diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100755 index 0000000..5d51129 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,34 @@ +name: Build Action + +on: + push: + branches: + - main + - releases/* + - v2-preview + paths-ignore: + - '**.md' + pull_request: + paths-ignore: + - '**.md' + +jobs: + build: + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + steps: + - uses: actions/checkout@v2 + - name: Setup Node.JS 12 + uses: actions/setup-node@v2 + with: + node-version: 12.x + - run: npm ci + - run: npm run build + - run: npm run format-check + - run: npm test + - name: Verify no unstaged changes + if: runner.os != 'windows' + run: bash __tests__/verify-no-unstaged-changes.sh diff --git a/.github/workflows/e2e-local-file.yml b/.github/workflows/e2e-local-file.yml new file mode 100644 index 0000000..39a09d2 --- /dev/null +++ b/.github/workflows/e2e-local-file.yml @@ -0,0 +1,87 @@ +name: Validate local file +on: + push: + branches: + - main + - releases/* + - v2-preview + paths-ignore: + - '**.md' + pull_request: + paths-ignore: + - '**.md' + +jobs: + setup-java-local-file-adopt: + name: Validate installation from local file Adopt + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [macos-latest, windows-latest, ubuntu-latest] + steps: + - name: Checkout + uses: actions/checkout@v2 + - name: Download Adopt OpenJDK file + run: | + if ($IsLinux) { + $downloadUrl = "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.10%2B9/OpenJDK11U-jdk_x64_linux_hotspot_11.0.10_9.tar.gz" + $localFilename = "java_package.tar.gz" + } elseif ($IsMacOS) { + $downloadUrl = "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.10%2B9/OpenJDK11U-jdk_x64_mac_hotspot_11.0.10_9.tar.gz" + $localFilename = "java_package.tar.gz" + } elseif ($IsWindows) { + $downloadUrl = "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.10%2B9/OpenJDK11U-jdk_x64_windows_hotspot_11.0.10_9.zip" + $localFilename = "java_package.zip" + } + echo "LocalFilename=$localFilename" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append + (New-Object System.Net.WebClient).DownloadFile($downloadUrl, "$env:RUNNER_TEMP/$localFilename") + shell: pwsh + - name: setup-java + uses: ./ + id: setup-java + with: + distribution: 'jdkfile' + jdkFile: ${{ runner.temp }}/${{ env.LocalFilename }} + java-version: '11.0.0-ea' + architecture: x64 + - name: Verify Java version + run: bash __tests__/verify-java.sh "11.0.10" "${{ steps.setup-java.outputs.path }}" + shell: bash + + setup-java-local-file-zulu: + name: Validate installation from local file Zulu + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [macos-latest, windows-latest, ubuntu-latest] + steps: + - name: Checkout + uses: actions/checkout@v2 + - name: Download Zulu OpenJDK file + run: | + if ($IsLinux) { + $downloadUrl = "https://cdn.azul.com/zulu/bin/zulu11.2.3-jdk11.0.1-linux_x64.tar.gz" + $localFilename = "java_package.tar.gz" + } elseif ($IsMacOS) { + $downloadUrl = "https://cdn.azul.com/zulu/bin/zulu11.2.3-jdk11.0.1-macosx_x64.tar.gz" + $localFilename = "java_package.tar.gz" + } elseif ($IsWindows) { + $downloadUrl = "https://cdn.azul.com/zulu/bin/zulu11.45.27-ca-jdk11.0.10-win_x64.zip" + $localFilename = "java_package.zip" + } + echo "LocalFilename=$localFilename" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append + (New-Object System.Net.WebClient).DownloadFile($downloadUrl, "$env:RUNNER_TEMP/$localFilename") + shell: pwsh + - name: setup-java + uses: ./ + id: setup-java + with: + distribution: 'jdkfile' + jdkFile: ${{ runner.temp }}/${{ env.LocalFilename }} + java-version: '11.0.0-ea' + architecture: x64 + - name: Verify Java version + run: bash __tests__/verify-java.sh "11.0" "${{ steps.setup-java.outputs.path }}" + shell: bash \ No newline at end of file diff --git a/.github/workflows/e2e-publishing.yml b/.github/workflows/e2e-publishing.yml new file mode 100644 index 0000000..2405e41 --- /dev/null +++ b/.github/workflows/e2e-publishing.yml @@ -0,0 +1,83 @@ +name: Validate publishing functionality +on: + push: + branches: + - main + - releases/* + - v2-preview + paths-ignore: + - '**.md' + pull_request: + paths-ignore: + - '**.md' + +jobs: + setup-java-publishing: + name: Validate settings.xml + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [macos-latest, windows-latest, ubuntu-latest] + steps: + - name: Checkout + uses: actions/checkout@v2 + - name: setup-java + uses: ./ + id: setup-java + with: + distribution: 'adopt' + java-version: '11' + server-id: maven + server-username: MAVEN_USERNAME + server-password: MAVEN_CENTRAL_TOKEN + gpg-passphrase: MAVEN_GPG_PASSPHRASE + - name: Validate settings.xml + run: | + $homePath = $env:USERPROFILE + if (-not $homePath) { + $homePath = $env:HOME + } + $xmlPath = Join-Path $homePath ".m2" "settings.xml" + + Get-Content $xmlPath | ForEach-Object { Write-Host $_ } + + [xml]$xml = Get-Content $xmlPath + $servers = $xml.settings.servers.server + if (($servers[0].id -ne 'maven') -or ($servers[0].username -ne '${env.MAVEN_USERNAME}') -or ($servers[0].password -ne '${env.MAVEN_CENTRAL_TOKEN}')) { + throw "Generated XML file is incorrect" + } + + if (($servers[1].id -ne 'gpg.passphrase') -or ($servers[1].passphrase -ne '${env.MAVEN_GPG_PASSPHRASE}')) { + throw "Generated XML file is incorrect" + } + shell: pwsh + + test-publishing-custom-location: + name: Validate settings.xml in custom location + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [macos-latest, windows-latest, ubuntu-latest] + steps: + - name: Checkout + uses: actions/checkout@v2 + - name: setup-java + uses: ./ + id: setup-java + with: + distribution: 'adopt' + java-version: '11' + server-id: maven + server-username: MAVEN_USERNAME + server-password: MAVEN_CENTRAL_TOKEN + gpg-passphrase: MAVEN_GPG_PASSPHRASE + settings-path: ${{ runner.temp }} + - name: Validate settings.xml location + run: | + $path = Join-Path $env:RUNNER_TEMP "settings.xml" + if (-not (Test-Path $path)) { + throw "settings.xml file is not found in expected location" + } + shell: pwsh \ No newline at end of file diff --git a/.github/workflows/e2e-versions.yml b/.github/workflows/e2e-versions.yml new file mode 100644 index 0000000..40b2b47 --- /dev/null +++ b/.github/workflows/e2e-versions.yml @@ -0,0 +1,166 @@ +name: Validate Java e2e +on: + push: + branches: + - main + - releases/* + - v2-preview + paths-ignore: + - '**.md' + pull_request: + paths-ignore: + - '**.md' + +jobs: + setup-java-major-versions: + name: ${{ matrix.distribution }} ${{ matrix.version }} (jdk-x64) - ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [macos-latest, windows-latest, ubuntu-latest] + distribution: ['adopt', 'zulu'] + version: ['8', '11', '15'] + steps: + - name: Checkout + uses: actions/checkout@v2 + - name: setup-java + uses: ./ + id: setup-java + with: + java-version: ${{ matrix.version }} + distribution: ${{ matrix.distribution }} + - name: Verify Java + run: bash __tests__/verify-java.sh "${{ matrix.version }}" "${{ steps.setup-java.outputs.path }}" + shell: bash + + setup-java-major-minor-versions: + name: ${{ matrix.distribution }} ${{ matrix.version }} (jdk-x64) - ${{ matrix.os }} + needs: setup-java-major-versions + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [macos-latest, windows-latest, ubuntu-latest] + distribution: ['adopt', 'zulu'] + version: + - '11.0' + - '8.0.282' + - '11.0.2+7' + include: + - distribution: 'adopt' + version: '12.0.2+10.1' + os: macos-latest + - distribution: 'adopt' + version: '12.0.2+10.1' + os: windows-latest + - distribution: 'adopt' + version: '12.0.2+10.1' + os: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v2 + - name: setup-java + uses: ./ + id: setup-java + with: + java-version: ${{ matrix.version }} + distribution: ${{ matrix.distribution }} + - name: Verify Java + run: bash __tests__/verify-java.sh "${{ matrix.version }}" "${{ steps.setup-java.outputs.path }}" + shell: bash + + setup-java-ea-versions-zulu: + name: zulu ${{ matrix.version }} (jdk-x64) - ${{ matrix.os }} + needs: setup-java-major-minor-versions + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [macos-latest, windows-latest, ubuntu-latest] + version: ['17-ea', '15.0.0-ea.14'] + steps: + - name: Checkout + uses: actions/checkout@v2 + - name: setup-java + uses: ./ + id: setup-java + with: + java-version: ${{ matrix.version }} + distribution: zulu + + setup-java-ea-versions-adopt: + name: adopt ${{ matrix.version }} (jdk-x64) - ${{ matrix.os }} + needs: setup-java-major-minor-versions + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [macos-latest, windows-latest, ubuntu-latest] + version: ['17-ea', '15.0.0-ea.14.1.202003160455'] + steps: + - name: Checkout + uses: actions/checkout@v2 + - name: setup-java + uses: ./ + id: setup-java + with: + java-version: ${{ matrix.version }} + distribution: adopt + + setup-java-custom-package-type: + name: ${{ matrix.distribution }} ${{ matrix.version }} (${{ matrix.java-package }}-x64) - ${{ matrix.os }} + needs: setup-java-major-minor-versions + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [macos-latest, windows-latest, ubuntu-latest] + distribution: ['adopt', 'zulu'] + java-package: ['jre'] + version: + - '15.0' + include: + - distribution: 'zulu' + java-package: jre+fx + version: '8' + os: ubuntu-latest + - distribution: 'zulu' + java-package: jdk+fx + version: '8.0.242' + os: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v2 + - name: setup-java + uses: ./ + id: setup-java + with: + java-version: ${{ matrix.version }} + java-package: ${{ matrix.java-package }} + distribution: ${{ matrix.distribution }} + - name: Verify Java + run: bash __tests__/verify-java.sh "${{ matrix.version }}" "${{ steps.setup-java.outputs.path }}" + shell: bash + + setup-java-custom-architecture: + name: ${{ matrix.distribution }} ${{ matrix.version }} (jdk-x86) - ${{ matrix.os }} + needs: setup-java-major-minor-versions + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + # Only Zulu provides x86 arch for now and only for windows / ubuntu + os: [windows-latest, ubuntu-latest] + distribution: ['zulu'] + version: ['11'] + steps: + - name: Checkout + uses: actions/checkout@v2 + - name: setup-java + uses: ./ + id: setup-java + with: + distribution: ${{ matrix.distribution }} + java-version: ${{ matrix.version }} + architecture: x86 \ No newline at end of file diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml deleted file mode 100644 index 1b7aa65..0000000 --- a/.github/workflows/workflow.yml +++ /dev/null @@ -1,88 +0,0 @@ -name: Main workflow -on: [push, pull_request] -jobs: - build: - runs-on: ${{ matrix.operating-system }} - strategy: - matrix: - operating-system: [ubuntu-latest, windows-latest] - steps: - - name: Checkout - uses: actions/checkout@v2 - - name: Setup Node.js 12 - uses: actions/setup-node@v1 - with: - node-version: 12.x - - name: npm install - run: npm install - - name: Lint - run: npm run format-check - - name: npm test - run: npm test - - test: - runs-on: ${{ matrix.operating-system }} - strategy: - matrix: - operating-system: [ubuntu-latest, windows-latest] - steps: - - name: Checkout - uses: actions/checkout@v2 - - name: Clear tool cache - if: runner.os != 'windows' - run: mv "${{ runner.tool_cache }}" "${{ runner.tool_cache }}.old" - - name: Clear tool cache (Windows) - if: runner.os == 'windows' - run: move "${{ runner.tool_cache }}" "${{ runner.tool_cache }}.old" - - name: Setup Java 13 - id: setup-java - uses: ./ - with: - java-version: 13.0.2 - - name: Verify Java 13 - if: runner.os != 'windows' - run: __tests__/verify-java.sh 13.0.2 "${{ steps.setup-java.outputs.path }}" "${{ steps.setup-java.outputs.version }}" - - name: Verify Java 13 (Windows) - if: runner.os == 'windows' - run: __tests__/verify-java.ps1 13.0.2 "${{ steps.setup-java.outputs.path }}" "${{ steps.setup-java.outputs.version }}" - - test-proxy: - runs-on: ubuntu-latest - container: - image: ubuntu:latest - options: --dns 127.0.0.1 - services: - squid-proxy: - image: datadog/squid:latest - ports: - - 3128:3128 - env: - https_proxy: http://squid-proxy:3128 - steps: - - uses: actions/checkout@v2 - - name: Clear tool cache - run: rm -rf $RUNNER_TOOL_CACHE/* - - name: Setup Java 13 - id: setup-java - uses: ./ - with: - java-version: 13.0.2 - - name: Verify Java 13 - run: __tests__/verify-java.sh 13.0.2 "${{ steps.setup-java.outputs.path }}" "${{ steps.setup-java.outputs.version }}" - - test-bypass-proxy: - runs-on: ubuntu-latest - env: - https_proxy: http://no-such-proxy:3128 - no_proxy: github.com,static.azul.com - steps: - - uses: actions/checkout@v2 - - name: Clear tool cache - run: rm -rf $RUNNER_TOOL_CACHE/* - - name: Setup Java 13 - id: setup-java - uses: ./ - with: - java-version: 13.0.2 - - name: Verify Java 13 - run: __tests__/verify-java.sh 13.0.2 "${{ steps.setup-java.outputs.path }}" "${{ steps.setup-java.outputs.version }}" diff --git a/.prettierrc.json b/.prettierrc.json index f6736bc..a2f723b 100644 --- a/.prettierrc.json +++ b/.prettierrc.json @@ -1,11 +1,11 @@ { - "printWidth": 80, - "tabWidth": 2, - "useTabs": false, - "semi": true, - "singleQuote": true, - "trailingComma": "none", - "bracketSpacing": false, - "arrowParens": "avoid", - "parser": "typescript" - } \ No newline at end of file + "printWidth": 100, + "tabWidth": 2, + "useTabs": false, + "semi": true, + "singleQuote": true, + "trailingComma": "none", + "bracketSpacing": true, + "arrowParens": "avoid", + "parser": "typescript" +} diff --git a/README.md b/README.md index 14e6d77..b109577 100644 --- a/README.md +++ b/README.md @@ -4,252 +4,85 @@ GitHub Actions status

-This action sets up a java environment for use in actions by: +This action provides the following functionality for GitHub Actions runners: +- Downloading and setting up a requested version of Java. See [Usage](#Usage) for a list of supported distributions +- Extracting and caching custom version of Java from a local file +- Configuring runner for publishing using Apache Maven +- Configuring runner for publishing using Gradle +- Configuring runner for using GPG private key +- Registering problem matchers for error output -- optionally downloading and caching a requested version of java by version and adding to PATH. Default downloads are populated from the [Zulu Community distribution of OpenJDK](http://static.azul.com/zulu/bin/) -- registering problem matchers for error output +## V2 vs V1 +- V2 supports custom distributions and provides support for Zulu OpenJDK and Adopt OpenJDK out of the box. V1 supports only Zulu OpenJDK +- V2 requires you to specify distribution along with the version. V1 defaults to Zulu OpenJDK, only version input is required. Follow [the migration guide](docs/switching-to-v2.md) to switch from V1 to V2 -# Usage +## Usage +Inputs `java-version` and `distribution` are mandatory. See [Supported distributions](../README.md#Supported-distributions) section for a list of available options. -See [action.yml](action.yml) - -## Basic +### Basic ```yaml steps: - uses: actions/checkout@v2 -- uses: actions/setup-java@v1 +- uses: actions/setup-java@v2-preview with: - java-version: '9.0.4' # The JDK version to make available on the path. - java-package: jdk # (jre, jdk, or jdk+fx) - defaults to jdk - architecture: x64 # (x64 or x86) - defaults to x64 -- run: java -cp java HelloWorldApp -``` -Examples of version specifications that the java-version parameter will accept: - -- A major Java version - - e.g. ```6, 7, 8, 9, 10, 11, 12, 13, ...``` - -- A semver Java version specification - - e.g. ```8.0.232, 7.0.181, 11.0.4``` - - e.g. ```8.0.x, >11.0.3, >=13.0.1, <8.0.212``` - -- An early access (EA) Java version - - e.g. ```14-ea, 15-ea``` - - e.g. ```14.0.0-ea, 15.0.0-ea``` - - e.g. ```14.0.0-ea.28, 15.0.0-ea.2``` (syntax for specifying an EA build number) - - Note that, per semver rules, EA builds will be matched by explicit EA version specifications. - -- 1.x syntax - - e.g. ```1.8``` (same as ```8```) - - e.g. ```1.8.0.212``` (same as ```8.0.212```) - - -## Local file -```yaml -steps: -- uses: actions/checkout@v2 -- uses: actions/setup-java@v1 - with: - java-version: '4.0.0' - architecture: x64 - jdkFile: # Optional - jdkFile to install java from. Useful for versions not found on Zulu Community CDN + distribution: 'adopt' # See 'Supported distributions' for available options + java-version: '11' - run: java -cp java HelloWorldApp ``` -## Matrix Testing +#### Supported version syntax +The `java-version` input supports an exact version or a version range using [SemVer](https://semver.org/) notation: +- major versions: `8`, `11`, `15` +- more specific versions: `11.0`, `11.0.4`, `8.0.232`, `8.0.282+8` +- early access (EA) versions: `15-ea`, `15.0.0-ea`, `15.0.0-ea.2`, `15.0.0+2-ea` + +**Note:** 4-digit notation will always force action to skip checking pre-cached versions and download version in runtime. + +#### Supported distributions +Currently, the following distributions are supported: +| Keyword | Distribution | Official site | License | +|-|-|-|-| +| `zulu` | Zulu OpenJDK | [Link](https://www.azul.com/downloads/zulu-community/?package=jdk) | [Link](https://www.azul.com/products/zulu-and-zulu-enterprise/zulu-terms-of-use/) | +| `adopt` | Adopt OpenJDK | [Link](https://adoptopenjdk.net/) | [Link](https://adoptopenjdk.net/about.html) + +**NOTE:** The different distributors can provide discrepant list of available versions / supported configurations. Please refer to the official documentation to see the list of supported versions. + +#### Testing against different Java versions ```yaml jobs: build: - runs-on: ubuntu-16.04 + runs-on: ubuntu-20.04 strategy: matrix: - # test against latest update of each major Java version, as well as specific updates of LTS versions: - java: [ 1.6, 6.0.83, 7, 7.0.181, 8, 8.0.192, 9.0.x, 10, 11.0.x, 11.0.3, 12, 13 ] - name: Java ${{ matrix.java }} sample + java: [ '8', '11', '13', '15' ] + name: Java ${{ matrix.Java }} sample steps: - uses: actions/checkout@v2 - name: Setup java - uses: actions/setup-java@v1 + uses: actions/setup-java@v2-preview with: + distribution: '' java-version: ${{ matrix.java }} - run: java -cp java HelloWorldApp ``` -## Publishing using Apache Maven +### Advanced +- [Selecting a Java distribution](docs/advanced-usage.md#Selecting-a-Java-distribution) + - [Adopt](docs/advanced-usage.md#Adopt) + - [Zulu](docs/advanced-usage.md#Zulu) +- [Installing custom Java package type](docs/advanced-usage.md#Installing-custom-Java-package-type) +- [Installing custom Java architecture](docs/advanced-usage.md#Installing-custom-Java-architecture) +- [Installing custom Java distribution from local file](docs/advanced-usage.md#Installing-Java-from-local-file) +- [Testing against different Java distributions](docs/advanced-usage.md#Testing-against-different-Java-distributions) +- [Testing against different platforms](docs/advanced-usage.md#Testing-against-different-platforms) +- [Publishing using Apache Maven](docs/advanced-usage.md#Publishing-using-Apache-Maven) +- [Publishing using Gradle](docs/advanced-usage.md#Publishing-using-Gradle) -### Extra setup for pom.xml: -The Maven GPG Plugin configuration in the pom.xml file should contain the following structure to avoid possible issues like `Inappropriate ioctl for device` or `gpg: signing failed: No such file or directory`: - -```xml - - - - --pinentry-mode - loopback - - -``` -GPG 2.1 requires `--pinentry-mode` to be set to `loopback` in order to pick up the `gpg.passphrase` value defined in Maven `settings.xml`. - -### Yaml example: -```yaml -jobs: - build: - - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - name: Set up JDK 1.8 - uses: actions/setup-java@v1 - with: - java-version: 1.8 - - - name: Build with Maven - run: mvn -B package --file pom.xml - - - name: Publish to GitHub Packages Apache Maven - run: mvn deploy - env: - GITHUB_TOKEN: ${{ github.token }} # GITHUB_TOKEN is the default env for the password - - - name: Set up Apache Maven Central - uses: actions/setup-java@v1 - with: # running setup-java again overwrites the settings.xml - java-version: 1.8 - server-id: maven # Value of the distributionManagement/repository/id field of the pom.xml - server-username: MAVEN_USERNAME # env variable for username in deploy - server-password: MAVEN_CENTRAL_TOKEN # env variable for token in deploy - gpg-private-key: ${{ secrets.MAVEN_GPG_PRIVATE_KEY }} # Value of the GPG private key to import - gpg-passphrase: MAVEN_GPG_PASSPHRASE # env variable for GPG private key passphrase - - - name: Publish to Apache Maven Central - run: mvn deploy - env: - MAVEN_USERNAME: maven_username123 - MAVEN_CENTRAL_TOKEN: ${{ secrets.MAVEN_CENTRAL_TOKEN }} - MAVEN_GPG_PASSPHRASE: ${{ secrets.MAVEN_GPG_PASSPHRASE }} -``` - -The two `settings.xml` files created from the above example look like the following. - -`settings.xml` file created for the first deploy to GitHub Packages -```xml - - - - github - ${env.GITHUB_ACTOR} - ${env.GITHUB_TOKEN} - - - gpg.passphrase - ${env.GPG_PASSPHRASE} - - - -``` - -`settings.xml` file created for the second deploy to Apache Maven Central -```xml - - - - maven - ${env.MAVEN_USERNAME} - ${env.MAVEN_CENTRAL_TOKEN} - - - gpg.passphrase - ${env.MAVEN_GPG_PASSPHRASE} - - - -``` - -***NOTE: The `settings.xml` file is created in the Actions $HOME/.m2 directory. If you have an existing `settings.xml` file at that location, it will be overwritten. See below for using the `settings-path` to change your `settings.xml` file location.*** - -### GPG - -If `gpg-private-key` input is provided, the private key will be written to a file in the runner's temp directory, the private key file will be imported into the GPG keychain, and then the file will be promptly removed before proceeding with the rest of the setup process. A cleanup step will remove the imported private key from the GPG keychain after the job completes regardless of the job status. This ensures that the private key is no longer accessible on self-hosted runners and cannot "leak" between jobs (hosted runners are always clean instances). - -**GPG key should be exported by: `gpg --armor --export-secret-keys YOUR_ID`** - -See the help docs on [Publishing a Package](https://help.github.com/en/github/managing-packages-with-github-packages/configuring-apache-maven-for-use-with-github-packages#publishing-a-package) for more information on the `pom.xml` file. - -## Publishing using Gradle -```yaml -jobs: - - build: - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - - name: Set up JDK 1.8 - uses: actions/setup-java@v1 - - - name: Build with Gradle - run: gradle build - - - name: Publish to GitHub Packages - run: gradle publish - env: - USERNAME: ${{ github.actor }} - PASSWORD: ${{ secrets.GITHUB_TOKEN }} -``` - -***NOTE: The `USERNAME` and `PASSWORD` need to correspond to the credentials environment variables used in the publishing section of your `build.gradle`.*** - -See the help docs on [Publishing a Package with Gradle](https://help.github.com/en/github/managing-packages-with-github-packages/configuring-gradle-for-use-with-github-packages#example-using-gradle-groovy-for-a-single-package-in-a-repository) for more information on the `build.gradle` configuration file. - -## Apache Maven with a settings path - -When using an Actions self-hosted runner with multiple shared runners the default `$HOME` directory can be shared by a number runners at the same time which could overwrite existing settings file. Setting the `settings-path` variable allows you to choose a unique location for your settings file. - -```yaml -jobs: - build: - - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - name: Set up JDK 1.8 for Shared Runner - uses: actions/setup-java@v1 - with: - java-version: 1.8 - server-id: github # Value of the distributionManagement/repository/id field of the pom.xml - settings-path: ${{ github.workspace }} # location for the settings.xml file - - - name: Build with Maven - run: mvn -B package --file pom.xml - - - name: Publish to GitHub Packages Apache Maven - run: mvn deploy -s $GITHUB_WORKSPACE/settings.xml - env: - GITHUB_TOKEN: ${{ github.token }} -``` - -# License +## License The scripts and documentation in this project are released under the [MIT License](LICENSE) -# Contributions +## Contributions Contributions are welcome! See [Contributor's Guide](docs/contributors.md) diff --git a/__tests__/auth.test.ts b/__tests__/auth.test.ts index b460e93..b45b510 100644 --- a/__tests__/auth.test.ts +++ b/__tests__/auth.test.ts @@ -1,14 +1,7 @@ import io = require('@actions/io'); import fs = require('fs'); -import os = require('os'); import path = require('path'); - -// make the os.homedir() call be local to the tests -jest.doMock('os', () => { - return { - homedir: jest.fn(() => __dirname) - }; -}); +import os from 'os'; import * as auth from '../src/auth'; @@ -16,8 +9,12 @@ const m2Dir = path.join(__dirname, auth.M2_DIR); const settingsFile = path.join(m2Dir, auth.SETTINGS_FILE); describe('auth tests', () => { + let spyOSHomedir: jest.SpyInstance; + beforeEach(async () => { await io.rmRF(m2Dir); + spyOSHomedir = jest.spyOn(os, 'homedir'); + spyOSHomedir.mockReturnValue(__dirname); }, 300000); afterAll(async () => { @@ -26,6 +23,9 @@ describe('auth tests', () => { } catch { console.log('Failed to remove test directories'); } + jest.resetAllMocks(); + jest.clearAllMocks(); + jest.restoreAllMocks(); }, 100000); it('creates settings.xml in alternate locations', async () => { @@ -38,7 +38,7 @@ describe('auth tests', () => { process.env[`INPUT_SETTINGS-PATH`] = altHome; await io.rmRF(altHome); // ensure it doesn't already exist - await auth.configAuthentication(id, username, password); + await auth.createAuthenticationSettings(id, username, password); expect(fs.existsSync(m2Dir)).toBe(false); expect(fs.existsSync(settingsFile)).toBe(false); @@ -58,13 +58,11 @@ describe('auth tests', () => { const username = 'UNAME'; const password = 'TOKEN'; - await auth.configAuthentication(id, username, password); + await auth.createAuthenticationSettings(id, username, password); expect(fs.existsSync(m2Dir)).toBe(true); expect(fs.existsSync(settingsFile)).toBe(true); - expect(fs.readFileSync(settingsFile, 'utf-8')).toEqual( - auth.generate(id, username, password) - ); + expect(fs.readFileSync(settingsFile, 'utf-8')).toEqual(auth.generate(id, username, password)); }, 100000); it('creates settings.xml with additional configuration', async () => { @@ -73,7 +71,7 @@ describe('auth tests', () => { const password = 'TOKEN'; const gpgPassphrase = 'GPG'; - await auth.configAuthentication(id, username, password, gpgPassphrase); + await auth.createAuthenticationSettings(id, username, password, gpgPassphrase); expect(fs.existsSync(m2Dir)).toBe(true); expect(fs.existsSync(settingsFile)).toBe(true); @@ -87,18 +85,16 @@ describe('auth tests', () => { const username = 'USERNAME'; const password = 'PASSWORD'; - fs.mkdirSync(m2Dir, {recursive: true}); + fs.mkdirSync(m2Dir, { recursive: true }); fs.writeFileSync(settingsFile, 'FAKE FILE'); expect(fs.existsSync(m2Dir)).toBe(true); expect(fs.existsSync(settingsFile)).toBe(true); - await auth.configAuthentication(id, username, password); + await auth.createAuthenticationSettings(id, username, password); expect(fs.existsSync(m2Dir)).toBe(true); expect(fs.existsSync(settingsFile)).toBe(true); - expect(fs.readFileSync(settingsFile, 'utf-8')).toEqual( - auth.generate(id, username, password) - ); + expect(fs.readFileSync(settingsFile, 'utf-8')).toEqual(auth.generate(id, username, password)); }, 100000); it('generates valid settings.xml with minimal configuration', () => { @@ -143,8 +139,6 @@ describe('auth tests', () => { `; - expect(auth.generate(id, username, password, gpgPassphrase)).toEqual( - expectedSettings - ); + expect(auth.generate(id, username, password, gpgPassphrase)).toEqual(expectedSettings); }); }); diff --git a/__tests__/data/adopt.json b/__tests__/data/adopt.json new file mode 100644 index 0000000..bcf1403 --- /dev/null +++ b/__tests__/data/adopt.json @@ -0,0 +1,909 @@ +[ + { + "binaries": [ + { + "architecture": "x64", + "download_count": 74181, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "09b7e6ab5d5eb4b73813f4caa793a0b616d33794a17988fa6a6b7c972e8f3dd3", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/download/jdk-14.0.2%2B12/OpenJDK14U-jdk_x64_mac_hotspot_14.0.2_12.tar.gz.sha256.txt", + "download_count": 23872, + "link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/download/jdk-14.0.2%2B12/OpenJDK14U-jdk_x64_mac_hotspot_14.0.2_12.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/download/jdk-14.0.2%2B12/OpenJDK14U-jdk_x64_mac_hotspot_14.0.2_12.tar.gz.json", + "name": "OpenJDK14U-jdk_x64_mac_hotspot_14.0.2_12.tar.gz", + "size": 195705010 + }, + "project": "jdk", + "scm_ref": "jdk-14.0.2+12_adopt", + "updated_at": "2020-07-16T08:55:45Z" + } + ], + "download_count": 477080, + "id": "MDc6UmVsZWFzZTI4NjIyMDc4.+ve8KojpqJUpsA==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/tag/jdk-14.0.2%2B12", + "release_name": "jdk-14.0.2+12", + "release_type": "ga", + "timestamp": "2020-07-16T08:54:16Z", + "updated_at": "2020-07-16T08:54:16Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 12, + "major": 14, + "minor": 0, + "openjdk_version": "14.0.2+12", + "security": 2, + "semver": "14.0.2+12" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 58023, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "b11cb192312530bcd84607631203d0c1727e672af12813078e6b525e3cce862d", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/download/jdk-14.0.1%2B7/OpenJDK14U-jdk_x64_mac_hotspot_14.0.1_7.tar.gz.sha256.txt", + "download_count": 25276, + "link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/download/jdk-14.0.1%2B7/OpenJDK14U-jdk_x64_mac_hotspot_14.0.1_7.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/download/jdk-14.0.1%2B7/OpenJDK14U-jdk_x64_mac_hotspot_14.0.1_7.tar.gz.json", + "name": "OpenJDK14U-jdk_x64_mac_hotspot_14.0.1_7.tar.gz", + "size": 195769653 + }, + "project": "jdk", + "scm_ref": "jdk-14.0.1+7_adopt", + "updated_at": "2020-04-20T12:54:23Z" + } + ], + "download_count": 198607, + "id": "MDc6UmVsZWFzZTI1Njc4MzEw.z3NqYG25PFlG+Q==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/tag/jdk-14.0.1%2B7", + "release_name": "jdk-14.0.1+7", + "release_type": "ga", + "timestamp": "2020-04-20T12:52:51Z", + "updated_at": "2020-04-20T12:52:51Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 1, + "build": 7, + "major": 14, + "minor": 0, + "openjdk_version": "14.0.1+7", + "security": 1, + "semver": "14.0.1+7.1" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 30069, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "d358a7ff03905282348c6c80562a4da2e04eb377b60ad2152be4c90f8d580b7f", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.2%2B7/OpenJDK15U-jdk_x64_mac_hotspot_15.0.2_7.tar.gz.sha256.txt", + "download_count": 3718, + "link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.2%2B7/OpenJDK15U-jdk_x64_mac_hotspot_15.0.2_7.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.2%2B7/OpenJDK15U-jdk_x64_mac_hotspot_15.0.2_7.tar.gz.json", + "name": "OpenJDK15U-jdk_x64_mac_hotspot_15.0.2_7.tar.gz", + "size": 195232978 + }, + "project": "jdk", + "scm_ref": "jdk-15.0.2+7_adopt", + "updated_at": "2021-01-22T17:33:20Z" + } + ], + "download_count": 124226, + "id": "MDc6UmVsZWFzZTM2NzgwOTAw.X2+6VqPND3E8CA==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/tag/jdk-15.0.2%2B7", + "release_name": "jdk-15.0.2+7", + "release_type": "ga", + "timestamp": "2021-01-22T17:31:37Z", + "updated_at": "2021-01-22T17:31:37Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 7, + "major": 15, + "minor": 0, + "openjdk_version": "15.0.2+7", + "security": 2, + "semver": "15.0.2+7" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 24542, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "b8c2e2ad31f3d6676ea665d9505b06df15e23741847556612b40e3ee329fc046", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.1%2B9.1/OpenJDK15U-jdk_x64_mac_hotspot_15.0.1_9.tar.gz.sha256.txt", + "download_count": 3274, + "link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.1%2B9.1/OpenJDK15U-jdk_x64_mac_hotspot_15.0.1_9.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.1%2B9.1/OpenJDK15U-jdk_x64_mac_hotspot_15.0.1_9.tar.gz.json", + "name": "OpenJDK15U-jdk_x64_mac_hotspot_15.0.1_9.tar.gz", + "size": 195872839 + }, + "project": "jdk", + "scm_ref": "jdk-15.0.1+9_adopt", + "updated_at": "2020-12-01T16:57:47Z" + } + ], + "download_count": 25378, + "id": "MDc6UmVsZWFzZTM0NjQ2MDU4.Yj2XZf+VBGAPtw==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/tag/jdk-15.0.1%2B9.1", + "release_name": "jdk-15.0.1+9.1", + "release_type": "ga", + "timestamp": "2020-12-01T16:57:26Z", + "updated_at": "2020-12-01T16:57:26Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 1, + "build": 9, + "major": 15, + "minor": 0, + "openjdk_version": "15.0.1+9", + "security": 1, + "semver": "15.0.1+9.1" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 21675, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "d32f9429c4992cef7be559a15c542011503d6bc38c89379800cd209a9d7ec539", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.1%2B9/OpenJDK15U-jdk_x64_mac_hotspot_15.0.1_9.tar.gz.sha256.txt", + "download_count": 11935, + "link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.1%2B9/OpenJDK15U-jdk_x64_mac_hotspot_15.0.1_9.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.1%2B9/OpenJDK15U-jdk_x64_mac_hotspot_15.0.1_9.tar.gz.json", + "name": "OpenJDK15U-jdk_x64_mac_hotspot_15.0.1_9.tar.gz", + "size": 195773522 + }, + "project": "jdk", + "scm_ref": "jdk-15.0.1+9_adopt", + "updated_at": "2020-10-23T20:48:09Z" + } + ], + "download_count": 308690, + "id": "MDc6UmVsZWFzZTMyOTk4MTUx.3oazo3YGfHhF3w==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/tag/jdk-15.0.1%2B9", + "release_name": "jdk-15.0.1+9", + "release_type": "ga", + "timestamp": "2020-10-23T20:46:22Z", + "updated_at": "2020-10-23T20:46:22Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 9, + "major": 15, + "minor": 0, + "openjdk_version": "15.0.1+9", + "security": 1, + "semver": "15.0.1+9" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 51254, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "bd1fc774232e2dfee93056a01f5765bd92ffb19d68dd548c233a82bb5c162be4", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15%2B36/OpenJDK15U-jdk_x64_mac_hotspot_15_36.tar.gz.sha256.txt", + "download_count": 5325, + "link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15%2B36/OpenJDK15U-jdk_x64_mac_hotspot_15_36.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15%2B36/OpenJDK15U-jdk_x64_mac_hotspot_15_36.tar.gz.json", + "name": "OpenJDK15U-jdk_x64_mac_hotspot_15_36.tar.gz", + "size": 195853361 + }, + "project": "jdk", + "scm_ref": "jdk-15+36_adopt", + "updated_at": "2020-09-17T07:43:54Z" + } + ], + "download_count": 157313, + "id": "MDc6UmVsZWFzZTMxNDUwMjA0.eYpt0EBEjldfEQ==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/tag/jdk-15%2B36", + "release_name": "jdk-15+36", + "release_type": "ga", + "timestamp": "2020-09-17T07:42:21Z", + "updated_at": "2020-09-17T07:42:21Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 36, + "major": 15, + "minor": 0, + "openjdk_version": "15+36", + "security": 0, + "semver": "15.0.0+36" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 27428, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "aabc3aebb0abf1ba64d9bd5796d0c7eb7239983f6e4c0f015b5b88be5616e4bd", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/download/jdk-14%2B36/OpenJDK14U-jdk_x64_mac_hotspot_14_36.tar.gz.sha256.txt", + "download_count": 19544, + "link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/download/jdk-14%2B36/OpenJDK14U-jdk_x64_mac_hotspot_14_36.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/download/jdk-14%2B36/OpenJDK14U-jdk_x64_mac_hotspot_14_36.tar.gz.json", + "name": "OpenJDK14U-jdk_x64_mac_hotspot_14_36.tar.gz", + "size": 201087797 + }, + "project": "jdk", + "scm_ref": "jdk-14+36_adopt", + "updated_at": "2020-03-18T12:13:05Z" + } + ], + "download_count": 364816, + "id": "MDc6UmVsZWFzZTI0NjMxMDAy.AY7rtvmrnWWlIg==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk14-binaries/releases/tag/jdk-14%2B36", + "release_name": "jdk-14+36", + "release_type": "ga", + "timestamp": "2020-03-18T12:11:08Z", + "updated_at": "2020-03-18T12:11:08Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 1, + "build": 36, + "major": 14, + "minor": 0, + "openjdk_version": "14+36", + "security": 0, + "semver": "14.0.0+36.1" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 63201, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "0ddb24efdf5aab541898d19b7667b149a1a64a8bd039b708fc58ee0284fa7e07", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/download/jdk-13.0.2%2B8/OpenJDK13U-jdk_x64_mac_hotspot_13.0.2_8.tar.gz.sha256.txt", + "download_count": 32531, + "link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/download/jdk-13.0.2%2B8/OpenJDK13U-jdk_x64_mac_hotspot_13.0.2_8.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/download/jdk-13.0.2%2B8/OpenJDK13U-jdk_x64_mac_hotspot_13.0.2_8.tar.gz.json", + "name": "OpenJDK13U-jdk_x64_mac_hotspot_13.0.2_8.tar.gz", + "size": 198206427 + }, + "project": "jdk", + "scm_ref": "jdk-13.0.2+8_adopt", + "updated_at": "2020-01-20T16:46:24Z" + } + ], + "download_count": 349677, + "id": "MDc6UmVsZWFzZTIyOTgxNTM1.gtZYwGfBgkb3Gg==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/tag/jdk-13.0.2%2B8", + "release_name": "jdk-13.0.2+8", + "release_type": "ga", + "timestamp": "2020-01-20T16:42:35Z", + "updated_at": "2020-01-20T16:42:35Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 1, + "build": 8, + "major": 13, + "minor": 0, + "openjdk_version": "13.0.2+8", + "security": 2, + "semver": "13.0.2+8.1" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 41508, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "9c82de98ce9bc2353bcf314d85366c9a2c572db034e10a71aa47e804e13748c1", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/download/jdk-13.0.1%2B9/OpenJDK13U-jdk_x64_mac_hotspot_13.0.1_9.tar.gz.sha256.txt", + "download_count": 32262, + "link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/download/jdk-13.0.1%2B9/OpenJDK13U-jdk_x64_mac_hotspot_13.0.1_9.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/download/jdk-13.0.1%2B9/OpenJDK13U-jdk_x64_mac_hotspot_13.0.1_9.tar.gz.json", + "name": "OpenJDK13U-jdk_x64_mac_hotspot_13.0.1_9.tar.gz", + "size": 198205689 + }, + "project": "jdk", + "scm_ref": "jdk-13.0.1+9_adopt", + "updated_at": "2019-10-26T14:44:27Z" + } + ], + "download_count": 680021, + "id": "MDc6UmVsZWFzZTIwOTk4NDA0.srlG2TmLho/j0w==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/tag/jdk-13.0.1%2B9", + "release_name": "jdk-13.0.1+9", + "release_type": "ga", + "timestamp": "2019-10-26T14:43:52Z", + "updated_at": "2019-10-26T14:43:52Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 1, + "build": 9, + "major": 13, + "minor": 0, + "openjdk_version": "13.0.1+9", + "security": 1, + "semver": "13.0.1+9.1" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 37738, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "f948be96daba250b6695e22cb51372d2ba3060e4d778dd09c89548889783099f", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/download/jdk-13%2B33/OpenJDK13U-jdk_x64_mac_hotspot_13_33.tar.gz.sha256.txt", + "download_count": 37738, + "link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/download/jdk-13%2B33/OpenJDK13U-jdk_x64_mac_hotspot_13_33.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/download/jdk-13%2B33/OpenJDK13U-jdk_x64_mac_hotspot_13_33.tar.gz.json", + "name": "OpenJDK13U-jdk_x64_mac_hotspot_13_33.tar.gz", + "size": 198189530 + }, + "project": "jdk", + "scm_ref": "jdk-13+33_adopt", + "updated_at": "2019-09-19T10:20:21Z" + } + ], + "download_count": 226200, + "id": "MDc6UmVsZWFzZTIwMTA0MTUy.trK7qCbNtlMWFw==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk13-binaries/releases/tag/jdk-13%2B33", + "release_name": "jdk-13+33", + "release_type": "ga", + "timestamp": "2019-09-19T10:19:58Z", + "updated_at": "2019-09-19T10:19:58Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 1, + "build": 33, + "major": 13, + "minor": 0, + "openjdk_version": "13+33", + "security": 0, + "semver": "13.0.0+33.1" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 24493, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "9919eee037554d40c7d2f219bbd654f2bf119e16a2f4d284d8dedaf525ee59e6", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz.sha256.txt", + "download_count": 22907, + "link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz.json", + "name": "OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz", + "size": 198392994 + }, + "project": "jdk", + "scm_ref": "jdk-12.0.2+10_adopt", + "updated_at": "2019-07-18T20:27:24Z" + } + ], + "download_count": 396318, + "id": "MDc6UmVsZWFzZTE4NzE2Mzk5.S/VUFSgnrVIv8A==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/tag/jdk-12.0.2%2B10", + "release_name": "jdk-12.0.2+10", + "release_type": "ga", + "timestamp": "2019-07-18T20:26:29Z", + "updated_at": "2019-07-18T20:26:29Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 1, + "build": 10, + "major": 12, + "minor": 0, + "openjdk_version": "12.0.2+10", + "security": 2, + "semver": "12.0.2+10.1" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 5539, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "7acd697e816491d31b24d0ae1867fd63060aa738cfa388757946ae312a60b4f2", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10.3/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz.sha256.txt", + "download_count": 5539, + "link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10.3/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10.3/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz.json", + "name": "OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz", + "size": 198429049 + }, + "project": "jdk", + "scm_ref": "jdk-12.0.2+10_adopt", + "updated_at": "2019-09-19T17:17:37Z" + } + ], + "download_count": 5879, + "id": "MDc6UmVsZWFzZTIwMTE2ODQ3.QGQl8Nj1qkma4Q==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/tag/jdk-12.0.2%2B10.3", + "release_name": "jdk-12.0.2+10.3", + "release_type": "ga", + "timestamp": "2019-09-19T17:17:26Z", + "updated_at": "2019-12-06T15:10:37Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 3, + "build": 10, + "major": 12, + "minor": 0, + "openjdk_version": "12.0.2+10", + "security": 2, + "semver": "12.0.2+10.3" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 22794, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "2c1a46c0fab6d4bdbc443f23c3f6a313c2de47fbbd9c16b5c1133a88f6c1ab8f", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10.2/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz.sha256.txt", + "download_count": 637, + "link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10.2/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10.2/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz.json", + "name": "OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz", + "size": 198862174 + }, + "project": "jdk", + "scm_ref": "jdk-12.0.2+10_adopt", + "updated_at": "2019-08-06T10:41:10Z" + } + ], + "download_count": 23563, + "id": "MDc6UmVsZWFzZTE5MTAzMTI3.in65dKG+veAxOg==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/tag/jdk-12.0.2%2B10.2", + "release_name": "jdk-12.0.2+10.2", + "release_type": "ga", + "timestamp": "2019-08-06T10:40:44Z", + "updated_at": "2019-08-06T10:40:44Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 2, + "build": 10, + "major": 12, + "minor": 0, + "openjdk_version": "12.0.2+10", + "security": 2, + "semver": "12.0.2+10.2" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 24493, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "9919eee037554d40c7d2f219bbd654f2bf119e16a2f4d284d8dedaf525ee59e6", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz.sha256.txt", + "download_count": 22907, + "link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.2%2B10/OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz.json", + "name": "OpenJDK12U-jdk_x64_mac_hotspot_12.0.2_10.tar.gz", + "size": 198392994 + }, + "project": "jdk", + "scm_ref": "jdk-12.0.2+9_adopt", + "updated_at": "2019-07-18T20:27:24Z" + } + ], + "download_count": 396318, + "id": "MDc6UmVsZWFzZTE4NzE2Mzk5.S/VUFSgnrVIv8A==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/tag/jdk-12.0.2%2B10", + "release_name": "jdk-12.0.2+9", + "release_type": "ga", + "timestamp": "2019-07-18T20:26:29Z", + "updated_at": "2019-07-18T20:26:29Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 1, + "build": 10, + "major": 12, + "minor": 0, + "openjdk_version": "12.0.2+9", + "security": 2, + "semver": "12.0.2+9.1" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 39519, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "dcb2ab681247298eda018df24166ba01674127083fb02892acf087e6181d8c56", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.1%2B12/OpenJDK12U-jdk_x64_mac_hotspot_12.0.1_12.tar.gz.sha256.txt", + "download_count": 33306, + "link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12.0.1%2B12/OpenJDK12U-jdk_x64_mac_hotspot_12.0.1_12.tar.gz", + "name": "OpenJDK12U-jdk_x64_mac_hotspot_12.0.1_12.tar.gz", + "size": 198112975 + }, + "project": "jdk", + "updated_at": "2019-04-21T15:12:34Z" + } + ], + "download_count": 1038669, + "id": "MDc6UmVsZWFzZTE2ODg3NDU3", + "release_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/tag/jdk-12.0.1%2B12", + "release_name": "jdk-12.0.1+12", + "release_type": "ga", + "timestamp": "2019-04-21T15:11:56Z", + "updated_at": "2019-04-21T15:11:56Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 12, + "major": 12, + "minor": 0, + "openjdk_version": "12.0.1+12", + "security": 1, + "semver": "12.0.1+12" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 3136, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "985036459d4ef0867a3fe83b0bf87877d8e66a121c7b9c145bb97bd921aaf3f1", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12%2B33/OpenJDK12U-jdk_x64_mac_hotspot_12_33.tar.gz.sha256.txt", + "download_count": 1905, + "link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/download/jdk-12%2B33/OpenJDK12U-jdk_x64_mac_hotspot_12_33.tar.gz", + "name": "OpenJDK12U-jdk_x64_mac_hotspot_12_33.tar.gz", + "size": 198099074 + }, + "project": "jdk", + "updated_at": "2019-03-22T12:09:13Z" + } + ], + "download_count": 757289, + "id": "MDc6UmVsZWFzZTE2MjgyMjM2", + "release_link": "https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/tag/jdk-12%2B33", + "release_name": "jdk-12+33", + "release_type": "ga", + "timestamp": "2019-03-22T12:08:43Z", + "updated_at": "2019-03-22T12:08:43Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 33, + "major": 12, + "minor": 0, + "openjdk_version": "12+33", + "security": 0, + "semver": "12.0.0+33" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 75576, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "ee7c98c9d79689aca6e717965747b8bf4eec5413e89d5444cc2bd6dbd59e3811", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.10%2B9/OpenJDK11U-jdk_x64_mac_hotspot_11.0.10_9.tar.gz.sha256.txt", + "download_count": 17426, + "link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.10%2B9/OpenJDK11U-jdk_x64_mac_hotspot_11.0.10_9.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.10%2B9/OpenJDK11U-jdk_x64_mac_hotspot_11.0.10_9.tar.gz.json", + "name": "OpenJDK11U-jdk_x64_mac_hotspot_11.0.10_9.tar.gz", + "size": 186160219 + }, + "project": "jdk", + "scm_ref": "jdk-11.0.10+9_adopt", + "updated_at": "2021-01-22T14:16:47Z" + } + ], + "download_count": 636180, + "id": "MDc6UmVsZWFzZTM2NzcwNDUy.hAVJRiZZTufG+w==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/tag/jdk-11.0.10%2B9", + "release_name": "jdk-11.0.10+9", + "release_type": "ga", + "timestamp": "2021-01-22T14:15:12Z", + "updated_at": "2021-01-22T14:15:12Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 9, + "major": 11, + "minor": 0, + "openjdk_version": "11.0.10+9", + "security": 10, + "semver": "11.0.10+9" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 108441, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "96bc469f9b02a3b84382a0685b0bd7935e1ad1bd82a0aab9befb5b42a17cbd77", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.9.1%2B1/OpenJDK11U-jdk_x64_mac_hotspot_11.0.9.1_1.tar.gz.sha256.txt", + "download_count": 22211, + "link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.9.1%2B1/OpenJDK11U-jdk_x64_mac_hotspot_11.0.9.1_1.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.9.1%2B1/OpenJDK11U-jdk_x64_mac_hotspot_11.0.9.1_1.tar.gz.json", + "name": "OpenJDK11U-jdk_x64_mac_hotspot_11.0.9.1_1.tar.gz", + "size": 185368626 + }, + "project": "jdk", + "scm_ref": "jdk-11.0.9.1+1_adopt", + "updated_at": "2020-11-12T14:10:45Z" + } + ], + "download_count": 815676, + "id": "MDc6UmVsZWFzZTMzODU4MDE1.94IbKUd3vvhzsA==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/tag/jdk-11.0.9.1%2B1", + "release_name": "jdk-11.0.9.1+1", + "release_type": "ga", + "timestamp": "2020-11-12T14:08:55Z", + "updated_at": "2020-11-12T14:08:55Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 1, + "major": 11, + "minor": 0, + "openjdk_version": "11.0.9.1+1", + "patch": 1, + "security": 9, + "semver": "11.0.9+101" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 45450, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "7b21961ffb2649e572721a0dfad64169b490e987937b661cb4e13a594c21e764", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.9%2B11.1/OpenJDK11U-jdk_x64_mac_hotspot_11.0.9_11.tar.gz.sha256.txt", + "download_count": 11117, + "link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.9%2B11.1/OpenJDK11U-jdk_x64_mac_hotspot_11.0.9_11.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.9%2B11.1/OpenJDK11U-jdk_x64_mac_hotspot_11.0.9_11.tar.gz.json", + "name": "OpenJDK11U-jdk_x64_mac_hotspot_11.0.9_11.tar.gz", + "size": 186006796 + }, + "project": "jdk", + "scm_ref": "jdk-11.0.9+11_adopt", + "updated_at": "2020-10-25T14:43:54Z" + } + ], + "download_count": 423635, + "id": "MDc6UmVsZWFzZTMzMDI4MDcz.dRvNNRwJCgY3Xw==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/tag/jdk-11.0.9%2B11.1", + "release_name": "jdk-11.0.9+11.1", + "release_type": "ga", + "timestamp": "2020-10-25T13:31:15Z", + "updated_at": "2020-10-25T13:31:15Z", + "vendor": "adoptopenjdk", + "version_data": { + "adopt_build_number": 1, + "build": 11, + "major": 11, + "minor": 0, + "openjdk_version": "11.0.9+11", + "security": 9, + "semver": "11.0.9+11.1" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 2456, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "e84b00d74f08f059829bbf121c8423dc37ff65135968c1fcda5839600be4f542", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.9%2B11/OpenJDK11U-jdk_x64_mac_hotspot_11.0.9_11.tar.gz.sha256.txt", + "download_count": 1046, + "link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.9%2B11/OpenJDK11U-jdk_x64_mac_hotspot_11.0.9_11.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.9%2B11/OpenJDK11U-jdk_x64_mac_hotspot_11.0.9_11.tar.gz.json", + "name": "OpenJDK11U-jdk_x64_mac_hotspot_11.0.9_11.tar.gz", + "size": 185532704 + }, + "project": "jdk", + "scm_ref": "jdk-11.0.9+11_adopt", + "updated_at": "2020-10-25T13:28:33Z" + } + ], + "download_count": 359580, + "id": "MDc6UmVsZWFzZTMyOTk4MzM5.6h9TT9pzYTK2Kg==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/tag/jdk-11.0.9%2B11", + "release_name": "jdk-11.0.9+11", + "release_type": "ga", + "timestamp": "2020-10-23T20:52:14Z", + "updated_at": "2020-10-23T20:52:14Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 11, + "major": 11, + "minor": 0, + "openjdk_version": "11.0.9+11", + "security": 9, + "semver": "11.0.9+11" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 149393, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "4a8dadd58cdc32c7e59978971d56aec610be7ee0ddf0dc1d137bb8b78456499f", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.8%2B10/OpenJDK11U-jdk_x64_mac_hotspot_11.0.8_10.tar.gz.sha256.txt", + "download_count": 40158, + "link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.8%2B10/OpenJDK11U-jdk_x64_mac_hotspot_11.0.8_10.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.8%2B10/OpenJDK11U-jdk_x64_mac_hotspot_11.0.8_10.tar.gz.json", + "name": "OpenJDK11U-jdk_x64_mac_hotspot_11.0.8_10.tar.gz", + "size": 185054456 + }, + "project": "jdk", + "scm_ref": "jdk-11.0.8+10_adopt", + "updated_at": "2020-07-15T14:30:51Z" + } + ], + "download_count": 1968658, + "id": "MDc6UmVsZWFzZTI4NTg5Nzcz.pCNBA7G9E1o7pw==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/tag/jdk-11.0.8%2B10", + "release_name": "jdk-11.0.8+10", + "release_type": "ga", + "timestamp": "2020-07-15T14:29:27Z", + "updated_at": "2020-07-15T14:29:27Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 10, + "major": 11, + "minor": 0, + "openjdk_version": "11.0.8+10", + "security": 8, + "semver": "11.0.8+10" + } + }, + { + "binaries": [], + "download_count": 1968658, + "id": "MDc6UmVsZWFzZTI4NTg5Nzcz.pCNBA7G9E1o7pw==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/tag/jdk-11.0.8%2B10", + "release_name": "jdk-11.0.8+10", + "release_type": "ga", + "timestamp": "2020-07-15T14:29:27Z", + "updated_at": "2020-07-15T14:29:27Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 10, + "major": 9, + "minor": 0, + "openjdk_version": "9.0.8+10", + "security": 8, + "semver": "9.0.8+10" + } + }, + { + "binaries": [ + { + "architecture": "x64", + "download_count": 149393, + "heap_size": "normal", + "image_type": "jdk", + "jvm_impl": "hotspot", + "os": "mac", + "package": { + "checksum": "4a8dadd58cdc32c7e59978971d56aec610be7ee0ddf0dc1d137bb8b78456499f", + "checksum_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.8%2B10/OpenJDK11U-jdk_x64_mac_hotspot_11.0.8_10.tar.gz.sha256.txt", + "download_count": 40158, + "link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.8%2B10/OpenJDK11U-jdk_x64_mac_hotspot_11.0.8_10.tar.gz", + "metadata_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.8%2B10/OpenJDK11U-jdk_x64_mac_hotspot_11.0.8_10.tar.gz.json", + "name": "OpenJDK11U-jdk_x64_mac_hotspot_11.0.8_10.tar.gz", + "size": 185054456 + }, + "project": "jdk", + "scm_ref": "jdk-11.0.8+10_adopt", + "updated_at": "2020-07-15T14:30:51Z" + } + ], + "download_count": 1968658, + "id": "MDc6UmVsZWFzZTI4NTg5Nzcz.pCNBA7G9E1o7pw==", + "release_link": "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/tag/jdk-11.0.8%2B10", + "release_name": "jdk-11.0.8+10", + "release_type": "ga", + "timestamp": "2020-07-15T14:29:27Z", + "updated_at": "2020-07-15T14:29:27Z", + "vendor": "adoptopenjdk", + "version_data": { + "build": 10, + "major": 9, + "minor": 0, + "openjdk_version": "9.0.8+10", + "security": 8, + "semver": "9.0.7+10" + } + } +] \ No newline at end of file diff --git a/__tests__/data/zulu-releases-default.json b/__tests__/data/zulu-releases-default.json new file mode 100644 index 0000000..f23a87d --- /dev/null +++ b/__tests__/data/zulu-releases-default.json @@ -0,0 +1,247 @@ +[ + { + "id": 10996, + "url": "https://cdn.azul.com/zulu/bin/zulu1.8.0_05-8.1.0.10-macosx.tar.gz", + "name": "zulu1.8.0_05-8.1.0.10-macosx.tar.gz", + "zulu_version": [8, 1, 0, 10], + "jdk_version": [8, 0, 5, 13] + }, + { + "id": 10997, + "url": "https://cdn.azul.com/zulu/bin/zulu1.8.0_11-8.2.0.1-macosx.tar.gz", + "name": "zulu1.8.0_11-8.2.0.1-macosx.tar.gz", + "zulu_version": [8, 2, 0, 1], + "jdk_version": [8, 0, 11, 12] + }, + { + "id": 10346, + "url": "https://cdn.azul.com/zulu/bin/zulu8.21.0.1-jdk8.0.131-macosx_x64.tar.gz", + "name": "zulu8.21.0.1-jdk8.0.131-macosx_x64.tar.gz", + "zulu_version": [8, 21, 0, 1], + "jdk_version": [8, 0, 131, 11] + }, + { + "id": 10362, + "url": "https://cdn.azul.com/zulu/bin/zulu8.23.0.3-jdk8.0.144-macosx_x64.tar.gz", + "name": "zulu8.23.0.3-jdk8.0.144-macosx_x64.tar.gz", + "zulu_version": [8, 23, 0, 3], + "jdk_version": [8, 0, 144, 1] + }, + { + "id": 10399, + "url": "https://cdn.azul.com/zulu/bin/zulu8.25.0.1-jdk8.0.152-macosx_x64.tar.gz", + "name": "zulu8.25.0.1-jdk8.0.152-macosx_x64.tar.gz", + "zulu_version": [8, 25, 0, 1], + "jdk_version": [8, 0, 152, 16] + }, + { + "id": 11355, + "url": "https://cdn.azul.com/zulu/bin/zulu8.46.0.19-ca-jdk8.0.252-macosx_x64.tar.gz", + "name": "zulu8.46.0.19-ca-jdk8.0.252-macosx_x64.tar.gz", + "zulu_version": [8, 46, 0, 19], + "jdk_version": [8, 0, 252, 14] + }, + { + "id": 11481, + "url": "https://cdn.azul.com/zulu/bin/zulu8.48.0.47-ca-jdk8.0.262-macosx_x64.tar.gz", + "name": "zulu8.48.0.47-ca-jdk8.0.262-macosx_x64.tar.gz", + "zulu_version": [8, 48, 0, 47], + "jdk_version": [8, 0, 262, 17] + }, + { + "id": 11622, + "url": "https://cdn.azul.com/zulu/bin/zulu8.48.0.51-ca-jdk8.0.262-macosx_x64.tar.gz", + "name": "zulu8.48.0.51-ca-jdk8.0.262-macosx_x64.tar.gz", + "zulu_version": [8, 48, 0, 51], + "jdk_version": [8, 0, 262, 19] + }, + { + "id": 11535, + "url": "https://cdn.azul.com/zulu/bin/zulu8.48.0.49-ca-jdk8.0.262-macosx_x64.tar.gz", + "name": "zulu8.48.0.49-ca-jdk8.0.262-macosx_x64.tar.gz", + "zulu_version": [8, 48, 0, 49], + "jdk_version": [8, 0, 262, 18] + }, + { + "id": 12424, + "url": "https://cdn.azul.com/zulu/bin/zulu8.52.0.23-ca-jdk8.0.282-macosx_x64.tar.gz", + "name": "zulu8.52.0.23-ca-jdk8.0.282-macosx_x64.tar.gz", + "zulu_version": [8, 52, 0, 23], + "jdk_version": [8, 0, 282, 8] + }, + { + "id": 10383, + "url": "https://cdn.azul.com/zulu/bin/zulu9.0.0.15-jdk9.0.0-macosx_x64.tar.gz", + "name": "zulu9.0.0.15-jdk9.0.0-macosx_x64.tar.gz", + "zulu_version": [9, 0, 0, 15], + "jdk_version": [9, 0, 0, 0] + }, + { + "id": 10413, + "url": "https://cdn.azul.com/zulu/bin/zulu9.0.1.3-jdk9.0.1-macosx_x64.tar.gz", + "name": "zulu9.0.1.3-jdk9.0.1-macosx_x64.tar.gz", + "zulu_version": [9, 0, 1, 3], + "jdk_version": [9, 0, 1, 0] + }, + { + "id": 10503, + "url": "https://cdn.azul.com/zulu/bin/zulu10.2+3-jdk10.0.1-macosx_x64.tar.gz", + "name": "zulu10.2+3-jdk10.0.1-macosx_x64.tar.gz", + "zulu_version": [10, 2, 3, 0], + "jdk_version": [10, 0, 1, 9] + }, + { + "id": 10541, + "url": "https://cdn.azul.com/zulu/bin/zulu10.3+5-jdk10.0.2-macosx_x64.tar.gz", + "name": "zulu10.3+5-jdk10.0.2-macosx_x64.tar.gz", + "zulu_version": [10, 3, 5, 0], + "jdk_version": [10, 0, 2, 13] + }, + { + "id": 10576, + "url": "https://cdn.azul.com/zulu/bin/zulu11.2.3-jdk11.0.1-macosx_x64.tar.gz", + "name": "zulu11.2.3-jdk11.0.1-macosx_x64.tar.gz", + "zulu_version": [11, 2, 3, 0], + "jdk_version": [11, 0, 1, 13] + }, + { + "id": 10604, + "url": "https://cdn.azul.com/zulu/bin/zulu11.29.3-ca-jdk11.0.2-macosx_x64.tar.gz", + "name": "zulu11.29.3-ca-jdk11.0.2-macosx_x64.tar.gz", + "zulu_version": [11, 29, 3, 0], + "jdk_version": [11, 0, 2, 7] + }, + { + "id": 10687, + "url": "https://cdn.azul.com/zulu/bin/zulu11.31.11-ca-jdk11.0.3-macosx_x64.tar.gz", + "name": "zulu11.31.11-ca-jdk11.0.3-macosx_x64.tar.gz", + "zulu_version": [11, 31, 11, 0], + "jdk_version": [11, 0, 3, 7] + }, + { + "id": 10856, + "url": "https://cdn.azul.com/zulu/bin/zulu11.35.13-ca-jdk11.0.5-macosx_x64.tar.gz", + "name": "zulu11.35.13-ca-jdk11.0.5-macosx_x64.tar.gz", + "zulu_version": [11, 35, 13, 0], + "jdk_version": [11, 0, 5, 10] + }, + { + "id": 10933, + "url": "https://cdn.azul.com/zulu/bin/zulu11.35.15-ca-jdk11.0.5-macosx_x64.tar.gz", + "name": "zulu11.35.15-ca-jdk11.0.5-macosx_x64.tar.gz", + "zulu_version": [11, 35, 15, 0], + "jdk_version": [11, 0, 5, 10] + }, + { + "id": 10933, + "url": "https://cdn.azul.com/zulu/bin/zulu11.35.11-ca-jdk11.0.5-macosx_x64.tar.gz", + "name": "zulu11.35.15-ca-jdk11.0.5-macosx_x64.tar.gz", + "zulu_version": [11, 35, 11, 0], + "jdk_version": [11, 0, 5, 10] + }, + { + "id": 12397, + "url": "https://cdn.azul.com/zulu/bin/zulu11.45.27-ca-jdk11.0.10-macosx_x64.tar.gz", + "name": "zulu11.45.27-ca-jdk11.0.10-macosx_x64.tar.gz", + "zulu_version": [11, 45, 27, 0], + "jdk_version": [11, 0, 10, 9] + }, + { + "id": 10667, + "url": "https://cdn.azul.com/zulu/bin/zulu12.1.3-ca-jdk12.0.0-macosx_x64.tar.gz", + "name": "zulu12.1.3-ca-jdk12.0.0-macosx_x64.tar.gz", + "zulu_version": [12, 1, 3, 0], + "jdk_version": [12, 0, 0, 33] + }, + { + "id": 10710, + "url": "https://cdn.azul.com/zulu/bin/zulu12.2.3-ca-jdk12.0.1-macosx_x64.tar.gz", + "name": "zulu12.2.3-ca-jdk12.0.1-macosx_x64.tar.gz", + "zulu_version": [12, 2, 3, 0], + "jdk_version": [12, 0, 1, 12] + }, + { + "id": 10780, + "url": "https://cdn.azul.com/zulu/bin/zulu12.3.11-ca-jdk12.0.2-macosx_x64.tar.gz", + "name": "zulu12.3.11-ca-jdk12.0.2-macosx_x64.tar.gz", + "zulu_version": [12, 3, 11, 0], + "jdk_version": [12, 0, 2, 3] + }, + { + "id": 10846, + "url": "https://cdn.azul.com/zulu/bin/zulu13.27.9-ca-jdk13.0.0-macosx_x64.tar.gz", + "name": "zulu13.27.9-ca-jdk13.0.0-macosx_x64.tar.gz", + "zulu_version": [13, 27, 9, 0], + "jdk_version": [13, 0, 0, 33] + }, + { + "id": 10888, + "url": "https://cdn.azul.com/zulu/bin/zulu13.28.11-ca-jdk13.0.1-macosx_x64.tar.gz", + "name": "zulu13.28.11-ca-jdk13.0.1-macosx_x64.tar.gz", + "zulu_version": [13, 28, 11, 0], + "jdk_version": [13, 0, 1, 10] + }, + { + "id": 11073, + "url": "https://cdn.azul.com/zulu/bin/zulu13.29.9-ca-jdk13.0.2-macosx_x64.tar.gz", + "name": "zulu13.29.9-ca-jdk13.0.2-macosx_x64.tar.gz", + "zulu_version": [13, 29, 9, 0], + "jdk_version": [13, 0, 2, 6] + }, + { + "id": 12408, + "url": "https://cdn.azul.com/zulu/bin/zulu13.37.21-ca-jdk13.0.6-macosx_x64.tar.gz", + "name": "zulu13.37.21-ca-jdk13.0.6-macosx_x64.tar.gz", + "zulu_version": [13, 37, 21, 0], + "jdk_version": [13, 0, 6, 5] + }, + { + "id": 11236, + "url": "https://cdn.azul.com/zulu/bin/zulu14.27.1-ca-jdk14.0.0-macosx_x64.tar.gz", + "name": "zulu14.27.1-ca-jdk14.0.0-macosx_x64.tar.gz", + "zulu_version": [14, 27, 1, 0], + "jdk_version": [14, 0, 0, 36] + }, + { + "id": 11349, + "url": "https://cdn.azul.com/zulu/bin/zulu14.28.21-ca-jdk14.0.1-macosx_x64.tar.gz", + "name": "zulu14.28.21-ca-jdk14.0.1-macosx_x64.tar.gz", + "zulu_version": [14, 28, 21, 0], + "jdk_version": [14, 0, 1, 8] + }, + { + "id": 11513, + "url": "https://cdn.azul.com/zulu/bin/zulu14.29.23-ca-jdk14.0.2-macosx_x64.tar.gz", + "name": "zulu14.29.23-ca-jdk14.0.2-macosx_x64.tar.gz", + "zulu_version": [14, 29, 23, 0], + "jdk_version": [14, 0, 2, 12] + }, + { + "id": 11780, + "url": "https://cdn.azul.com/zulu/bin/zulu15.27.17-ca-jdk15.0.0-macosx_x64.tar.gz", + "name": "zulu15.27.17-ca-jdk15.0.0-macosx_x64.tar.gz", + "zulu_version": [15, 27, 17, 0], + "jdk_version": [15, 0, 0, 36] + }, + { + "id": 11924, + "url": "https://cdn.azul.com/zulu/bin/zulu15.28.13-ca-jdk15.0.1-macosx_x64.tar.gz", + "name": "zulu15.28.13-ca-jdk15.0.1-macosx_x64.tar.gz", + "zulu_version": [15, 28, 13, 0], + "jdk_version": [15, 0, 1, 8] + }, + { + "id": 12101, + "url": "https://cdn.azul.com/zulu/bin/zulu15.28.51-ca-jdk15.0.1-macosx_x64.tar.gz", + "name": "zulu15.28.51-ca-jdk15.0.1-macosx_x64.tar.gz", + "zulu_version": [15, 28, 51, 0], + "jdk_version": [15, 0, 1, 9] + }, + { + "id": 12445, + "url": "https://cdn.azul.com/zulu/bin/zulu15.29.15-ca-jdk15.0.2-macosx_x64.tar.gz", + "name": "zulu15.29.15-ca-jdk15.0.2-macosx_x64.tar.gz", + "zulu_version": [15, 29, 15, 0], + "jdk_version": [15, 0, 2, 7] + } +] diff --git a/__tests__/distributors/adopt-installer.test.ts b/__tests__/distributors/adopt-installer.test.ts new file mode 100644 index 0000000..4b4a3c0 --- /dev/null +++ b/__tests__/distributors/adopt-installer.test.ts @@ -0,0 +1,149 @@ +import { HttpClient } from '@actions/http-client'; + +import * as semver from 'semver'; + +import { AdoptDistribution } from '../../src/distributions/adopt/installer'; +import { JavaInstallerOptions } from '../../src/distributions/base-models'; + +let manifestData = require('../data/adopt.json') as []; + +describe('getAvailableVersions', () => { + let spyHttpClient: jest.SpyInstance; + + beforeEach(() => { + spyHttpClient = jest.spyOn(HttpClient.prototype, 'getJson'); + spyHttpClient.mockReturnValue({ + statusCode: 200, + headers: {}, + result: [] + }); + }); + + afterEach(() => { + jest.resetAllMocks(); + jest.clearAllMocks(); + jest.restoreAllMocks(); + }); + + it.each([ + [ + { version: '11', architecture: 'x64', packageType: 'jdk' }, + 'os=mac&architecture=x64&image_type=jdk&release_type=ga&page_size=20&page=0' + ], + [ + { version: '11', architecture: 'x86', packageType: 'jdk' }, + 'os=mac&architecture=x86&image_type=jdk&release_type=ga&page_size=20&page=0' + ], + [ + { version: '11', architecture: 'x64', packageType: 'jre' }, + 'os=mac&architecture=x64&image_type=jre&release_type=ga&page_size=20&page=0' + ], + [ + { version: '11-ea', architecture: 'x64', packageType: 'jdk' }, + 'os=mac&architecture=x64&image_type=jdk&release_type=ea&page_size=20&page=0' + ] + ])( + 'build correct url for %s', + async (installerOptions: JavaInstallerOptions, expectedParameters) => { + const distribution = new AdoptDistribution(installerOptions); + const baseUrl = 'https://api.adoptopenjdk.net/v3/assets/version/%5B1.0,100.0%5D'; + const expectedUrl = `${baseUrl}?project=jdk&vendor=adoptopenjdk&heap_size=normal&jvm_impl=hotspot&sort_method=DEFAULT&sort_order=DESC&${expectedParameters}`; + distribution['getPlatformOption'] = () => 'mac'; + + await distribution['getAvailableVersions'](); + + expect(spyHttpClient.mock.calls).toHaveLength(1); + expect(spyHttpClient.mock.calls[0][0]).toBe(expectedUrl); + } + ); + + it('load available versions', async () => { + spyHttpClient = jest.spyOn(HttpClient.prototype, 'getJson'); + spyHttpClient + .mockReturnValueOnce({ + statusCode: 200, + headers: {}, + result: manifestData + }) + .mockReturnValueOnce({ + statusCode: 200, + headers: {}, + result: manifestData + }) + .mockReturnValueOnce({ + statusCode: 200, + headers: {}, + result: [] + }); + + const distribution = new AdoptDistribution({ + version: '11', + architecture: 'x64', + packageType: 'jdk' + }); + const availableVersions = await distribution['getAvailableVersions'](); + expect(availableVersions).not.toBeNull(); + expect(availableVersions.length).toBe(manifestData.length * 2); + }); +}); + +describe('findPackageForDownload', () => { + it.each([ + ['9', '9.0.7+10'], + ['15', '15.0.2+7'], + ['15.0', '15.0.2+7'], + ['15.0.2', '15.0.2+7'], + ['15.0.1', '15.0.1+9.1'], + ['11.x', '11.0.10+9'], + ['x', '15.0.2+7'], + ['12', '12.0.2+10.3'], // make sure that '12.0.2+10.1', '12.0.2+10.3', '12.0.2+10.2' are sorted correctly + ['12.0.2+10.1', '12.0.2+10.1'], + ['15.0.1+9', '15.0.1+9'], + ['15.0.1+9.1', '15.0.1+9.1'] + ])('version is resolved correctly %s -> %s', async (input, expected) => { + const distribution = new AdoptDistribution({ + version: '11', + architecture: 'x64', + packageType: 'jdk' + }); + distribution['getAvailableVersions'] = async () => manifestData; + const resolvedVersion = await distribution['findPackageForDownload'](input); + expect(resolvedVersion.version).toBe(expected); + }); + + it('version is found but binaries list is empty', async () => { + const distribution = new AdoptDistribution({ + version: '11', + architecture: 'x64', + packageType: 'jdk' + }); + distribution['getAvailableVersions'] = async () => manifestData; + await expect(distribution['findPackageForDownload']('9.0.8')).rejects.toThrowError( + /Could not find satisfied version for SemVer */ + ); + }); + + it('version is not found', async () => { + const distribution = new AdoptDistribution({ + version: '11', + architecture: 'x64', + packageType: 'jdk' + }); + distribution['getAvailableVersions'] = async () => manifestData; + await expect(distribution['findPackageForDownload']('7.x')).rejects.toThrowError( + /Could not find satisfied version for SemVer */ + ); + }); + + it('version list is empty', async () => { + const distribution = new AdoptDistribution({ + version: '11', + architecture: 'x64', + packageType: 'jdk' + }); + distribution['getAvailableVersions'] = async () => []; + await expect(distribution['findPackageForDownload']('11')).rejects.toThrowError( + /Could not find satisfied version for SemVer */ + ); + }); +}); diff --git a/__tests__/distributors/base-installer.test.ts b/__tests__/distributors/base-installer.test.ts new file mode 100644 index 0000000..e23c972 --- /dev/null +++ b/__tests__/distributors/base-installer.test.ts @@ -0,0 +1,251 @@ +import * as tc from '@actions/tool-cache'; +import * as core from '@actions/core'; +import * as util from '../../src/util'; + +import path from 'path'; +import * as semver from 'semver'; + +import { JavaBase } from '../../src/distributions/base-installer'; +import { + JavaDownloadRelease, + JavaInstallerOptions, + JavaInstallerResults +} from '../../src/distributions/base-models'; + +class EmptyJavaBase extends JavaBase { + constructor(installerOptions: JavaInstallerOptions) { + super('Empty', installerOptions); + } + + protected async downloadTool(javaRelease: JavaDownloadRelease): Promise { + return { + version: '11.0.8', + path: `/toolcache/${this.toolcacheFolderName}/11.0.8/${this.architecture}` + }; + } + + protected async findPackageForDownload(range: string): Promise { + const availableVersion = '11.0.8'; + if (!semver.satisfies(availableVersion, range)) { + throw new Error('Available version not found'); + } + + return { + version: availableVersion, + url: `some/random_url/java/${availableVersion}` + }; + } +} + +describe('findInToolcache', () => { + const actualJavaVersion = '11.1.10'; + const javaPath = path.join('Java_Empty_jdk', actualJavaVersion, 'x64'); + + let mockJavaBase: EmptyJavaBase; + let spyGetToolcachePath: jest.SpyInstance; + let spyTcFindAllVersions: jest.SpyInstance; + + beforeEach(() => { + spyGetToolcachePath = jest.spyOn(util, 'getToolcachePath'); + spyTcFindAllVersions = jest.spyOn(tc, 'findAllVersions'); + }); + + afterEach(() => { + jest.resetAllMocks(); + jest.clearAllMocks(); + jest.restoreAllMocks(); + }); + + it.each([ + [ + { version: '11', architecture: 'x64', packageType: 'jdk' }, + { version: actualJavaVersion, path: javaPath } + ], + [ + { version: '11.1', architecture: 'x64', packageType: 'jdk' }, + { version: actualJavaVersion, path: javaPath } + ], + [ + { version: '11.1.10', architecture: 'x64', packageType: 'jdk' }, + { version: actualJavaVersion, path: javaPath } + ], + [{ version: '11', architecture: 'x64', packageType: 'jre' }, null], + [{ version: '8', architecture: 'x64', packageType: 'jdk' }, null], + [{ version: '11', architecture: 'x86', packageType: 'jdk' }, null], + [{ version: '11', architecture: 'x86', packageType: 'jre' }, null] + ])(`should find java for path %s -> %s`, (input, expected) => { + spyTcFindAllVersions.mockReturnValue([actualJavaVersion]); + spyGetToolcachePath.mockImplementation( + (toolname: string, javaVersion: string, architecture: string) => { + const semverVersion = new semver.Range(javaVersion); + + if (path.basename(javaPath) !== architecture || !javaPath.includes(toolname)) { + return ''; + } + + return semver.satisfies(actualJavaVersion, semverVersion) ? javaPath : ''; + } + ); + mockJavaBase = new EmptyJavaBase(input); + expect(mockJavaBase['findInToolcache']()).toEqual(expected); + }); + + it.each([ + ['11', '11.0.3'], + ['11.0', '11.0.3'], + ['11.0.1', '11.0.1'], + ['11.0.3', '11.0.3'], + ['15', '15.0.2'], + ['x', '15.0.2'], + ['x-ea', '17.4.4-ea'], + ['11-ea', '11.3.2-ea'], + ['11.2-ea', '11.2.1-ea'], + ['11.2.1-ea', '11.2.1-ea'] + ])('should choose correct java from tool-cache for input %s', (input, expected) => { + spyTcFindAllVersions.mockReturnValue([ + '17.4.4-ea', + '11.0.2', + '15.0.2', + '11.0.3', + '11.2.1-ea', + '11.3.2-ea', + '11.0.1' + ]); + spyGetToolcachePath.mockImplementation( + (toolname: string, javaVersion: string, architecture: string) => + `/hostedtoolcache/${toolname}/${javaVersion}/${architecture}` + ); + mockJavaBase = new EmptyJavaBase({ version: input, architecture: 'x64', packageType: 'jdk' }); + const foundVersion = mockJavaBase['findInToolcache'](); + expect(foundVersion?.version).toEqual(expected); + }); +}); + +describe('setupJava', () => { + const actualJavaVersion = '11.1.10'; + const javaPath = path.join('Java_Empty_jdk', actualJavaVersion, 'x86'); + + let mockJavaBase: EmptyJavaBase; + + let spyGetToolcachePath: jest.SpyInstance; + let spyTcFindAllVersions: jest.SpyInstance; + let spyCoreDebug: jest.SpyInstance; + let spyCoreInfo: jest.SpyInstance; + let spyCoreExportVariable: jest.SpyInstance; + let spyCoreAddPath: jest.SpyInstance; + let spyCoreSetOutput: jest.SpyInstance; + + beforeEach(() => { + spyGetToolcachePath = jest.spyOn(util, 'getToolcachePath'); + spyGetToolcachePath.mockImplementation( + (toolname: string, javaVersion: string, architecture: string) => { + const semverVersion = new semver.Range(javaVersion); + + if (path.basename(javaPath) !== architecture || !javaPath.includes(toolname)) { + return ''; + } + + return semver.satisfies(actualJavaVersion, semverVersion) ? javaPath : ''; + } + ); + + spyTcFindAllVersions = jest.spyOn(tc, 'findAllVersions'); + spyTcFindAllVersions.mockReturnValue([actualJavaVersion]); + + // Spy on core methods + spyCoreDebug = jest.spyOn(core, 'debug'); + spyCoreDebug.mockImplementation(() => undefined); + + spyCoreInfo = jest.spyOn(core, 'info'); + spyCoreInfo.mockImplementation(() => undefined); + + spyCoreAddPath = jest.spyOn(core, 'addPath'); + spyCoreAddPath.mockImplementation(() => undefined); + + spyCoreExportVariable = jest.spyOn(core, 'exportVariable'); + spyCoreExportVariable.mockImplementation(() => undefined); + + spyCoreSetOutput = jest.spyOn(core, 'setOutput'); + spyCoreSetOutput.mockImplementation(() => undefined); + }); + + afterEach(() => { + jest.resetAllMocks(); + jest.clearAllMocks(); + jest.restoreAllMocks(); + }); + + it.each([ + [ + { version: '11', architecture: 'x86', packageType: 'jdk' }, + { version: actualJavaVersion, path: javaPath } + ], + [ + { version: '11.1', architecture: 'x86', packageType: 'jdk' }, + { version: actualJavaVersion, path: javaPath } + ], + [ + { version: '11.1.10', architecture: 'x86', packageType: 'jdk' }, + { version: actualJavaVersion, path: javaPath } + ] + ])('should find java locally for %s', (input, expected) => { + mockJavaBase = new EmptyJavaBase(input); + expect(mockJavaBase.setupJava()).resolves.toEqual(expected); + expect(spyGetToolcachePath).toHaveBeenCalled(); + }); + + it.each([ + [ + { version: '11', architecture: 'x86', packageType: 'jre' }, + { path: `/toolcache/Java_Empty_jre/11.0.8/x86`, version: '11.0.8' } + ], + [ + { version: '11', architecture: 'x64', packageType: 'jdk' }, + { path: `/toolcache/Java_Empty_jdk/11.0.8/x64`, version: '11.0.8' } + ], + [ + { version: '11', architecture: 'x64', packageType: 'jre' }, + { path: `/toolcache/Java_Empty_jre/11.0.8/x64`, version: '11.0.8' } + ] + ])('download java with configuration %s', async (input, expected) => { + mockJavaBase = new EmptyJavaBase(input); + await expect(mockJavaBase.setupJava()).resolves.toEqual(expected); + expect(spyGetToolcachePath).toHaveBeenCalled(); + expect(spyCoreAddPath).toHaveBeenCalled(); + expect(spyCoreExportVariable).toHaveBeenCalled(); + expect(spyCoreSetOutput).toHaveBeenCalled(); + }); + + it.each([ + [{ version: '15', architecture: 'x86', packageType: 'jre' }], + [{ version: '11.0.7', architecture: 'x64', packageType: 'jre' }] + ])('should throw an error for Available version not found for %s', async input => { + mockJavaBase = new EmptyJavaBase(input); + await expect(mockJavaBase.setupJava()).rejects.toThrowError('Available version not found'); + expect(spyTcFindAllVersions).toHaveBeenCalled(); + expect(spyCoreAddPath).not.toHaveBeenCalled(); + expect(spyCoreExportVariable).not.toHaveBeenCalled(); + expect(spyCoreSetOutput).not.toHaveBeenCalled(); + }); +}); + +describe('normalizeVersion', () => { + const DummyJavaBase = JavaBase as any; + + it.each([ + ['11', { version: '11', stable: true }], + ['11.0', { version: '11.0', stable: true }], + ['11.0.10', { version: '11.0.10', stable: true }], + ['11-ea', { version: '11', stable: false }], + ['11.0.2-ea', { version: '11.0.2', stable: false }] + ])('normalizeVersion from %s to %s', (input, expected) => { + expect(DummyJavaBase.prototype.normalizeVersion.call(null, input)).toEqual(expected); + }); + + it('normalizeVersion should throw an error for non semver', () => { + const version = '11g'; + expect(DummyJavaBase.prototype.normalizeVersion.bind(null, version)).toThrowError( + `The string '${version}' is not valid SemVer notation for a Java version. Please check README file for code snippets and more detailed information` + ); + }); +}); diff --git a/__tests__/distributors/local-installer.test.ts b/__tests__/distributors/local-installer.test.ts new file mode 100644 index 0000000..c3b085b --- /dev/null +++ b/__tests__/distributors/local-installer.test.ts @@ -0,0 +1,197 @@ +import fs from 'fs'; + +import * as tc from '@actions/tool-cache'; +import * as core from '@actions/core'; + +import path from 'path'; +import * as semver from 'semver'; +import * as util from '../../src/util'; + +import { LocalDistribution } from '../../src/distributions/local/installer'; + +describe('setupJava', () => { + const actualJavaVersion = '11.1.10'; + const javaPath = path.join('Java_jdkfile_jdk', actualJavaVersion, 'x86'); + + let mockJavaBase: LocalDistribution; + + let spyGetToolcachePath: jest.SpyInstance; + let spyTcCacheDir: jest.SpyInstance; + let spyTcFindAllVersions: jest.SpyInstance; + let spyCoreDebug: jest.SpyInstance; + let spyCoreInfo: jest.SpyInstance; + let spyCoreExportVariable: jest.SpyInstance; + let spyCoreAddPath: jest.SpyInstance; + let spyCoreSetOutput: jest.SpyInstance; + let spyFsStat: jest.SpyInstance; + let spyFsReadDir: jest.SpyInstance; + let spyUtilsExtractJdkFile: jest.SpyInstance; + let spyPathResolve: jest.SpyInstance; + let expectedJdkFile = 'JavaLocalJdkFile'; + + beforeEach(() => { + spyGetToolcachePath = jest.spyOn(util, 'getToolcachePath'); + spyGetToolcachePath.mockImplementation( + (toolname: string, javaVersion: string, architecture: string) => { + const semverVersion = new semver.Range(javaVersion); + + if (path.basename(javaPath) !== architecture || !javaPath.includes(toolname)) { + return ''; + } + + return semver.satisfies(actualJavaVersion, semverVersion) ? javaPath : ''; + } + ); + + spyTcCacheDir = jest.spyOn(tc, 'cacheDir'); + spyTcCacheDir.mockImplementation( + (archivePath: string, toolcacheFolderName: string, version: string, architecture: string) => + path.join(toolcacheFolderName, version, architecture) + ); + + spyTcFindAllVersions = jest.spyOn(tc, 'findAllVersions'); + spyTcFindAllVersions.mockReturnValue([actualJavaVersion]); + + // Spy on core methods + spyCoreDebug = jest.spyOn(core, 'debug'); + spyCoreDebug.mockImplementation(() => undefined); + + spyCoreInfo = jest.spyOn(core, 'info'); + spyCoreInfo.mockImplementation(() => undefined); + + spyCoreAddPath = jest.spyOn(core, 'addPath'); + spyCoreAddPath.mockImplementation(() => undefined); + + spyCoreExportVariable = jest.spyOn(core, 'exportVariable'); + spyCoreExportVariable.mockImplementation(() => undefined); + + spyCoreSetOutput = jest.spyOn(core, 'setOutput'); + spyCoreSetOutput.mockImplementation(() => undefined); + + // Spy on fs methods + spyFsReadDir = jest.spyOn(fs, 'readdirSync'); + spyFsReadDir.mockImplementation(() => ['JavaTest']); + + spyFsStat = jest.spyOn(fs, 'statSync'); + spyFsStat.mockImplementation((file: string) => { + return { isFile: () => file === expectedJdkFile }; + }); + + // Spy on util methods + spyUtilsExtractJdkFile = jest.spyOn(util, 'extractJdkFile'); + spyUtilsExtractJdkFile.mockImplementation(() => 'some/random/path/'); + + // Spy on path methods + spyPathResolve = jest.spyOn(path, 'resolve'); + spyPathResolve.mockImplementation((path: string) => path); + }); + + afterEach(() => { + jest.resetAllMocks(); + jest.clearAllMocks(); + jest.restoreAllMocks(); + }); + + it('java is resolved from toolcache, jdkfile is untouched', async () => { + const inputs = { version: actualJavaVersion, architecture: 'x86', packageType: 'jdk' }; + const jdkFile = 'not_existing_one'; + const expected = { + version: actualJavaVersion, + path: path.join('Java_jdkfile_jdk', inputs.version, inputs.architecture) + }; + + mockJavaBase = new LocalDistribution(inputs, jdkFile); + await expect(mockJavaBase.setupJava()).resolves.toEqual(expected); + expect(spyGetToolcachePath).toHaveBeenCalled(); + expect(spyCoreInfo).toHaveBeenCalledWith(`Resolved Java ${actualJavaVersion} from tool-cache`); + expect(spyCoreInfo).not.toHaveBeenCalledWith( + `Java ${inputs.version} was not found in tool-cache. Trying to unpack JDK file...` + ); + }); + + it("java is resolved from toolcache, jdkfile doesn't exist", async () => { + const inputs = { version: actualJavaVersion, architecture: 'x86', packageType: 'jdk' }; + const jdkFile = undefined; + const expected = { + version: actualJavaVersion, + path: path.join('Java_jdkfile_jdk', inputs.version, inputs.architecture) + }; + + mockJavaBase = new LocalDistribution(inputs, jdkFile); + await expect(mockJavaBase.setupJava()).resolves.toEqual(expected); + expect(spyGetToolcachePath).toHaveBeenCalled(); + expect(spyCoreInfo).toHaveBeenCalledWith(`Resolved Java ${actualJavaVersion} from tool-cache`); + expect(spyCoreInfo).not.toHaveBeenCalledWith( + `Java ${inputs.version} was not found in tool-cache. Trying to unpack JDK file...` + ); + }); + + it('java is unpacked from jdkfile', async () => { + const inputs = { version: '11.0.289', architecture: 'x86', packageType: 'jdk' }; + const jdkFile = expectedJdkFile; + const expected = { + version: '11.0.289', + path: path.join('Java_jdkfile_jdk', inputs.version, inputs.architecture) + }; + + mockJavaBase = new LocalDistribution(inputs, jdkFile); + await expect(mockJavaBase.setupJava()).resolves.toEqual(expected); + expect(spyTcFindAllVersions).toHaveBeenCalled(); + expect(spyCoreInfo).not.toHaveBeenCalledWith( + `Resolved Java ${actualJavaVersion} from tool-cache` + ); + expect(spyCoreInfo).toHaveBeenCalledWith(`Extracting Java from '${jdkFile}'`); + expect(spyCoreInfo).toHaveBeenCalledWith( + `Java ${inputs.version} was not found in tool-cache. Trying to unpack JDK file...` + ); + }); + + it('jdk file is not found', async () => { + const inputs = { version: '11.0.289', architecture: 'x86', packageType: 'jdk' }; + const jdkFile = 'not_existing_one'; + const expected = { + javaVersion: '11.0.289', + javaPath: path.join('Java_jdkfile_jdk', inputs.version, inputs.architecture) + }; + + mockJavaBase = new LocalDistribution(inputs, jdkFile); + expected.javaPath = path.join('Java_jdkfile_jdk', inputs.version, inputs.architecture); + await expect(mockJavaBase.setupJava()).rejects.toThrowError( + "JDK file was not found in path 'not_existing_one'" + ); + expect(spyTcFindAllVersions).toHaveBeenCalled(); + expect(spyCoreInfo).not.toHaveBeenCalledWith( + `Resolved Java ${actualJavaVersion} from tool-cache` + ); + expect(spyCoreInfo).not.toHaveBeenCalledWith(`Extracting Java from '${jdkFile}'`); + expect(spyCoreInfo).toHaveBeenCalledWith( + `Java ${inputs.version} was not found in tool-cache. Trying to unpack JDK file...` + ); + }); + + it.each([ + [{ version: '8.0.289', architecture: 'x64', packageType: 'jdk' }, 'otherJdkFile'], + [{ version: '11.0.289', architecture: 'x64', packageType: 'jdk' }, 'otherJdkFile'], + [{ version: '12.0.289', architecture: 'x64', packageType: 'jdk' }, 'otherJdkFile'], + [{ version: '11.1.11', architecture: 'x64', packageType: 'jdk' }, 'not_existing_one'] + ])( + `Throw an error if jdkfile has wrong path, inputs %s, jdkfile %s, real name ${expectedJdkFile}`, + async (inputs, jdkFile) => { + mockJavaBase = new LocalDistribution(inputs, jdkFile); + await expect(mockJavaBase.setupJava()).rejects.toThrowError( + /JDK file was not found in path */ + ); + expect(spyTcFindAllVersions).toHaveBeenCalled(); + } + ); + + it.each([ + [{ version: '8.0.289', architecture: 'x64', packageType: 'jdk' }, ''], + [{ version: '7.0.289', architecture: 'x64', packageType: 'jdk' }, undefined], + [{ version: '11.0.289', architecture: 'x64', packageType: 'jdk' }, undefined] + ])('Throw an error if jdkfile is not specified, inputs %s', async (inputs, jdkFile) => { + mockJavaBase = new LocalDistribution(inputs, jdkFile); + await expect(mockJavaBase.setupJava()).rejects.toThrowError("'jdkFile' is not specified"); + expect(spyTcFindAllVersions).toHaveBeenCalled(); + }); +}); diff --git a/__tests__/distributors/zulu-installer.test.ts b/__tests__/distributors/zulu-installer.test.ts new file mode 100644 index 0000000..fe5958a --- /dev/null +++ b/__tests__/distributors/zulu-installer.test.ts @@ -0,0 +1,159 @@ +import { HttpClient } from '@actions/http-client'; +import * as semver from 'semver'; +import { ZuluDistribution } from '../../src/distributions/zulu/installer'; +import { IZuluVersions } from '../../src/distributions/zulu/models'; +import * as utils from '../../src/util'; + +const manifestData = require('../data/zulu-releases-default.json') as []; + +describe('getAvailableVersions', () => { + let spyHttpClient: jest.SpyInstance; + let spyUtilGetDownloadArchiveExtension: jest.SpyInstance; + + beforeEach(() => { + spyHttpClient = jest.spyOn(HttpClient.prototype, 'getJson'); + spyHttpClient.mockReturnValue({ + statusCode: 200, + headers: {}, + result: manifestData as IZuluVersions[] + }); + + spyUtilGetDownloadArchiveExtension = jest.spyOn(utils, 'getDownloadArchiveExtension'); + spyUtilGetDownloadArchiveExtension.mockReturnValue('tar.gz'); + }); + + afterEach(() => { + jest.resetAllMocks(); + jest.clearAllMocks(); + jest.restoreAllMocks(); + }); + + it.each([ + [ + { version: '11', architecture: 'x86', packageType: 'jdk' }, + '?os=macos&ext=tar.gz&bundle_type=jdk&javafx=false&arch=x86&hw_bitness=32&release_status=ga' + ], + [ + { version: '11-ea', architecture: 'x86', packageType: 'jdk' }, + '?os=macos&ext=tar.gz&bundle_type=jdk&javafx=false&arch=x86&hw_bitness=32&release_status=ea' + ], + [ + { version: '8', architecture: 'x64', packageType: 'jdk' }, + '?os=macos&ext=tar.gz&bundle_type=jdk&javafx=false&arch=x86&hw_bitness=64&release_status=ga' + ], + [ + { version: '8', architecture: 'x64', packageType: 'jre' }, + '?os=macos&ext=tar.gz&bundle_type=jre&javafx=false&arch=x86&hw_bitness=64&release_status=ga' + ], + [ + { version: '8', architecture: 'x64', packageType: 'jdk+fx' }, + '?os=macos&ext=tar.gz&bundle_type=jdk&javafx=true&arch=x86&hw_bitness=64&release_status=ga&features=fx' + ], + [ + { version: '8', architecture: 'x64', packageType: 'jre+fx' }, + '?os=macos&ext=tar.gz&bundle_type=jre&javafx=true&arch=x86&hw_bitness=64&release_status=ga&features=fx' + ] + ])('build correct url for %s -> %s', async (input, parsedUrl) => { + const distribution = new ZuluDistribution(input); + distribution['getPlatformOption'] = () => 'macos'; + const buildUrl = `https://api.azul.com/zulu/download/community/v1.0/bundles/${parsedUrl}`; + + await distribution['getAvailableVersions'](); + + expect(spyHttpClient.mock.calls).toHaveLength(1); + expect(spyHttpClient.mock.calls[0][0]).toBe(buildUrl); + }); + + it('load available versions', async () => { + const distribution = new ZuluDistribution({ + version: '11', + architecture: 'x86', + packageType: 'jdk' + }); + const availableVersions = await distribution['getAvailableVersions'](); + expect(availableVersions).toHaveLength(manifestData.length); + }); +}); + +describe('getArchitectureOptions', () => { + it.each([ + [{ architecture: 'x64' }, { arch: 'x86', hw_bitness: '64', abi: '' }], + [{ architecture: 'x86' }, { arch: 'x86', hw_bitness: '32', abi: '' }], + [{ architecture: 'x32' }, { arch: 'x32', hw_bitness: '', abi: '' }], + [{ architecture: 'arm' }, { arch: 'arm', hw_bitness: '', abi: '' }] + ])('%s -> %s', (input, expected) => { + const distribution = new ZuluDistribution({ + version: '11', + architecture: input.architecture, + packageType: 'jdk' + }); + expect(distribution['getArchitectureOptions']()).toEqual(expected); + }); +}); + +describe('findPackageForDownload', () => { + it.each([ + ['8', '8.0.282+8'], + ['11.x', '11.0.10+9'], + ['8.0', '8.0.282+8'], + ['11.0.x', '11.0.10+9'], + ['15', '15.0.2+7'], + ['9.0.0', '9.0.0+0'], + ['9.0', '9.0.1+0'], + ['8.0.262', '8.0.262+19'], // validate correct choise between [8.0.262.17, 8.0.262.19, 8.0.262.18] + ['8.0.262+17', '8.0.262+17'], + ['15.0.1+8', '15.0.1+8'], + ['15.0.1+9', '15.0.1+9'] + ])('version is %s -> %s', async (input, expected) => { + const distribution = new ZuluDistribution({ + version: input, + architecture: 'x86', + packageType: 'jdk' + }); + distribution['getAvailableVersions'] = async () => manifestData; + const result = await distribution['findPackageForDownload'](distribution['version']); + expect(result.version).toBe(expected); + }); + + it('select correct bundle if there are multiple items with the same jdk version but different zulu versions', async () => { + const distribution = new ZuluDistribution({ + version: '', + architecture: 'x86', + packageType: 'jdk' + }); + distribution['getAvailableVersions'] = async () => manifestData; + const result = await distribution['findPackageForDownload']('11.0.5'); + expect(result.url).toBe( + 'https://cdn.azul.com/zulu/bin/zulu11.35.15-ca-jdk11.0.5-macosx_x64.tar.gz' + ); + }); + + it('should throw an error', async () => { + const distribution = new ZuluDistribution({ + version: '18', + architecture: 'x86', + packageType: 'jdk' + }); + await expect( + distribution['findPackageForDownload'](distribution['version']) + ).rejects.toThrowError(/Could not find satisfied version for semver */); + }); +}); + +describe('convertVersionToSemver', () => { + it.each([ + [[12], '12'], + [[12, 0], '12.0'], + [[12, 0, 2], '12.0.2'], + [[12, 0, 2, 1], '12.0.2+1'], + [[12, 0, 2, 1, 3], '12.0.2+1'] + ])('%s -> %s', (input: number[], expected: string) => { + const distribution = new ZuluDistribution({ + version: '18', + architecture: 'x86', + packageType: 'jdk' + }); + const actual = distribution['convertVersionToSemver'](input); + expect(actual).toBe(expected); + }); +}); diff --git a/__tests__/gpg.test.ts b/__tests__/gpg.test.ts index f19e9a6..5288f9e 100644 --- a/__tests__/gpg.test.ts +++ b/__tests__/gpg.test.ts @@ -33,11 +33,7 @@ describe('gpg tests', () => { expect(keyId).toBeNull(); - expect(exec.exec).toHaveBeenCalledWith( - 'gpg', - expect.anything(), - expect.anything() - ); + expect(exec.exec).toHaveBeenCalledWith('gpg', expect.anything(), expect.anything()); }); }); @@ -46,11 +42,7 @@ describe('gpg tests', () => { const keyId = 'asdfhjkl'; await gpg.deleteKey(keyId); - expect(exec.exec).toHaveBeenCalledWith( - 'gpg', - expect.anything(), - expect.anything() - ); + expect(exec.exec).toHaveBeenCalledWith('gpg', expect.anything(), expect.anything()); }); }); }); diff --git a/__tests__/installer.test.ts b/__tests__/installer.test.ts deleted file mode 100644 index ff2d61b..0000000 --- a/__tests__/installer.test.ts +++ /dev/null @@ -1,159 +0,0 @@ -import io = require('@actions/io'); -import fs = require('fs'); -import path = require('path'); -import child_process = require('child_process'); - -const toolDir = path.join(__dirname, 'runner', 'tools'); -const tempDir = path.join(__dirname, 'runner', 'temp'); -const javaDir = path.join(__dirname, 'runner', 'java'); - -process.env['RUNNER_TOOL_CACHE'] = toolDir; -process.env['RUNNER_TEMP'] = tempDir; -import * as installer from '../src/installer'; - -let javaFilePath = ''; -let javaUrl = ''; -if (process.platform === 'win32') { - javaFilePath = path.join(javaDir, 'java_win.zip'); - javaUrl = - 'https://download.java.net/java/GA/jdk12/33/GPL/openjdk-12_windows-x64_bin.zip'; -} else if (process.platform === 'darwin') { - javaFilePath = path.join(javaDir, 'java_mac.tar.gz'); - javaUrl = - 'https://download.java.net/java/GA/jdk12/33/GPL/openjdk-12_osx-x64_bin.tar.gz'; -} else { - javaFilePath = path.join(javaDir, 'java_linux.tar.gz'); - javaUrl = - 'https://download.java.net/java/GA/jdk12/33/GPL/openjdk-12_linux-x64_bin.tar.gz'; -} - -describe('installer tests', () => { - beforeAll(async () => { - await io.rmRF(toolDir); - await io.rmRF(tempDir); - if (!fs.existsSync(`${javaFilePath}.complete`)) { - // Download java - await io.mkdirP(javaDir); - - console.log('Downloading java'); - child_process.execSync(`curl "${javaUrl}" > "${javaFilePath}"`); - // Write complete file so we know it was successful - fs.writeFileSync(`${javaFilePath}.complete`, 'content'); - } - }, 300000); - - afterAll(async () => { - try { - await io.rmRF(toolDir); - await io.rmRF(tempDir); - } catch { - console.log('Failed to remove test directories'); - } - }, 100000); - - it('Installs version of Java from jdkFile if no matching version is installed', async () => { - await installer.getJava('12', 'x64', javaFilePath, 'jdk'); - const JavaDir = path.join(toolDir, 'jdk', '12.0.0', 'x64'); - - expect(fs.existsSync(`${JavaDir}.complete`)).toBe(true); - expect(fs.existsSync(path.join(JavaDir, 'bin'))).toBe(true); - }, 100000); - - it('Throws if invalid directory to jdk', async () => { - let thrown = false; - try { - await installer.getJava('1000', 'x64', 'bad path', 'jdk'); - } catch { - thrown = true; - } - expect(thrown).toBe(true); - }); - - it('Downloads java if no file given', async () => { - await installer.getJava('8.0.102', 'x64', '', 'jdk'); - const JavaDir = path.join(toolDir, 'jdk', '8.0.102', 'x64'); - - expect(fs.existsSync(`${JavaDir}.complete`)).toBe(true); - expect(fs.existsSync(path.join(JavaDir, 'bin'))).toBe(true); - }, 100000); - - it('Downloads java with 1.x syntax', async () => { - await installer.getJava('1.10', 'x64', '', 'jdk'); - const JavaDir = path.join(toolDir, 'jdk', '10.0.2', 'x64'); - - expect(fs.existsSync(`${JavaDir}.complete`)).toBe(true); - expect(fs.existsSync(path.join(JavaDir, 'bin'))).toBe(true); - }, 100000); - - it('Downloads java with normal semver syntax', async () => { - await installer.getJava('9.0.x', 'x64', '', 'jdk'); - const JavaDir = path.join(toolDir, 'jdk', '9.0.7', 'x64'); - - expect(fs.existsSync(`${JavaDir}.complete`)).toBe(true); - expect(fs.existsSync(path.join(JavaDir, 'bin'))).toBe(true); - }, 100000); - - it('Downloads java if package is jre', async () => { - await installer.getJava('8.0.222', 'x64', '', 'jre'); - const JavaDir = path.join(toolDir, 'jre', '8.0.222', 'x64'); - - expect(fs.existsSync(`${JavaDir}.complete`)).toBe(true); - expect(fs.existsSync(path.join(JavaDir, 'bin'))).toBe(true); - }, 100000); - - it('Downloads java if package is jdk+fx', async () => { - await installer.getJava('8.0.222', 'x64', '', 'jdk+fx'); - const JavaDir = path.join(toolDir, 'jdk+fx', '8.0.222', 'x64'); - - expect(fs.existsSync(`${JavaDir}.complete`)).toBe(true); - expect(fs.existsSync(path.join(JavaDir, 'bin'))).toBe(true); - }, 100000); - - it('Throws if invalid java package is specified', async () => { - let thrown = false; - try { - await installer.getJava('8.0.222', 'x64', '', 'bad jdk'); - } catch { - thrown = true; - } - expect(thrown).toBe(true); - }); - - it('Throws if invalid directory to jdk', async () => { - let thrown = false; - try { - await installer.getJava('1000', 'x64', 'bad path', 'jdk'); - } catch { - thrown = true; - } - expect(thrown).toBe(true); - }); - - it('Uses version of Java installed in cache', async () => { - const JavaDir: string = path.join(toolDir, 'jdk', '250.0.0', 'x64'); - await io.mkdirP(JavaDir); - fs.writeFileSync(`${JavaDir}.complete`, 'hello'); - // This will throw if it doesn't find it in the cache (because no such version exists) - await installer.getJava( - '250', - 'x64', - 'path shouldnt matter, found in cache', - 'jdk' - ); - return; - }); - - it('Doesnt use version of Java that was only partially installed in cache', async () => { - const JavaDir: string = path.join(toolDir, 'jdk', '251.0.0', 'x64'); - await io.mkdirP(JavaDir); - let thrown = false; - try { - // This will throw if it doesn't find it in the cache (because no such version exists) - await installer.getJava('251', 'x64', 'bad path', 'jdk'); - } catch { - thrown = true; - } - expect(thrown).toBe(true); - return; - }); -}); diff --git a/__tests__/util.test.ts b/__tests__/util.test.ts index 4ef37cf..6509917 100644 --- a/__tests__/util.test.ts +++ b/__tests__/util.test.ts @@ -1,61 +1,22 @@ -import path = require('path'); +import { isVersionSatisfies } from '../src/util'; -const env = process.env; - -describe('util tests', () => { - beforeEach(() => { - const tempEnv = Object.assign({}, env); - delete tempEnv.RUNNER_TEMP; - delete tempEnv.USERPROFILE; - process.env = tempEnv; - Object.defineProperty(process, 'platform', {value: 'linux'}); - }); - - describe('getTempDir', () => { - it('gets temp dir using env', () => { - process.env['RUNNER_TEMP'] = 'defaulttmp'; - const util = require('../src/util'); - - const tempDir = util.getTempDir(); - - expect(tempDir).toEqual(process.env['RUNNER_TEMP']); - }); - - it('gets temp dir for windows using userprofile', () => { - Object.defineProperty(process, 'platform', {value: 'win32'}); - process.env['USERPROFILE'] = 'winusertmp'; - const util = require('../src/util'); - - const tempDir = util.getTempDir(); - - expect(tempDir).toEqual( - path.join(process.env['USERPROFILE'], 'actions', 'temp') - ); - }); - - it('gets temp dir for windows using c drive', () => { - Object.defineProperty(process, 'platform', {value: 'win32'}); - const util = require('../src/util'); - - const tempDir = util.getTempDir(); - - expect(tempDir).toEqual(path.join('C:\\', 'actions', 'temp')); - }); - - it('gets temp dir for mac', () => { - Object.defineProperty(process, 'platform', {value: 'darwin'}); - const util = require('../src/util'); - - const tempDir = util.getTempDir(); - - expect(tempDir).toEqual(path.join('/Users', 'actions', 'temp')); - }); - - it('gets temp dir for linux', () => { - const util = require('../src/util'); - const tempDir = util.getTempDir(); - - expect(tempDir).toEqual(path.join('/home', 'actions', 'temp')); - }); +describe('isVersionSatisfies', () => { + it.each([ + ['x', '11.0.0', true], + ['3', '3.7.1', true], + ['3', '3.7.2', true], + ['3', '3.7.2+4', true], + ['2.5', '2.5.0', true], + ['2.5', '2.5.0+1', true], + ['2.5', '2.6.1', false], + ['2.5.1', '2.5.0', false], + ['2.5.1+3', '2.5.0', false], + ['2.5.1+3', '2.5.1+3', true], + ['2.5.1+3', '2.5.1+2', false], + ['15.0.0+14', '15.0.0+14.1.202003190635', false], + ['15.0.0+14.1.202003190635', '15.0.0+14.1.202003190635', true] + ])('%s, %s -> %s', (inputRange: string, inputVersion: string, expected: boolean) => { + const actual = isVersionSatisfies(inputRange, inputVersion); + expect(actual).toBe(expected); }); }); diff --git a/__tests__/verify-java.ps1 b/__tests__/verify-java.ps1 deleted file mode 100644 index 359f291..0000000 --- a/__tests__/verify-java.ps1 +++ /dev/null @@ -1,31 +0,0 @@ -if (!$args.Count -or !$args[0]) -{ - throw "Must supply java version argument" -} - -$java_version = & cmd.exe /c "java -version 2>&1" | Out-String -Write-Host "Found java version: $java_version" -if (!$java_version.Contains($args[0])) -{ - throw "Unexpected version" -} - -if ($args.Count -lt 2 -or !$args[1]) -{ - throw "Must supply java path argument" -} - -if ($args[1] -ne $Env:JAVA_HOME) -{ - throw "Unexpected path" -} - -if ($args.Count -lt 3 -or !$args[2]) -{ - throw "Must supply java version argument" -} - -if ($args[0] -ne $args[2]) -{ - throw "Unexpected version" -} diff --git a/__tests__/verify-java.sh b/__tests__/verify-java.sh index e0da7d3..1bad5d3 100755 --- a/__tests__/verify-java.sh +++ b/__tests__/verify-java.sh @@ -5,29 +5,35 @@ if [ -z "$1" ]; then exit 1 fi -java_version="$(java -version 2>&1)" -echo "Found java version: $java_version" -if [ -z "$(echo $java_version | grep --fixed-strings $1)" ]; then - echo "::error::Unexpected version" - exit 1 -fi - if [ -z "$2" ]; then echo "::error::Must supply java path argument" exit 1 fi -if [ "$2" != "$JAVA_HOME" ]; then - echo "::error::Unexpected path" - exit 1 +EXPECTED_JAVA_VERSION=$1 +EXPECTED_PATH=$2 + +EXPECTED_JAVA_VERSION=$(echo $EXPECTED_JAVA_VERSION | cut -d'+' -f1) +if [[ $EXPECTED_JAVA_VERSION == 8 ]] || [[ $EXPECTED_JAVA_VERSION == 8.* ]]; then + EXPECTED_JAVA_VERSION="1.${EXPECTED_JAVA_VERSION}" +fi +if [[ $EXPECTED_JAVA_VERSION == *-ea* ]]; then + EXPECTED_JAVA_VERSION=$(echo $EXPECTED_JAVA_VERSION | cut -d'-' -f1 | cut -d'.' -f1) fi -if [ -z "$3" ]; then - echo "::error::Must supply java version argument" - exit 1 -fi +ACTUAL_JAVA_VERSION="$(java -version 2>&1)" +echo "Found java version: $ACTUAL_JAVA_VERSION" -if [ "$1" != "$3" ]; then +GREP_RESULT=$(echo $ACTUAL_JAVA_VERSION | grep "^openjdk version \"$EXPECTED_JAVA_VERSION") +if [ -z "$GREP_RESULT" ]; then echo "::error::Unexpected version" + echo "Expected version: $EXPECTED_JAVA_VERSION" + exit 1 +fi + +if [ "$EXPECTED_PATH" != "$JAVA_HOME" ]; then + echo "::error::Unexpected path" + echo "Actual path: $JAVA_HOME" + echo "Expected path: $EXPECTED_PATH" exit 1 fi diff --git a/__tests__/verify-no-unstaged-changes.sh b/__tests__/verify-no-unstaged-changes.sh new file mode 100644 index 0000000..c99e226 --- /dev/null +++ b/__tests__/verify-no-unstaged-changes.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +if [[ "$(git status --porcelain)" != "" ]]; then + echo ---------------------------------------- + echo git status + echo ---------------------------------------- + git status + echo ---------------------------------------- + echo git diff + echo ---------------------------------------- + git diff + echo ---------------------------------------- + echo Troubleshooting + echo ---------------------------------------- + echo "::error::Unstaged changes detected. Locally try running: git clean -ffdx && npm ci && npm run pre-checkin" + exit 1 +fi \ No newline at end of file diff --git a/action.yml b/action.yml index 7457268..df59abd 100644 --- a/action.yml +++ b/action.yml @@ -4,22 +4,21 @@ description: 'Set up a specific version of the Java JDK and add the author: 'GitHub' inputs: java-version: - description: 'The Java version to make available on the path. Takes a whole - or semver Java version, or 1.x syntax (e.g. 1.8 => Java 8.x). - Early access versions can be specified in the form of e.g. 14-ea, - 14.0.0-ea, or 14.0.0-ea.28' + description: 'The Java version to set up. Takes a whole or semver Java version. See examples of supported syntax in README file' + required: true + distribution: + description: 'Java distribution. See the list of supported distributions in README file' required: true java-package: - description: 'The package type (jre, jdk, jdk+fx)' + description: 'The package type (jdk, jre, jdk+fx, jre+fx)' required: false default: 'jdk' architecture: - description: 'The architecture (x86, x64) of the package.' + description: 'The architecture of the package' required: false default: 'x64' jdkFile: - description: 'Path to where the compressed JDK is located. The path could - be in your source repository or a local path on the agent.' + description: 'Path to where the compressed JDK is located' required: false server-id: description: 'ID of the distributionManagement repository in the pom.xml @@ -47,10 +46,12 @@ inputs: $GPG_PASSPHRASE.' required: false outputs: - path: - description: 'Path to where the java environment has been installed (same as $JAVA_HOME)' + distribution: + description: 'Distribution of Java that has been installed' version: description: 'Actual version of the java environment that has been installed' + path: + description: 'Path to where the java environment has been installed (same as $JAVA_HOME)' runs: using: 'node12' main: 'dist/setup/index.js' diff --git a/dist/cleanup/index.js b/dist/cleanup/index.js index 0fe3844..6bcd087 100644 --- a/dist/cleanup/index.js +++ b/dist/cleanup/index.js @@ -354,13 +354,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge step((generator = generator.apply(thisArg, _arguments || [])).next()); }); }; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const os = __webpack_require__(87); -const events = __webpack_require__(614); -const child = __webpack_require__(129); -const path = __webpack_require__(622); -const io = __webpack_require__(1); -const ioUtil = __webpack_require__(672); +const os = __importStar(__webpack_require__(87)); +const events = __importStar(__webpack_require__(614)); +const child = __importStar(__webpack_require__(129)); +const path = __importStar(__webpack_require__(622)); +const io = __importStar(__webpack_require__(1)); +const ioUtil = __importStar(__webpack_require__(672)); /* eslint-disable @typescript-eslint/unbound-method */ const IS_WINDOWS = process.platform === 'win32'; /* @@ -804,6 +811,12 @@ class ToolRunner extends events.EventEmitter { resolve(exitCode); } }); + if (this.options.input) { + if (!cp.stdin) { + throw new Error('child process missing stdin'); + } + cp.stdin.end(this.options.input); + } }); }); } @@ -932,6 +945,442 @@ class ExecState extends events.EventEmitter { } //# sourceMappingURL=toolrunner.js.map +/***/ }), + +/***/ 16: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const compareBuild = (a, b, loose) => { + const versionA = new SemVer(a, loose) + const versionB = new SemVer(b, loose) + return versionA.compare(versionB) || versionA.compareBuild(versionB) +} +module.exports = compareBuild + + +/***/ }), + +/***/ 20: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) + +// Mostly just for testing and legacy API reasons +const toComparators = (range, options) => + new Range(range, options).set + .map(comp => comp.map(c => c.value).join(' ').trim().split(' ')) + +module.exports = toComparators + + +/***/ }), + +/***/ 31: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const semver = __importStar(__webpack_require__(550)); +const core_1 = __webpack_require__(470); +// needs to be require for core node modules to be mocked +/* eslint @typescript-eslint/no-require-imports: 0 */ +const os = __webpack_require__(87); +const cp = __webpack_require__(129); +const fs = __webpack_require__(747); +function _findMatch(versionSpec, stable, candidates, archFilter) { + return __awaiter(this, void 0, void 0, function* () { + const platFilter = os.platform(); + let result; + let match; + let file; + for (const candidate of candidates) { + const version = candidate.version; + core_1.debug(`check ${version} satisfies ${versionSpec}`); + if (semver.satisfies(version, versionSpec) && + (!stable || candidate.stable === stable)) { + file = candidate.files.find(item => { + core_1.debug(`${item.arch}===${archFilter} && ${item.platform}===${platFilter}`); + let chk = item.arch === archFilter && item.platform === platFilter; + if (chk && item.platform_version) { + const osVersion = module.exports._getOsVersion(); + if (osVersion === item.platform_version) { + chk = true; + } + else { + chk = semver.satisfies(osVersion, item.platform_version); + } + } + return chk; + }); + if (file) { + core_1.debug(`matched ${candidate.version}`); + match = candidate; + break; + } + } + } + if (match && file) { + // clone since we're mutating the file list to be only the file that matches + result = Object.assign({}, match); + result.files = [file]; + } + return result; + }); +} +exports._findMatch = _findMatch; +function _getOsVersion() { + // TODO: add windows and other linux, arm variants + // right now filtering on version is only an ubuntu and macos scenario for tools we build for hosted (python) + const plat = os.platform(); + let version = ''; + if (plat === 'darwin') { + version = cp.execSync('sw_vers -productVersion').toString(); + } + else if (plat === 'linux') { + // lsb_release process not in some containers, readfile + // Run cat /etc/lsb-release + // DISTRIB_ID=Ubuntu + // DISTRIB_RELEASE=18.04 + // DISTRIB_CODENAME=bionic + // DISTRIB_DESCRIPTION="Ubuntu 18.04.4 LTS" + const lsbContents = module.exports._readLinuxVersionFile(); + if (lsbContents) { + const lines = lsbContents.split('\n'); + for (const line of lines) { + const parts = line.split('='); + if (parts.length === 2 && parts[0].trim() === 'DISTRIB_RELEASE') { + version = parts[1].trim(); + break; + } + } + } + } + return version; +} +exports._getOsVersion = _getOsVersion; +function _readLinuxVersionFile() { + const lsbFile = '/etc/lsb-release'; + let contents = ''; + if (fs.existsSync(lsbFile)) { + contents = fs.readFileSync(lsbFile).toString(); + } + return contents; +} +exports._readLinuxVersionFile = _readLinuxVersionFile; +//# sourceMappingURL=manifest.js.map + +/***/ }), + +/***/ 65: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const debug = __webpack_require__(548) +const { MAX_LENGTH, MAX_SAFE_INTEGER } = __webpack_require__(181) +const { re, t } = __webpack_require__(976) + +const parseOptions = __webpack_require__(143) +const { compareIdentifiers } = __webpack_require__(760) +class SemVer { + constructor (version, options) { + options = parseOptions(options) + + if (version instanceof SemVer) { + if (version.loose === !!options.loose && + version.includePrerelease === !!options.includePrerelease) { + return version + } else { + version = version.version + } + } else if (typeof version !== 'string') { + throw new TypeError(`Invalid Version: ${version}`) + } + + if (version.length > MAX_LENGTH) { + throw new TypeError( + `version is longer than ${MAX_LENGTH} characters` + ) + } + + debug('SemVer', version, options) + this.options = options + this.loose = !!options.loose + // this isn't actually relevant for versions, but keep it so that we + // don't run into trouble passing this.options around. + this.includePrerelease = !!options.includePrerelease + + const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]) + + if (!m) { + throw new TypeError(`Invalid Version: ${version}`) + } + + this.raw = version + + // these are actually numbers + this.major = +m[1] + this.minor = +m[2] + this.patch = +m[3] + + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError('Invalid major version') + } + + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError('Invalid minor version') + } + + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError('Invalid patch version') + } + + // numberify any prerelease numeric ids + if (!m[4]) { + this.prerelease = [] + } else { + this.prerelease = m[4].split('.').map((id) => { + if (/^[0-9]+$/.test(id)) { + const num = +id + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id + }) + } + + this.build = m[5] ? m[5].split('.') : [] + this.format() + } + + format () { + this.version = `${this.major}.${this.minor}.${this.patch}` + if (this.prerelease.length) { + this.version += `-${this.prerelease.join('.')}` + } + return this.version + } + + toString () { + return this.version + } + + compare (other) { + debug('SemVer.compare', this.version, this.options, other) + if (!(other instanceof SemVer)) { + if (typeof other === 'string' && other === this.version) { + return 0 + } + other = new SemVer(other, this.options) + } + + if (other.version === this.version) { + return 0 + } + + return this.compareMain(other) || this.comparePre(other) + } + + compareMain (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return ( + compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) + ) + } + + comparePre (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + // NOT having a prerelease is > having one + if (this.prerelease.length && !other.prerelease.length) { + return -1 + } else if (!this.prerelease.length && other.prerelease.length) { + return 1 + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0 + } + + let i = 0 + do { + const a = this.prerelease[i] + const b = other.prerelease[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) + } + + compareBuild (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + let i = 0 + do { + const a = this.build[i] + const b = other.build[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) + } + + // preminor will bump the version up to the next minor release, and immediately + // down to pre-release. premajor and prepatch work the same way. + inc (release, identifier) { + switch (release) { + case 'premajor': + this.prerelease.length = 0 + this.patch = 0 + this.minor = 0 + this.major++ + this.inc('pre', identifier) + break + case 'preminor': + this.prerelease.length = 0 + this.patch = 0 + this.minor++ + this.inc('pre', identifier) + break + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0 + this.inc('patch', identifier) + this.inc('pre', identifier) + break + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if (this.prerelease.length === 0) { + this.inc('patch', identifier) + } + this.inc('pre', identifier) + break + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + if ( + this.minor !== 0 || + this.patch !== 0 || + this.prerelease.length === 0 + ) { + this.major++ + } + this.minor = 0 + this.patch = 0 + this.prerelease = [] + break + case 'minor': + // If this is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++ + } + this.patch = 0 + this.prerelease = [] + break + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if (this.prerelease.length === 0) { + this.patch++ + } + this.prerelease = [] + break + // This probably shouldn't be used publicly. + // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction. + case 'pre': + if (this.prerelease.length === 0) { + this.prerelease = [0] + } else { + let i = this.prerelease.length + while (--i >= 0) { + if (typeof this.prerelease[i] === 'number') { + this.prerelease[i]++ + i = -2 + } + } + if (i === -1) { + // didn't increment anything + this.prerelease.push(0) + } + } + if (identifier) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + if (this.prerelease[0] === identifier) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0] + } + } else { + this.prerelease = [identifier, 0] + } + } + break + + default: + throw new Error(`invalid increment argument: ${release}`) + } + this.format() + this.raw = this.version + return this + } +} + +module.exports = SemVer + + /***/ }), /***/ 82: @@ -1001,6 +1450,533 @@ function issueCommand(command, message) { exports.issueCommand = issueCommand; //# sourceMappingURL=file-command.js.map +/***/ }), + +/***/ 120: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compareBuild = __webpack_require__(16) +const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose)) +module.exports = sort + + +/***/ }), + +/***/ 124: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// hoisted class for cyclic dependency +class Range { + constructor (range, options) { + options = parseOptions(options) + + if (range instanceof Range) { + if ( + range.loose === !!options.loose && + range.includePrerelease === !!options.includePrerelease + ) { + return range + } else { + return new Range(range.raw, options) + } + } + + if (range instanceof Comparator) { + // just put it in the set and return + this.raw = range.value + this.set = [[range]] + this.format() + return this + } + + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + + // First, split based on boolean or || + this.raw = range + this.set = range + .split(/\s*\|\|\s*/) + // map the range to a 2d array of comparators + .map(range => this.parseRange(range.trim())) + // throw out any comparator lists that are empty + // this generally means that it was not a valid range, which is allowed + // in loose mode, but will still throw if the WHOLE range is invalid. + .filter(c => c.length) + + if (!this.set.length) { + throw new TypeError(`Invalid SemVer Range: ${range}`) + } + + // if we have any that are not the null set, throw out null sets. + if (this.set.length > 1) { + // keep the first one, in case they're all null sets + const first = this.set[0] + this.set = this.set.filter(c => !isNullSet(c[0])) + if (this.set.length === 0) + this.set = [first] + else if (this.set.length > 1) { + // if we have any that are *, then the range is just * + for (const c of this.set) { + if (c.length === 1 && isAny(c[0])) { + this.set = [c] + break + } + } + } + } + + this.format() + } + + format () { + this.range = this.set + .map((comps) => { + return comps.join(' ').trim() + }) + .join('||') + .trim() + return this.range + } + + toString () { + return this.range + } + + parseRange (range) { + range = range.trim() + + // memoize range parsing for performance. + // this is a very hot path, and fully deterministic. + const memoOpts = Object.keys(this.options).join(',') + const memoKey = `parseRange:${memoOpts}:${range}` + const cached = cache.get(memoKey) + if (cached) + return cached + + const loose = this.options.loose + // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` + const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE] + range = range.replace(hr, hyphenReplace(this.options.includePrerelease)) + debug('hyphen replace', range) + // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` + range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace) + debug('comparator trim', range, re[t.COMPARATORTRIM]) + + // `~ 1.2.3` => `~1.2.3` + range = range.replace(re[t.TILDETRIM], tildeTrimReplace) + + // `^ 1.2.3` => `^1.2.3` + range = range.replace(re[t.CARETTRIM], caretTrimReplace) + + // normalize spaces + range = range.split(/\s+/).join(' ') + + // At this point, the range is completely trimmed and + // ready to be split into comparators. + + const compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] + const rangeList = range + .split(' ') + .map(comp => parseComparator(comp, this.options)) + .join(' ') + .split(/\s+/) + // >=0.0.0 is equivalent to * + .map(comp => replaceGTE0(comp, this.options)) + // in loose mode, throw out any that are not valid comparators + .filter(this.options.loose ? comp => !!comp.match(compRe) : () => true) + .map(comp => new Comparator(comp, this.options)) + + // if any comparators are the null set, then replace with JUST null set + // if more than one comparator, remove any * comparators + // also, don't include the same comparator more than once + const l = rangeList.length + const rangeMap = new Map() + for (const comp of rangeList) { + if (isNullSet(comp)) + return [comp] + rangeMap.set(comp.value, comp) + } + if (rangeMap.size > 1 && rangeMap.has('')) + rangeMap.delete('') + + const result = [...rangeMap.values()] + cache.set(memoKey, result) + return result + } + + intersects (range, options) { + if (!(range instanceof Range)) { + throw new TypeError('a Range is required') + } + + return this.set.some((thisComparators) => { + return ( + isSatisfiable(thisComparators, options) && + range.set.some((rangeComparators) => { + return ( + isSatisfiable(rangeComparators, options) && + thisComparators.every((thisComparator) => { + return rangeComparators.every((rangeComparator) => { + return thisComparator.intersects(rangeComparator, options) + }) + }) + ) + }) + ) + }) + } + + // if ANY of the sets match ALL of its comparators, then pass + test (version) { + if (!version) { + return false + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + for (let i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true + } + } + return false + } +} +module.exports = Range + +const LRU = __webpack_require__(702) +const cache = new LRU({ max: 1000 }) + +const parseOptions = __webpack_require__(143) +const Comparator = __webpack_require__(174) +const debug = __webpack_require__(548) +const SemVer = __webpack_require__(65) +const { + re, + t, + comparatorTrimReplace, + tildeTrimReplace, + caretTrimReplace +} = __webpack_require__(976) + +const isNullSet = c => c.value === '<0.0.0-0' +const isAny = c => c.value === '' + +// take a set of comparators and determine whether there +// exists a version which can satisfy it +const isSatisfiable = (comparators, options) => { + let result = true + const remainingComparators = comparators.slice() + let testComparator = remainingComparators.pop() + + while (result && remainingComparators.length) { + result = remainingComparators.every((otherComparator) => { + return testComparator.intersects(otherComparator, options) + }) + + testComparator = remainingComparators.pop() + } + + return result +} + +// comprised of xranges, tildes, stars, and gtlt's at this point. +// already replaced the hyphen ranges +// turn into a set of JUST comparators. +const parseComparator = (comp, options) => { + debug('comp', comp, options) + comp = replaceCarets(comp, options) + debug('caret', comp) + comp = replaceTildes(comp, options) + debug('tildes', comp) + comp = replaceXRanges(comp, options) + debug('xrange', comp) + comp = replaceStars(comp, options) + debug('stars', comp) + return comp +} + +const isX = id => !id || id.toLowerCase() === 'x' || id === '*' + +// ~, ~> --> * (any, kinda silly) +// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0 +// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0 +// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0 +// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0 +// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0 +const replaceTildes = (comp, options) => + comp.trim().split(/\s+/).map((comp) => { + return replaceTilde(comp, options) + }).join(' ') + +const replaceTilde = (comp, options) => { + const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE] + return comp.replace(r, (_, M, m, p, pr) => { + debug('tilde', comp, _, M, m, p, pr) + let ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = `>=${M}.0.0 <${+M + 1}.0.0-0` + } else if (isX(p)) { + // ~1.2 == >=1.2.0 <1.3.0-0 + ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0` + } else if (pr) { + debug('replaceTilde pr', pr) + ret = `>=${M}.${m}.${p}-${pr + } <${M}.${+m + 1}.0-0` + } else { + // ~1.2.3 == >=1.2.3 <1.3.0-0 + ret = `>=${M}.${m}.${p + } <${M}.${+m + 1}.0-0` + } + + debug('tilde return', ret) + return ret + }) +} + +// ^ --> * (any, kinda silly) +// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0 +// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0 +// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0 +// ^1.2.3 --> >=1.2.3 <2.0.0-0 +// ^1.2.0 --> >=1.2.0 <2.0.0-0 +const replaceCarets = (comp, options) => + comp.trim().split(/\s+/).map((comp) => { + return replaceCaret(comp, options) + }).join(' ') + +const replaceCaret = (comp, options) => { + debug('caret', comp, options) + const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET] + const z = options.includePrerelease ? '-0' : '' + return comp.replace(r, (_, M, m, p, pr) => { + debug('caret', comp, _, M, m, p, pr) + let ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0` + } else if (isX(p)) { + if (M === '0') { + ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0` + } else { + ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0` + } + } else if (pr) { + debug('replaceCaret pr', pr) + if (M === '0') { + if (m === '0') { + ret = `>=${M}.${m}.${p}-${pr + } <${M}.${m}.${+p + 1}-0` + } else { + ret = `>=${M}.${m}.${p}-${pr + } <${M}.${+m + 1}.0-0` + } + } else { + ret = `>=${M}.${m}.${p}-${pr + } <${+M + 1}.0.0-0` + } + } else { + debug('no pr') + if (M === '0') { + if (m === '0') { + ret = `>=${M}.${m}.${p + }${z} <${M}.${m}.${+p + 1}-0` + } else { + ret = `>=${M}.${m}.${p + }${z} <${M}.${+m + 1}.0-0` + } + } else { + ret = `>=${M}.${m}.${p + } <${+M + 1}.0.0-0` + } + } + + debug('caret return', ret) + return ret + }) +} + +const replaceXRanges = (comp, options) => { + debug('replaceXRanges', comp, options) + return comp.split(/\s+/).map((comp) => { + return replaceXRange(comp, options) + }).join(' ') +} + +const replaceXRange = (comp, options) => { + comp = comp.trim() + const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE] + return comp.replace(r, (ret, gtlt, M, m, p, pr) => { + debug('xRange', comp, ret, gtlt, M, m, p, pr) + const xM = isX(M) + const xm = xM || isX(m) + const xp = xm || isX(p) + const anyX = xp + + if (gtlt === '=' && anyX) { + gtlt = '' + } + + // if we're including prereleases in the match, then we need + // to fix this to -0, the lowest possible prerelease value + pr = options.includePrerelease ? '-0' : '' + + if (xM) { + if (gtlt === '>' || gtlt === '<') { + // nothing is allowed + ret = '<0.0.0-0' + } else { + // nothing is forbidden + ret = '*' + } + } else if (gtlt && anyX) { + // we know patch is an x, because we have any x at all. + // replace X with 0 + if (xm) { + m = 0 + } + p = 0 + + if (gtlt === '>') { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + gtlt = '>=' + if (xm) { + M = +M + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === '<=') { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<' + if (xm) { + M = +M + 1 + } else { + m = +m + 1 + } + } + + if (gtlt === '<') + pr = '-0' + + ret = `${gtlt + M}.${m}.${p}${pr}` + } else if (xm) { + ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0` + } else if (xp) { + ret = `>=${M}.${m}.0${pr + } <${M}.${+m + 1}.0-0` + } + + debug('xRange return', ret) + + return ret + }) +} + +// Because * is AND-ed with everything else in the comparator, +// and '' means "any version", just remove the *s entirely. +const replaceStars = (comp, options) => { + debug('replaceStars', comp, options) + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace(re[t.STAR], '') +} + +const replaceGTE0 = (comp, options) => { + debug('replaceGTE0', comp, options) + return comp.trim() + .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '') +} + +// This function is passed to string.replace(re[t.HYPHENRANGE]) +// M, m, patch, prerelease, build +// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 +// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do +// 1.2 - 3.4 => >=1.2.0 <3.5.0-0 +const hyphenReplace = incPr => ($0, + from, fM, fm, fp, fpr, fb, + to, tM, tm, tp, tpr, tb) => { + if (isX(fM)) { + from = '' + } else if (isX(fm)) { + from = `>=${fM}.0.0${incPr ? '-0' : ''}` + } else if (isX(fp)) { + from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}` + } else if (fpr) { + from = `>=${from}` + } else { + from = `>=${from}${incPr ? '-0' : ''}` + } + + if (isX(tM)) { + to = '' + } else if (isX(tm)) { + to = `<${+tM + 1}.0.0-0` + } else if (isX(tp)) { + to = `<${tM}.${+tm + 1}.0-0` + } else if (tpr) { + to = `<=${tM}.${tm}.${tp}-${tpr}` + } else if (incPr) { + to = `<${tM}.${tm}.${+tp + 1}-0` + } else { + to = `<=${to}` + } + + return (`${from} ${to}`).trim() +} + +const testSet = (set, version, options) => { + for (let i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false + } + } + + if (version.prerelease.length && !options.includePrerelease) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for (let i = 0; i < set.length; i++) { + debug(set[i].semver) + if (set[i].semver === Comparator.ANY) { + continue + } + + if (set[i].semver.prerelease.length > 0) { + const allowed = set[i].semver + if (allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch) { + return true + } + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false + } + + return true +} + + /***/ }), /***/ 129: @@ -1010,27 +1986,558 @@ module.exports = require("child_process"); /***/ }), -/***/ 211: -/***/ (function(__unusedmodule, exports) { +/***/ 139: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// Unique ID creation requires a high quality random # generator. In node.js +// this is pretty straight-forward - we use the crypto API. + +var crypto = __webpack_require__(417); + +module.exports = function nodeRNG() { + return crypto.randomBytes(16); +}; + + +/***/ }), + +/***/ 141: +/***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; -Object.defineProperty(exports, "__esModule", { value: true }); -exports.INPUT_VERSION = 'version'; -exports.INPUT_JAVA_VERSION = 'java-version'; -exports.INPUT_ARCHITECTURE = 'architecture'; -exports.INPUT_JAVA_PACKAGE = 'java-package'; -exports.INPUT_JDK_FILE = 'jdkFile'; -exports.INPUT_SERVER_ID = 'server-id'; -exports.INPUT_SERVER_USERNAME = 'server-username'; -exports.INPUT_SERVER_PASSWORD = 'server-password'; -exports.INPUT_SETTINGS_PATH = 'settings-path'; -exports.INPUT_GPG_PRIVATE_KEY = 'gpg-private-key'; -exports.INPUT_GPG_PASSPHRASE = 'gpg-passphrase'; -exports.INPUT_DEFAULT_GPG_PRIVATE_KEY = undefined; -exports.INPUT_DEFAULT_GPG_PASSPHRASE = 'GPG_PASSPHRASE'; -exports.STATE_GPG_PRIVATE_KEY_FINGERPRINT = 'gpg-private-key-fingerprint'; +var net = __webpack_require__(631); +var tls = __webpack_require__(818); +var http = __webpack_require__(605); +var https = __webpack_require__(211); +var events = __webpack_require__(614); +var assert = __webpack_require__(357); +var util = __webpack_require__(669); + + +exports.httpOverHttp = httpOverHttp; +exports.httpsOverHttp = httpsOverHttp; +exports.httpOverHttps = httpOverHttps; +exports.httpsOverHttps = httpsOverHttps; + + +function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + return agent; +} + +function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; +} + +function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + return agent; +} + +function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; +} + + +function TunnelingAgent(options) { + var self = this; + self.options = options || {}; + self.proxyOptions = self.options.proxy || {}; + self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; + self.requests = []; + self.sockets = []; + + self.on('free', function onFree(socket, host, port, localAddress) { + var options = toOptions(host, port, localAddress); + for (var i = 0, len = self.requests.length; i < len; ++i) { + var pending = self.requests[i]; + if (pending.host === options.host && pending.port === options.port) { + // Detect the request to connect same origin server, + // reuse the connection. + self.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self.removeSocket(socket); + }); +} +util.inherits(TunnelingAgent, events.EventEmitter); + +TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self = this; + var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); + + if (self.sockets.length >= this.maxSockets) { + // We are over limit so we'll add it to the queue. + self.requests.push(options); + return; + } + + // If we are under maxSockets create a new one. + self.createSocket(options, function(socket) { + socket.on('free', onFree); + socket.on('close', onCloseOrRemove); + socket.on('agentRemove', onCloseOrRemove); + req.onSocket(socket); + + function onFree() { + self.emit('free', socket, options); + } + + function onCloseOrRemove(err) { + self.removeSocket(socket); + socket.removeListener('free', onFree); + socket.removeListener('close', onCloseOrRemove); + socket.removeListener('agentRemove', onCloseOrRemove); + } + }); +}; + +TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self = this; + var placeholder = {}; + self.sockets.push(placeholder); + + var connectOptions = mergeOptions({}, self.proxyOptions, { + method: 'CONNECT', + path: options.host + ':' + options.port, + agent: false, + headers: { + host: options.host + ':' + options.port + } + }); + if (options.localAddress) { + connectOptions.localAddress = options.localAddress; + } + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers['Proxy-Authorization'] = 'Basic ' + + new Buffer(connectOptions.proxyAuth).toString('base64'); + } + + debug('making CONNECT request'); + var connectReq = self.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; // for v0.6 + connectReq.once('response', onResponse); // for v0.6 + connectReq.once('upgrade', onUpgrade); // for v0.6 + connectReq.once('connect', onConnect); // for v0.7 or later + connectReq.once('error', onError); + connectReq.end(); + + function onResponse(res) { + // Very hacky. This is necessary to avoid http-parser leaks. + res.upgrade = true; + } + + function onUpgrade(res, socket, head) { + // Hacky. + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + + if (res.statusCode !== 200) { + debug('tunneling socket could not be established, statusCode=%d', + res.statusCode); + socket.destroy(); + var error = new Error('tunneling socket could not be established, ' + + 'statusCode=' + res.statusCode); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + return; + } + if (head.length > 0) { + debug('got illegal response body from proxy'); + socket.destroy(); + var error = new Error('got illegal response body from proxy'); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + return; + } + debug('tunneling connection has established'); + self.sockets[self.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } + + function onError(cause) { + connectReq.removeAllListeners(); + + debug('tunneling socket could not be established, cause=%s\n', + cause.message, cause.stack); + var error = new Error('tunneling socket could not be established, ' + + 'cause=' + cause.message); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + } +}; + +TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket) + if (pos === -1) { + return; + } + this.sockets.splice(pos, 1); + + var pending = this.requests.shift(); + if (pending) { + // If we have pending requests and a socket gets closed a new one + // needs to be created to take over in the pool for the one that closed. + this.createSocket(pending, function(socket) { + pending.request.onSocket(socket); + }); + } +}; + +function createSecureSocket(options, cb) { + var self = this; + TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { + var hostHeader = options.request.getHeader('host'); + var tlsOptions = mergeOptions({}, self.options, { + socket: socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host + }); + + // 0 is dummy port for v0.6 + var secureSocket = tls.connect(0, tlsOptions); + self.sockets[self.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); +} + + +function toOptions(host, port, localAddress) { + if (typeof host === 'string') { // since v0.10 + return { + host: host, + port: port, + localAddress: localAddress + }; + } + return host; // for v0.11 or later +} + +function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === 'object') { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== undefined) { + target[k] = overrides[k]; + } + } + } + } + return target; +} + + +var debug; +if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === 'string') { + args[0] = 'TUNNEL: ' + args[0]; + } else { + args.unshift('TUNNEL:'); + } + console.error.apply(console, args); + } +} else { + debug = function() {}; +} +exports.debug = debug; // for test + + +/***/ }), + +/***/ 143: +/***/ (function(module) { + +// parse out just the options we care about so we always get a consistent +// obj with keys in a consistent order. +const opts = ['includePrerelease', 'loose', 'rtl'] +const parseOptions = options => + !options ? {} + : typeof options !== 'object' ? { loose: true } + : opts.filter(k => options[k]).reduce((options, k) => { + options[k] = true + return options + }, {}) +module.exports = parseOptions + + +/***/ }), + +/***/ 164: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) +const gt = __webpack_require__(486) + +const minVersion = (range, loose) => { + range = new Range(range, loose) + + let minver = new SemVer('0.0.0') + if (range.test(minver)) { + return minver + } + + minver = new SemVer('0.0.0-0') + if (range.test(minver)) { + return minver + } + + minver = null + for (let i = 0; i < range.set.length; ++i) { + const comparators = range.set[i] + + let setMin = null + comparators.forEach((comparator) => { + // Clone to avoid manipulating the comparator's semver object. + const compver = new SemVer(comparator.semver.version) + switch (comparator.operator) { + case '>': + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + /* fallthrough */ + case '': + case '>=': + if (!setMin || gt(compver, setMin)) { + setMin = compver + } + break + case '<': + case '<=': + /* Ignore maximum versions */ + break + /* istanbul ignore next */ + default: + throw new Error(`Unexpected operation: ${comparator.operator}`) + } + }) + if (setMin && (!minver || gt(minver, setMin))) + minver = setMin + } + + if (minver && range.test(minver)) { + return minver + } + + return null +} +module.exports = minVersion + + +/***/ }), + +/***/ 167: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const gte = (a, b, loose) => compare(a, b, loose) >= 0 +module.exports = gte + + +/***/ }), + +/***/ 174: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const ANY = Symbol('SemVer ANY') +// hoisted class for cyclic dependency +class Comparator { + static get ANY () { + return ANY + } + constructor (comp, options) { + options = parseOptions(options) + + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp + } else { + comp = comp.value + } + } + + debug('comparator', comp, options) + this.options = options + this.loose = !!options.loose + this.parse(comp) + + if (this.semver === ANY) { + this.value = '' + } else { + this.value = this.operator + this.semver.version + } + + debug('comp', this) + } + + parse (comp) { + const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] + const m = comp.match(r) + + if (!m) { + throw new TypeError(`Invalid comparator: ${comp}`) + } + + this.operator = m[1] !== undefined ? m[1] : '' + if (this.operator === '=') { + this.operator = '' + } + + // if it literally is just '>' or '' then allow anything. + if (!m[2]) { + this.semver = ANY + } else { + this.semver = new SemVer(m[2], this.options.loose) + } + } + + toString () { + return this.value + } + + test (version) { + debug('Comparator.test', version, this.options.loose) + + if (this.semver === ANY || version === ANY) { + return true + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + return cmp(version, this.operator, this.semver, this.options) + } + + intersects (comp, options) { + if (!(comp instanceof Comparator)) { + throw new TypeError('a Comparator is required') + } + + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (this.operator === '') { + if (this.value === '') { + return true + } + return new Range(comp.value, options).test(this.value) + } else if (comp.operator === '') { + if (comp.value === '') { + return true + } + return new Range(this.value, options).test(comp.semver) + } + + const sameDirectionIncreasing = + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '>=' || comp.operator === '>') + const sameDirectionDecreasing = + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '<=' || comp.operator === '<') + const sameSemVer = this.semver.version === comp.semver.version + const differentDirectionsInclusive = + (this.operator === '>=' || this.operator === '<=') && + (comp.operator === '>=' || comp.operator === '<=') + const oppositeDirectionsLessThan = + cmp(this.semver, '<', comp.semver, options) && + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '<=' || comp.operator === '<') + const oppositeDirectionsGreaterThan = + cmp(this.semver, '>', comp.semver, options) && + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '>=' || comp.operator === '>') + + return ( + sameDirectionIncreasing || + sameDirectionDecreasing || + (sameSemVer && differentDirectionsInclusive) || + oppositeDirectionsLessThan || + oppositeDirectionsGreaterThan + ) + } +} + +module.exports = Comparator + +const parseOptions = __webpack_require__(143) +const {re, t} = __webpack_require__(976) +const cmp = __webpack_require__(752) +const debug = __webpack_require__(548) +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) + + +/***/ }), + +/***/ 181: +/***/ (function(module) { + +// Note: this is the semver.org version of the spec that it implements +// Not necessarily the package version of this code. +const SEMVER_SPEC_VERSION = '2.0.0' + +const MAX_LENGTH = 256 +const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || + /* istanbul ignore next */ 9007199254740991 + +// Max safe segment length for coercion. +const MAX_SAFE_COMPONENT_LENGTH = 16 + +module.exports = { + SEMVER_SPEC_VERSION, + MAX_LENGTH, + MAX_SAFE_INTEGER, + MAX_SAFE_COMPONENT_LENGTH +} + + +/***/ }), + +/***/ 211: +/***/ (function(module) { + +module.exports = require("https"); /***/ }), @@ -1039,6 +2546,25 @@ exports.STATE_GPG_PRIVATE_KEY_FINGERPRINT = 'gpg-private-key-fingerprint'; "use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; 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) { @@ -1048,27 +2574,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge step((generator = generator.apply(thisArg, _arguments || [])).next()); }); }; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; Object.defineProperty(exports, "__esModule", { value: true }); const core = __importStar(__webpack_require__(470)); const gpg = __importStar(__webpack_require__(884)); -const constants = __importStar(__webpack_require__(211)); +const constants = __importStar(__webpack_require__(694)); function run() { return __awaiter(this, void 0, void 0, function* () { if (core.getInput(constants.INPUT_GPG_PRIVATE_KEY, { required: false })) { - core.info('removing private key from keychain'); + core.info('Removing private key from keychain'); try { const keyFingerprint = core.getState(constants.STATE_GPG_PRIVATE_KEY_FINGERPRINT); yield gpg.deleteKey(keyFingerprint); } catch (error) { - core.setFailed('failed to remove private key'); + core.setFailed('Failed to remove private key'); } } }); @@ -1076,6 +2595,57 @@ function run() { run(); +/***/ }), + +/***/ 259: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) +const intersects = (r1, r2, options) => { + r1 = new Range(r1, options) + r2 = new Range(r2, options) + return r1.intersects(r2) +} +module.exports = intersects + + +/***/ }), + +/***/ 283: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const compareLoose = (a, b) => compare(a, b, true) +module.exports = compareLoose + + +/***/ }), + +/***/ 298: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const eq = (a, b, loose) => compare(a, b, loose) === 0 +module.exports = eq + + +/***/ }), + +/***/ 310: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) +const satisfies = (version, range, options) => { + try { + range = new Range(range, options) + } catch (er) { + return false + } + return range.test(version) +} +module.exports = satisfies + + /***/ }), /***/ 322: @@ -1083,42 +2653,115 @@ run(); "use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); var __importStar = (this && this.__importStar) || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; + if (mod != null) for (var k in mod) if (k !== "default" && Object.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 }); -const path = __importStar(__webpack_require__(622)); +exports.getToolcachePath = exports.isVersionSatisfies = exports.getDownloadArchiveExtension = exports.extractJdkFile = exports.getVersionFromToolcachePath = exports.getTempDir = void 0; +const os_1 = __importDefault(__webpack_require__(87)); +const path_1 = __importDefault(__webpack_require__(622)); +const fs = __importStar(__webpack_require__(747)); +const semver = __importStar(__webpack_require__(876)); +const tc = __importStar(__webpack_require__(533)); function getTempDir() { - let tempDirectory = process.env.RUNNER_TEMP; - if (tempDirectory === undefined) { - let baseLocation; - if (isWindows()) { - // On windows use the USERPROFILE env variable - baseLocation = process.env['USERPROFILE'] - ? process.env['USERPROFILE'] - : 'C:\\'; - } - else { - if (process.platform === 'darwin') { - baseLocation = '/Users'; - } - else { - baseLocation = '/home'; - } - } - tempDirectory = path.join(baseLocation, 'actions', 'temp'); - } + let tempDirectory = process.env['RUNNER_TEMP'] || os_1.default.tmpdir(); return tempDirectory; } exports.getTempDir = getTempDir; -function isWindows() { - return process.platform === 'win32'; +function getVersionFromToolcachePath(toolPath) { + if (toolPath) { + return path_1.default.basename(path_1.default.dirname(toolPath)); + } + return toolPath; } -exports.isWindows = isWindows; +exports.getVersionFromToolcachePath = getVersionFromToolcachePath; +function extractJdkFile(toolPath, extension) { + return __awaiter(this, void 0, void 0, function* () { + if (!extension) { + extension = toolPath.endsWith('.tar.gz') ? 'tar.gz' : path_1.default.extname(toolPath); + if (extension.startsWith('.')) { + extension = extension.substring(1); + } + } + switch (extension) { + case 'tar.gz': + case 'tar': + return yield tc.extractTar(toolPath); + case 'zip': + return yield tc.extractZip(toolPath); + default: + return yield tc.extract7z(toolPath); + } + }); +} +exports.extractJdkFile = extractJdkFile; +function getDownloadArchiveExtension() { + return process.platform === 'win32' ? 'zip' : 'tar.gz'; +} +exports.getDownloadArchiveExtension = getDownloadArchiveExtension; +function isVersionSatisfies(range, version) { + var _a; + if (semver.valid(range)) { + // if full version with build digit is provided as a range (such as '1.2.3+4') + // we should check for exact equal via compareBuild + // since semver.satisfies doesn't handle 4th digit + const semRange = semver.parse(range); + if (semRange && ((_a = semRange.build) === null || _a === void 0 ? void 0 : _a.length) > 0) { + return semver.compareBuild(range, version) === 0; + } + } + return semver.satisfies(version, range); +} +exports.isVersionSatisfies = isVersionSatisfies; +function getToolcachePath(toolName, version, architecture) { + var _a; + const toolcacheRoot = (_a = process.env['RUNNER_TOOL_CACHE']) !== null && _a !== void 0 ? _a : ''; + const fullPath = path_1.default.join(toolcacheRoot, toolName, version, architecture); + if (fs.existsSync(fullPath)) { + return fullPath; + } + return null; +} +exports.getToolcachePath = getToolcachePath; + + +/***/ }), + +/***/ 323: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const outside = __webpack_require__(462) +// Determine if version is less than all the versions possible in the range +const ltr = (version, range, options) => outside(version, range, '<', options) +module.exports = ltr /***/ }), @@ -1130,6 +2773,37 @@ module.exports = require("assert"); /***/ }), +/***/ 396: +/***/ (function(module) { + +"use strict"; + +module.exports = function (Yallist) { + Yallist.prototype[Symbol.iterator] = function* () { + for (let walker = this.head; walker; walker = walker.next) { + yield walker.value + } + } +} + + +/***/ }), + +/***/ 413: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = __webpack_require__(141); + + +/***/ }), + +/***/ 417: +/***/ (function(module) { + +module.exports = require("crypto"); + +/***/ }), + /***/ 431: /***/ (function(__unusedmodule, exports, __webpack_require__) { @@ -1214,6 +2888,93 @@ function escapeProperty(s) { } //# sourceMappingURL=command.js.map +/***/ }), + +/***/ 462: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const Comparator = __webpack_require__(174) +const {ANY} = Comparator +const Range = __webpack_require__(124) +const satisfies = __webpack_require__(310) +const gt = __webpack_require__(486) +const lt = __webpack_require__(586) +const lte = __webpack_require__(898) +const gte = __webpack_require__(167) + +const outside = (version, range, hilo, options) => { + version = new SemVer(version, options) + range = new Range(range, options) + + let gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case '>': + gtfn = gt + ltefn = lte + ltfn = lt + comp = '>' + ecomp = '>=' + break + case '<': + gtfn = lt + ltefn = gte + ltfn = gt + comp = '<' + ecomp = '<=' + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + + // If it satisfies the range it is not outside + if (satisfies(version, range, options)) { + return false + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for (let i = 0; i < range.set.length; ++i) { + const comparators = range.set[i] + + let high = null + let low = null + + comparators.forEach((comparator) => { + if (comparator.semver === ANY) { + comparator = new Comparator('>=0.0.0') + } + high = high || comparator + low = low || comparator + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator + } + }) + + // If the edge version comparator has a operator then our version + // isn't outside it + if (high.operator === comp || high.operator === ecomp) { + return false + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ((!low.operator || low.operator === comp) && + ltefn(version, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false + } + } + return true +} + +module.exports = outside + + /***/ }), /***/ 470: @@ -1459,6 +3220,3362 @@ function getState(name) { exports.getState = getState; //# sourceMappingURL=core.js.map +/***/ }), + +/***/ 480: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) +const validRange = (range, options) => { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range(range, options).range || '*' + } catch (er) { + return null + } +} +module.exports = validRange + + +/***/ }), + +/***/ 486: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const gt = (a, b, loose) => compare(a, b, loose) > 0 +module.exports = gt + + +/***/ }), + +/***/ 489: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const patch = (a, loose) => new SemVer(a, loose).patch +module.exports = patch + + +/***/ }), + +/***/ 499: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const parse = __webpack_require__(830) +const {re, t} = __webpack_require__(976) + +const coerce = (version, options) => { + if (version instanceof SemVer) { + return version + } + + if (typeof version === 'number') { + version = String(version) + } + + if (typeof version !== 'string') { + return null + } + + options = options || {} + + let match = null + if (!options.rtl) { + match = version.match(re[t.COERCE]) + } else { + // Find the right-most coercible string that does not share + // a terminus with a more left-ward coercible string. + // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' + // + // Walk through the string checking with a /g regexp + // Manually set the index so as to pick up overlapping matches. + // Stop when we get a match that ends at the string end, since no + // coercible string can be more right-ward without the same terminus. + let next + while ((next = re[t.COERCERTL].exec(version)) && + (!match || match.index + match[0].length !== version.length) + ) { + if (!match || + next.index + next[0].length !== match.index + match[0].length) { + match = next + } + re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length + } + // leave it in a clean state + re[t.COERCERTL].lastIndex = -1 + } + + if (match === null) + return null + + return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options) +} +module.exports = coerce + + +/***/ }), + +/***/ 503: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const parse = __webpack_require__(830) +const clean = (version, options) => { + const s = parse(version.trim().replace(/^[=v]+/, ''), options) + return s ? s.version : null +} +module.exports = clean + + +/***/ }), + +/***/ 531: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// Determine if version is greater than all the versions possible in the range. +const outside = __webpack_require__(462) +const gtr = (version, range, options) => outside(version, range, '>', options) +module.exports = gtr + + +/***/ }), + +/***/ 533: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const core = __importStar(__webpack_require__(470)); +const io = __importStar(__webpack_require__(1)); +const fs = __importStar(__webpack_require__(747)); +const mm = __importStar(__webpack_require__(31)); +const os = __importStar(__webpack_require__(87)); +const path = __importStar(__webpack_require__(622)); +const httpm = __importStar(__webpack_require__(539)); +const semver = __importStar(__webpack_require__(550)); +const stream = __importStar(__webpack_require__(794)); +const util = __importStar(__webpack_require__(669)); +const v4_1 = __importDefault(__webpack_require__(826)); +const exec_1 = __webpack_require__(986); +const assert_1 = __webpack_require__(357); +const retry_helper_1 = __webpack_require__(979); +class HTTPError extends Error { + constructor(httpStatusCode) { + super(`Unexpected HTTP response: ${httpStatusCode}`); + this.httpStatusCode = httpStatusCode; + Object.setPrototypeOf(this, new.target.prototype); + } +} +exports.HTTPError = HTTPError; +const IS_WINDOWS = process.platform === 'win32'; +const IS_MAC = process.platform === 'darwin'; +const userAgent = 'actions/tool-cache'; +/** + * Download a tool from an url and stream it into a file + * + * @param url url of tool to download + * @param dest path to download tool + * @param auth authorization header + * @returns path to downloaded tool + */ +function downloadTool(url, dest, auth) { + return __awaiter(this, void 0, void 0, function* () { + dest = dest || path.join(_getTempDirectory(), v4_1.default()); + yield io.mkdirP(path.dirname(dest)); + core.debug(`Downloading ${url}`); + core.debug(`Destination ${dest}`); + const maxAttempts = 3; + const minSeconds = _getGlobal('TEST_DOWNLOAD_TOOL_RETRY_MIN_SECONDS', 10); + const maxSeconds = _getGlobal('TEST_DOWNLOAD_TOOL_RETRY_MAX_SECONDS', 20); + const retryHelper = new retry_helper_1.RetryHelper(maxAttempts, minSeconds, maxSeconds); + return yield retryHelper.execute(() => __awaiter(this, void 0, void 0, function* () { + return yield downloadToolAttempt(url, dest || '', auth); + }), (err) => { + if (err instanceof HTTPError && err.httpStatusCode) { + // Don't retry anything less than 500, except 408 Request Timeout and 429 Too Many Requests + if (err.httpStatusCode < 500 && + err.httpStatusCode !== 408 && + err.httpStatusCode !== 429) { + return false; + } + } + // Otherwise retry + return true; + }); + }); +} +exports.downloadTool = downloadTool; +function downloadToolAttempt(url, dest, auth) { + return __awaiter(this, void 0, void 0, function* () { + if (fs.existsSync(dest)) { + throw new Error(`Destination file path ${dest} already exists`); + } + // Get the response headers + const http = new httpm.HttpClient(userAgent, [], { + allowRetries: false + }); + let headers; + if (auth) { + core.debug('set auth'); + headers = { + authorization: auth + }; + } + const response = yield http.get(url, headers); + if (response.message.statusCode !== 200) { + const err = new HTTPError(response.message.statusCode); + core.debug(`Failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`); + throw err; + } + // Download the response body + const pipeline = util.promisify(stream.pipeline); + const responseMessageFactory = _getGlobal('TEST_DOWNLOAD_TOOL_RESPONSE_MESSAGE_FACTORY', () => response.message); + const readStream = responseMessageFactory(); + let succeeded = false; + try { + yield pipeline(readStream, fs.createWriteStream(dest)); + core.debug('download complete'); + succeeded = true; + return dest; + } + finally { + // Error, delete dest before retry + if (!succeeded) { + core.debug('download failed'); + try { + yield io.rmRF(dest); + } + catch (err) { + core.debug(`Failed to delete '${dest}'. ${err.message}`); + } + } + } + }); +} +/** + * Extract a .7z file + * + * @param file path to the .7z file + * @param dest destination directory. Optional. + * @param _7zPath path to 7zr.exe. Optional, for long path support. Most .7z archives do not have this + * problem. If your .7z archive contains very long paths, you can pass the path to 7zr.exe which will + * gracefully handle long paths. By default 7zdec.exe is used because it is a very small program and is + * bundled with the tool lib. However it does not support long paths. 7zr.exe is the reduced command line + * interface, it is smaller than the full command line interface, and it does support long paths. At the + * time of this writing, it is freely available from the LZMA SDK that is available on the 7zip website. + * Be sure to check the current license agreement. If 7zr.exe is bundled with your action, then the path + * to 7zr.exe can be pass to this function. + * @returns path to the destination directory + */ +function extract7z(file, dest, _7zPath) { + return __awaiter(this, void 0, void 0, function* () { + assert_1.ok(IS_WINDOWS, 'extract7z() not supported on current OS'); + assert_1.ok(file, 'parameter "file" is required'); + dest = yield _createExtractFolder(dest); + const originalCwd = process.cwd(); + process.chdir(dest); + if (_7zPath) { + try { + const logLevel = core.isDebug() ? '-bb1' : '-bb0'; + const args = [ + 'x', + logLevel, + '-bd', + '-sccUTF-8', + file + ]; + const options = { + silent: true + }; + yield exec_1.exec(`"${_7zPath}"`, args, options); + } + finally { + process.chdir(originalCwd); + } + } + else { + const escapedScript = path + .join(__dirname, '..', 'scripts', 'Invoke-7zdec.ps1') + .replace(/'/g, "''") + .replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines + const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, ''); + const escapedTarget = dest.replace(/'/g, "''").replace(/"|\n|\r/g, ''); + const command = `& '${escapedScript}' -Source '${escapedFile}' -Target '${escapedTarget}'`; + const args = [ + '-NoLogo', + '-Sta', + '-NoProfile', + '-NonInteractive', + '-ExecutionPolicy', + 'Unrestricted', + '-Command', + command + ]; + const options = { + silent: true + }; + try { + const powershellPath = yield io.which('powershell', true); + yield exec_1.exec(`"${powershellPath}"`, args, options); + } + finally { + process.chdir(originalCwd); + } + } + return dest; + }); +} +exports.extract7z = extract7z; +/** + * Extract a compressed tar archive + * + * @param file path to the tar + * @param dest destination directory. Optional. + * @param flags flags for the tar command to use for extraction. Defaults to 'xz' (extracting gzipped tars). Optional. + * @returns path to the destination directory + */ +function extractTar(file, dest, flags = 'xz') { + return __awaiter(this, void 0, void 0, function* () { + if (!file) { + throw new Error("parameter 'file' is required"); + } + // Create dest + dest = yield _createExtractFolder(dest); + // Determine whether GNU tar + core.debug('Checking tar --version'); + let versionOutput = ''; + yield exec_1.exec('tar --version', [], { + ignoreReturnCode: true, + silent: true, + listeners: { + stdout: (data) => (versionOutput += data.toString()), + stderr: (data) => (versionOutput += data.toString()) + } + }); + core.debug(versionOutput.trim()); + const isGnuTar = versionOutput.toUpperCase().includes('GNU TAR'); + // Initialize args + let args; + if (flags instanceof Array) { + args = flags; + } + else { + args = [flags]; + } + if (core.isDebug() && !flags.includes('v')) { + args.push('-v'); + } + let destArg = dest; + let fileArg = file; + if (IS_WINDOWS && isGnuTar) { + args.push('--force-local'); + destArg = dest.replace(/\\/g, '/'); + // Technically only the dest needs to have `/` but for aesthetic consistency + // convert slashes in the file arg too. + fileArg = file.replace(/\\/g, '/'); + } + if (isGnuTar) { + // Suppress warnings when using GNU tar to extract archives created by BSD tar + args.push('--warning=no-unknown-keyword'); + } + args.push('-C', destArg, '-f', fileArg); + yield exec_1.exec(`tar`, args); + return dest; + }); +} +exports.extractTar = extractTar; +/** + * Extract a xar compatible archive + * + * @param file path to the archive + * @param dest destination directory. Optional. + * @param flags flags for the xar. Optional. + * @returns path to the destination directory + */ +function extractXar(file, dest, flags = []) { + return __awaiter(this, void 0, void 0, function* () { + assert_1.ok(IS_MAC, 'extractXar() not supported on current OS'); + assert_1.ok(file, 'parameter "file" is required'); + dest = yield _createExtractFolder(dest); + let args; + if (flags instanceof Array) { + args = flags; + } + else { + args = [flags]; + } + args.push('-x', '-C', dest, '-f', file); + if (core.isDebug()) { + args.push('-v'); + } + const xarPath = yield io.which('xar', true); + yield exec_1.exec(`"${xarPath}"`, _unique(args)); + return dest; + }); +} +exports.extractXar = extractXar; +/** + * Extract a zip + * + * @param file path to the zip + * @param dest destination directory. Optional. + * @returns path to the destination directory + */ +function extractZip(file, dest) { + return __awaiter(this, void 0, void 0, function* () { + if (!file) { + throw new Error("parameter 'file' is required"); + } + dest = yield _createExtractFolder(dest); + if (IS_WINDOWS) { + yield extractZipWin(file, dest); + } + else { + yield extractZipNix(file, dest); + } + return dest; + }); +} +exports.extractZip = extractZip; +function extractZipWin(file, dest) { + return __awaiter(this, void 0, void 0, function* () { + // build the powershell command + const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines + const escapedDest = dest.replace(/'/g, "''").replace(/"|\n|\r/g, ''); + const command = `$ErrorActionPreference = 'Stop' ; try { Add-Type -AssemblyName System.IO.Compression.FileSystem } catch { } ; [System.IO.Compression.ZipFile]::ExtractToDirectory('${escapedFile}', '${escapedDest}')`; + // run powershell + const powershellPath = yield io.which('powershell', true); + const args = [ + '-NoLogo', + '-Sta', + '-NoProfile', + '-NonInteractive', + '-ExecutionPolicy', + 'Unrestricted', + '-Command', + command + ]; + yield exec_1.exec(`"${powershellPath}"`, args); + }); +} +function extractZipNix(file, dest) { + return __awaiter(this, void 0, void 0, function* () { + const unzipPath = yield io.which('unzip', true); + const args = [file]; + if (!core.isDebug()) { + args.unshift('-q'); + } + yield exec_1.exec(`"${unzipPath}"`, args, { cwd: dest }); + }); +} +/** + * Caches a directory and installs it into the tool cacheDir + * + * @param sourceDir the directory to cache into tools + * @param tool tool name + * @param version version of the tool. semver format + * @param arch architecture of the tool. Optional. Defaults to machine architecture + */ +function cacheDir(sourceDir, tool, version, arch) { + return __awaiter(this, void 0, void 0, function* () { + version = semver.clean(version) || version; + arch = arch || os.arch(); + core.debug(`Caching tool ${tool} ${version} ${arch}`); + core.debug(`source dir: ${sourceDir}`); + if (!fs.statSync(sourceDir).isDirectory()) { + throw new Error('sourceDir is not a directory'); + } + // Create the tool dir + const destPath = yield _createToolPath(tool, version, arch); + // copy each child item. do not move. move can fail on Windows + // due to anti-virus software having an open handle on a file. + for (const itemName of fs.readdirSync(sourceDir)) { + const s = path.join(sourceDir, itemName); + yield io.cp(s, destPath, { recursive: true }); + } + // write .complete + _completeToolPath(tool, version, arch); + return destPath; + }); +} +exports.cacheDir = cacheDir; +/** + * Caches a downloaded file (GUID) and installs it + * into the tool cache with a given targetName + * + * @param sourceFile the file to cache into tools. Typically a result of downloadTool which is a guid. + * @param targetFile the name of the file name in the tools directory + * @param tool tool name + * @param version version of the tool. semver format + * @param arch architecture of the tool. Optional. Defaults to machine architecture + */ +function cacheFile(sourceFile, targetFile, tool, version, arch) { + return __awaiter(this, void 0, void 0, function* () { + version = semver.clean(version) || version; + arch = arch || os.arch(); + core.debug(`Caching tool ${tool} ${version} ${arch}`); + core.debug(`source file: ${sourceFile}`); + if (!fs.statSync(sourceFile).isFile()) { + throw new Error('sourceFile is not a file'); + } + // create the tool dir + const destFolder = yield _createToolPath(tool, version, arch); + // copy instead of move. move can fail on Windows due to + // anti-virus software having an open handle on a file. + const destPath = path.join(destFolder, targetFile); + core.debug(`destination file ${destPath}`); + yield io.cp(sourceFile, destPath); + // write .complete + _completeToolPath(tool, version, arch); + return destFolder; + }); +} +exports.cacheFile = cacheFile; +/** + * Finds the path to a tool version in the local installed tool cache + * + * @param toolName name of the tool + * @param versionSpec version of the tool + * @param arch optional arch. defaults to arch of computer + */ +function find(toolName, versionSpec, arch) { + if (!toolName) { + throw new Error('toolName parameter is required'); + } + if (!versionSpec) { + throw new Error('versionSpec parameter is required'); + } + arch = arch || os.arch(); + // attempt to resolve an explicit version + if (!_isExplicitVersion(versionSpec)) { + const localVersions = findAllVersions(toolName, arch); + const match = _evaluateVersions(localVersions, versionSpec); + versionSpec = match; + } + // check for the explicit version in the cache + let toolPath = ''; + if (versionSpec) { + versionSpec = semver.clean(versionSpec) || ''; + const cachePath = path.join(_getCacheDirectory(), toolName, versionSpec, arch); + core.debug(`checking cache: ${cachePath}`); + if (fs.existsSync(cachePath) && fs.existsSync(`${cachePath}.complete`)) { + core.debug(`Found tool in cache ${toolName} ${versionSpec} ${arch}`); + toolPath = cachePath; + } + else { + core.debug('not found'); + } + } + return toolPath; +} +exports.find = find; +/** + * Finds the paths to all versions of a tool that are installed in the local tool cache + * + * @param toolName name of the tool + * @param arch optional arch. defaults to arch of computer + */ +function findAllVersions(toolName, arch) { + const versions = []; + arch = arch || os.arch(); + const toolPath = path.join(_getCacheDirectory(), toolName); + if (fs.existsSync(toolPath)) { + const children = fs.readdirSync(toolPath); + for (const child of children) { + if (_isExplicitVersion(child)) { + const fullPath = path.join(toolPath, child, arch || ''); + if (fs.existsSync(fullPath) && fs.existsSync(`${fullPath}.complete`)) { + versions.push(child); + } + } + } + } + return versions; +} +exports.findAllVersions = findAllVersions; +function getManifestFromRepo(owner, repo, auth, branch = 'master') { + return __awaiter(this, void 0, void 0, function* () { + let releases = []; + const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}`; + const http = new httpm.HttpClient('tool-cache'); + const headers = {}; + if (auth) { + core.debug('set auth'); + headers.authorization = auth; + } + const response = yield http.getJson(treeUrl, headers); + if (!response.result) { + return releases; + } + let manifestUrl = ''; + for (const item of response.result.tree) { + if (item.path === 'versions-manifest.json') { + manifestUrl = item.url; + break; + } + } + headers['accept'] = 'application/vnd.github.VERSION.raw'; + let versionsRaw = yield (yield http.get(manifestUrl, headers)).readBody(); + if (versionsRaw) { + // shouldn't be needed but protects against invalid json saved with BOM + versionsRaw = versionsRaw.replace(/^\uFEFF/, ''); + try { + releases = JSON.parse(versionsRaw); + } + catch (_a) { + core.debug('Invalid json'); + } + } + return releases; + }); +} +exports.getManifestFromRepo = getManifestFromRepo; +function findFromManifest(versionSpec, stable, manifest, archFilter = os.arch()) { + return __awaiter(this, void 0, void 0, function* () { + // wrap the internal impl + const match = yield mm._findMatch(versionSpec, stable, manifest, archFilter); + return match; + }); +} +exports.findFromManifest = findFromManifest; +function _createExtractFolder(dest) { + return __awaiter(this, void 0, void 0, function* () { + if (!dest) { + // create a temp dir + dest = path.join(_getTempDirectory(), v4_1.default()); + } + yield io.mkdirP(dest); + return dest; + }); +} +function _createToolPath(tool, version, arch) { + return __awaiter(this, void 0, void 0, function* () { + const folderPath = path.join(_getCacheDirectory(), tool, semver.clean(version) || version, arch || ''); + core.debug(`destination ${folderPath}`); + const markerPath = `${folderPath}.complete`; + yield io.rmRF(folderPath); + yield io.rmRF(markerPath); + yield io.mkdirP(folderPath); + return folderPath; + }); +} +function _completeToolPath(tool, version, arch) { + const folderPath = path.join(_getCacheDirectory(), tool, semver.clean(version) || version, arch || ''); + const markerPath = `${folderPath}.complete`; + fs.writeFileSync(markerPath, ''); + core.debug('finished caching tool'); +} +function _isExplicitVersion(versionSpec) { + const c = semver.clean(versionSpec) || ''; + core.debug(`isExplicit: ${c}`); + const valid = semver.valid(c) != null; + core.debug(`explicit? ${valid}`); + return valid; +} +function _evaluateVersions(versions, versionSpec) { + let version = ''; + core.debug(`evaluating ${versions.length} versions`); + versions = versions.sort((a, b) => { + if (semver.gt(a, b)) { + return 1; + } + return -1; + }); + for (let i = versions.length - 1; i >= 0; i--) { + const potential = versions[i]; + const satisfied = semver.satisfies(potential, versionSpec); + if (satisfied) { + version = potential; + break; + } + } + if (version) { + core.debug(`matched: ${version}`); + } + else { + core.debug('match not found'); + } + return version; +} +/** + * Gets RUNNER_TOOL_CACHE + */ +function _getCacheDirectory() { + const cacheDirectory = process.env['RUNNER_TOOL_CACHE'] || ''; + assert_1.ok(cacheDirectory, 'Expected RUNNER_TOOL_CACHE to be defined'); + return cacheDirectory; +} +/** + * Gets RUNNER_TEMP + */ +function _getTempDirectory() { + const tempDirectory = process.env['RUNNER_TEMP'] || ''; + assert_1.ok(tempDirectory, 'Expected RUNNER_TEMP to be defined'); + return tempDirectory; +} +/** + * Gets a global variable + */ +function _getGlobal(key, defaultValue) { + /* eslint-disable @typescript-eslint/no-explicit-any */ + const value = global[key]; + /* eslint-enable @typescript-eslint/no-explicit-any */ + return value !== undefined ? value : defaultValue; +} +/** + * Returns an array of unique values. + * @param values Values to make unique. + */ +function _unique(values) { + return Array.from(new Set(values)); +} +//# sourceMappingURL=tool-cache.js.map + +/***/ }), + +/***/ 539: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +const http = __webpack_require__(605); +const https = __webpack_require__(211); +const pm = __webpack_require__(950); +let tunnel; +var HttpCodes; +(function (HttpCodes) { + HttpCodes[HttpCodes["OK"] = 200] = "OK"; + HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; + HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; + HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; + HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; + HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; + HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; + HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; + HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; + HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; + HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; +})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); +var Headers; +(function (Headers) { + Headers["Accept"] = "accept"; + Headers["ContentType"] = "content-type"; +})(Headers = exports.Headers || (exports.Headers = {})); +var MediaTypes; +(function (MediaTypes) { + MediaTypes["ApplicationJson"] = "application/json"; +})(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {})); +/** + * Returns the proxy URL, depending upon the supplied url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ +function getProxyUrl(serverUrl) { + let proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ''; +} +exports.getProxyUrl = getProxyUrl; +const HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect +]; +const HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout +]; +const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; +const ExponentialBackoffCeiling = 10; +const ExponentialBackoffTimeSlice = 5; +class HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = 'HttpClientError'; + this.statusCode = statusCode; + Object.setPrototypeOf(this, HttpClientError.prototype); + } +} +exports.HttpClientError = HttpClientError; +class HttpClientResponse { + constructor(message) { + this.message = message; + } + readBody() { + return new Promise(async (resolve, reject) => { + let output = Buffer.alloc(0); + this.message.on('data', (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on('end', () => { + resolve(output.toString()); + }); + }); + } +} +exports.HttpClientResponse = HttpClientResponse; +function isHttps(requestUrl) { + let parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === 'https:'; +} +exports.isHttps = isHttps; +class HttpClient { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + } + get(requestUrl, additionalHeaders) { + return this.request('GET', requestUrl, null, additionalHeaders || {}); + } + del(requestUrl, additionalHeaders) { + return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + } + post(requestUrl, data, additionalHeaders) { + return this.request('POST', requestUrl, data, additionalHeaders || {}); + } + patch(requestUrl, data, additionalHeaders) { + return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + } + put(requestUrl, data, additionalHeaders) { + return this.request('PUT', requestUrl, data, additionalHeaders || {}); + } + head(requestUrl, additionalHeaders) { + return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return this.request(verb, requestUrl, stream, additionalHeaders); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + async getJson(requestUrl, additionalHeaders = {}) { + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + let res = await this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async postJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async putJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async patchJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + async request(verb, requestUrl, data, headers) { + if (this._disposed) { + throw new Error('Client has already been disposed.'); + } + let parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + // Only perform retries on reads since writes may not be idempotent. + let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1 + ? this._maxRetries + 1 + : 1; + let numTries = 0; + let response; + while (numTries < maxTries) { + response = await this.requestRaw(info, data); + // Check if it's an authentication challenge + if (response && + response.message && + response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (let i = 0; i < this.handlers.length; i++) { + if (this.handlers[i].canHandleAuthentication(response)) { + authenticationHandler = this.handlers[i]; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } + else { + // We have received an unauthorized response but have no handlers to handle it. + // Let the response return to the caller. + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 && + this._allowRedirects && + redirectsRemaining > 0) { + const redirectUrl = response.message.headers['location']; + if (!redirectUrl) { + // if there's no location to redirect to, we won't + break; + } + let parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol == 'https:' && + parsedUrl.protocol != parsedRedirectUrl.protocol && + !this._allowRedirectDowngrade) { + throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); + } + // we need to finish reading the response before reassigning response + // which will leak the open socket. + await response.readBody(); + // strip authorization header if redirected to a different hostname + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (let header in headers) { + // header names are case insensitive + if (header.toLowerCase() === 'authorization') { + delete headers[header]; + } + } + } + // let's make the request with the new redirectUrl + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = await this.requestRaw(info, data); + redirectsRemaining--; + } + if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) { + // If not a retry code, return immediately instead of retrying + return response; + } + numTries += 1; + if (numTries < maxTries) { + await response.readBody(); + await this._performExponentialBackoff(numTries); + } + } + return response; + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return new Promise((resolve, reject) => { + let callbackForResult = function (err, res) { + if (err) { + reject(err); + } + resolve(res); + }; + this.requestRawWithCallback(info, data, callbackForResult); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + let socket; + if (typeof data === 'string') { + info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); + } + let callbackCalled = false; + let handleResult = (err, res) => { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + }; + let req = info.httpModule.request(info.options, (msg) => { + let res = new HttpClientResponse(msg); + handleResult(null, res); + }); + req.on('socket', sock => { + socket = sock; + }); + // If we ever get disconnected, we want the socket to timeout eventually + req.setTimeout(this._socketTimeout || 3 * 60000, () => { + if (socket) { + socket.end(); + } + handleResult(new Error('Request timeout: ' + info.options.path), null); + }); + req.on('error', function (err) { + // err has statusCode property + // res should have headers + handleResult(err, null); + }); + if (data && typeof data === 'string') { + req.write(data, 'utf8'); + } + if (data && typeof data !== 'string') { + data.on('close', function () { + req.end(); + }); + data.pipe(req); + } + else { + req.end(); + } + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + let parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + _prepareRequest(method, requestUrl, headers) { + const info = {}; + info.parsedUrl = requestUrl; + const usingSsl = info.parsedUrl.protocol === 'https:'; + info.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info.options = {}; + info.options.host = info.parsedUrl.hostname; + info.options.port = info.parsedUrl.port + ? parseInt(info.parsedUrl.port) + : defaultPort; + info.options.path = + (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); + info.options.method = method; + info.options.headers = this._mergeHeaders(headers); + if (this.userAgent != null) { + info.options.headers['user-agent'] = this.userAgent; + } + info.options.agent = this._getAgent(info.parsedUrl); + // gives handlers an opportunity to participate + if (this.handlers) { + this.handlers.forEach(handler => { + handler.prepareRequest(info.options); + }); + } + return info; + } + _mergeHeaders(headers) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers)); + } + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + let proxyUrl = pm.getProxyUrl(parsedUrl); + let useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (this._keepAlive && !useProxy) { + agent = this._agent; + } + // if agent is already assigned use that agent. + if (!!agent) { + return agent; + } + const usingSsl = parsedUrl.protocol === 'https:'; + let maxSockets = 100; + if (!!this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + if (useProxy) { + // If using proxy, need tunnel + if (!tunnel) { + tunnel = __webpack_require__(413); + } + const agentOptions = { + maxSockets: maxSockets, + keepAlive: this._keepAlive, + proxy: { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`, + host: proxyUrl.hostname, + port: proxyUrl.port + } + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === 'https:'; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } + else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + // if reusing agent across request and tunneling agent isn't assigned create a new agent + if (this._keepAlive && !agent) { + const options = { keepAlive: this._keepAlive, maxSockets: maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + // if not using private agent and tunnel agent isn't setup then use global agent + if (!agent) { + agent = usingSsl ? https.globalAgent : http.globalAgent; + } + if (usingSsl && this._ignoreSslError) { + // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process + // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options + // we have to cast it to any and change it directly + agent.options = Object.assign(agent.options || {}, { + rejectUnauthorized: false + }); + } + return agent; + } + _performExponentialBackoff(retryNumber) { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise(resolve => setTimeout(() => resolve(), ms)); + } + static dateTimeDeserializer(key, value) { + if (typeof value === 'string') { + let a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + async _processResponse(res, options) { + return new Promise(async (resolve, reject) => { + const statusCode = res.message.statusCode; + const response = { + statusCode: statusCode, + result: null, + headers: {} + }; + // not found leads to null obj returned + if (statusCode == HttpCodes.NotFound) { + resolve(response); + } + let obj; + let contents; + // get the result from the body + try { + contents = await res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, HttpClient.dateTimeDeserializer); + } + else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } + catch (err) { + // Invalid resource (contents not json); leaving result obj null + } + // note that 3xx redirects are handled by the http layer. + if (statusCode > 299) { + let msg; + // if exception/error in body, attempt to get better error + if (obj && obj.message) { + msg = obj.message; + } + else if (contents && contents.length > 0) { + // it may be the case that the exception is in the body message as string + msg = contents; + } + else { + msg = 'Failed request: (' + statusCode + ')'; + } + let err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } + else { + resolve(response); + } + }); + } +} +exports.HttpClient = HttpClient; + + +/***/ }), + +/***/ 548: +/***/ (function(module) { + +const debug = ( + typeof process === 'object' && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG) +) ? (...args) => console.error('SEMVER', ...args) + : () => {} + +module.exports = debug + + +/***/ }), + +/***/ 550: +/***/ (function(module, exports) { + +exports = module.exports = SemVer + +var debug +/* istanbul ignore next */ +if (typeof process === 'object' && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG)) { + debug = function () { + var args = Array.prototype.slice.call(arguments, 0) + args.unshift('SEMVER') + console.log.apply(console, args) + } +} else { + debug = function () {} +} + +// Note: this is the semver.org version of the spec that it implements +// Not necessarily the package version of this code. +exports.SEMVER_SPEC_VERSION = '2.0.0' + +var MAX_LENGTH = 256 +var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || + /* istanbul ignore next */ 9007199254740991 + +// Max safe segment length for coercion. +var MAX_SAFE_COMPONENT_LENGTH = 16 + +// The actual regexps go on exports.re +var re = exports.re = [] +var src = exports.src = [] +var t = exports.tokens = {} +var R = 0 + +function tok (n) { + t[n] = R++ +} + +// The following Regular Expressions can be used for tokenizing, +// validating, and parsing SemVer version strings. + +// ## Numeric Identifier +// A single `0`, or a non-zero digit followed by zero or more digits. + +tok('NUMERICIDENTIFIER') +src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*' +tok('NUMERICIDENTIFIERLOOSE') +src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+' + +// ## Non-numeric Identifier +// Zero or more digits, followed by a letter or hyphen, and then zero or +// more letters, digits, or hyphens. + +tok('NONNUMERICIDENTIFIER') +src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*' + +// ## Main Version +// Three dot-separated numeric identifiers. + +tok('MAINVERSION') +src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIER] + ')' + +tok('MAINVERSIONLOOSE') +src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')' + +// ## Pre-release Version Identifier +// A numeric identifier, or a non-numeric identifier. + +tok('PRERELEASEIDENTIFIER') +src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + + '|' + src[t.NONNUMERICIDENTIFIER] + ')' + +tok('PRERELEASEIDENTIFIERLOOSE') +src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + + '|' + src[t.NONNUMERICIDENTIFIER] + ')' + +// ## Pre-release Version +// Hyphen, followed by one or more dot-separated pre-release version +// identifiers. + +tok('PRERELEASE') +src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))' + +tok('PRERELEASELOOSE') +src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))' + +// ## Build Metadata Identifier +// Any combination of digits, letters, or hyphens. + +tok('BUILDIDENTIFIER') +src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+' + +// ## Build Metadata +// Plus sign, followed by one or more period-separated build metadata +// identifiers. + +tok('BUILD') +src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + + '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))' + +// ## Full Version String +// A main version, followed optionally by a pre-release version and +// build metadata. + +// Note that the only major, minor, patch, and pre-release sections of +// the version string are capturing groups. The build metadata is not a +// capturing group, because it should not ever be used in version +// comparison. + +tok('FULL') +tok('FULLPLAIN') +src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + + src[t.PRERELEASE] + '?' + + src[t.BUILD] + '?' + +src[t.FULL] = '^' + src[t.FULLPLAIN] + '$' + +// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. +// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty +// common in the npm registry. +tok('LOOSEPLAIN') +src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + + src[t.PRERELEASELOOSE] + '?' + + src[t.BUILD] + '?' + +tok('LOOSE') +src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$' + +tok('GTLT') +src[t.GTLT] = '((?:<|>)?=?)' + +// Something like "2.*" or "1.2.x". +// Note that "x.x" is a valid xRange identifer, meaning "any version" +// Only the first item is strictly required. +tok('XRANGEIDENTIFIERLOOSE') +src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*' +tok('XRANGEIDENTIFIER') +src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*' + +tok('XRANGEPLAIN') +src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:' + src[t.PRERELEASE] + ')?' + + src[t.BUILD] + '?' + + ')?)?' + +tok('XRANGEPLAINLOOSE') +src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:' + src[t.PRERELEASELOOSE] + ')?' + + src[t.BUILD] + '?' + + ')?)?' + +tok('XRANGE') +src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$' +tok('XRANGELOOSE') +src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$' + +// Coercion. +// Extract anything that could conceivably be a part of a valid semver +tok('COERCE') +src[t.COERCE] = '(^|[^\\d])' + + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:$|[^\\d])' +tok('COERCERTL') +re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g') + +// Tilde ranges. +// Meaning is "reasonably at or greater than" +tok('LONETILDE') +src[t.LONETILDE] = '(?:~>?)' + +tok('TILDETRIM') +src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+' +re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g') +var tildeTrimReplace = '$1~' + +tok('TILDE') +src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$' +tok('TILDELOOSE') +src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$' + +// Caret ranges. +// Meaning is "at least and backwards compatible with" +tok('LONECARET') +src[t.LONECARET] = '(?:\\^)' + +tok('CARETTRIM') +src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+' +re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g') +var caretTrimReplace = '$1^' + +tok('CARET') +src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$' +tok('CARETLOOSE') +src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$' + +// A simple gt/lt/eq thing, or just "" to indicate "any version" +tok('COMPARATORLOOSE') +src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$' +tok('COMPARATOR') +src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$' + +// An expression to strip any whitespace between the gtlt and the thing +// it modifies, so that `> 1.2.3` ==> `>1.2.3` +tok('COMPARATORTRIM') +src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')' + +// this one has to use the /g flag +re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g') +var comparatorTrimReplace = '$1$2$3' + +// Something like `1.2.3 - 1.2.4` +// Note that these all use the loose form, because they'll be +// checked against either the strict or loose comparator form +// later. +tok('HYPHENRANGE') +src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + + '\\s+-\\s+' + + '(' + src[t.XRANGEPLAIN] + ')' + + '\\s*$' + +tok('HYPHENRANGELOOSE') +src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + + '\\s+-\\s+' + + '(' + src[t.XRANGEPLAINLOOSE] + ')' + + '\\s*$' + +// Star ranges basically just allow anything at all. +tok('STAR') +src[t.STAR] = '(<|>)?=?\\s*\\*' + +// Compile to actual regexp objects. +// All are flag-free, unless they were created above with a flag. +for (var i = 0; i < R; i++) { + debug(i, src[i]) + if (!re[i]) { + re[i] = new RegExp(src[i]) + } +} + +exports.parse = parse +function parse (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (version instanceof SemVer) { + return version + } + + if (typeof version !== 'string') { + return null + } + + if (version.length > MAX_LENGTH) { + return null + } + + var r = options.loose ? re[t.LOOSE] : re[t.FULL] + if (!r.test(version)) { + return null + } + + try { + return new SemVer(version, options) + } catch (er) { + return null + } +} + +exports.valid = valid +function valid (version, options) { + var v = parse(version, options) + return v ? v.version : null +} + +exports.clean = clean +function clean (version, options) { + var s = parse(version.trim().replace(/^[=v]+/, ''), options) + return s ? s.version : null +} + +exports.SemVer = SemVer + +function SemVer (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + if (version instanceof SemVer) { + if (version.loose === options.loose) { + return version + } else { + version = version.version + } + } else if (typeof version !== 'string') { + throw new TypeError('Invalid Version: ' + version) + } + + if (version.length > MAX_LENGTH) { + throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters') + } + + if (!(this instanceof SemVer)) { + return new SemVer(version, options) + } + + debug('SemVer', version, options) + this.options = options + this.loose = !!options.loose + + var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]) + + if (!m) { + throw new TypeError('Invalid Version: ' + version) + } + + this.raw = version + + // these are actually numbers + this.major = +m[1] + this.minor = +m[2] + this.patch = +m[3] + + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError('Invalid major version') + } + + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError('Invalid minor version') + } + + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError('Invalid patch version') + } + + // numberify any prerelease numeric ids + if (!m[4]) { + this.prerelease = [] + } else { + this.prerelease = m[4].split('.').map(function (id) { + if (/^[0-9]+$/.test(id)) { + var num = +id + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id + }) + } + + this.build = m[5] ? m[5].split('.') : [] + this.format() +} + +SemVer.prototype.format = function () { + this.version = this.major + '.' + this.minor + '.' + this.patch + if (this.prerelease.length) { + this.version += '-' + this.prerelease.join('.') + } + return this.version +} + +SemVer.prototype.toString = function () { + return this.version +} + +SemVer.prototype.compare = function (other) { + debug('SemVer.compare', this.version, this.options, other) + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return this.compareMain(other) || this.comparePre(other) +} + +SemVer.prototype.compareMain = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) +} + +SemVer.prototype.comparePre = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + // NOT having a prerelease is > having one + if (this.prerelease.length && !other.prerelease.length) { + return -1 + } else if (!this.prerelease.length && other.prerelease.length) { + return 1 + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0 + } + + var i = 0 + do { + var a = this.prerelease[i] + var b = other.prerelease[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +SemVer.prototype.compareBuild = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + var i = 0 + do { + var a = this.build[i] + var b = other.build[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +// preminor will bump the version up to the next minor release, and immediately +// down to pre-release. premajor and prepatch work the same way. +SemVer.prototype.inc = function (release, identifier) { + switch (release) { + case 'premajor': + this.prerelease.length = 0 + this.patch = 0 + this.minor = 0 + this.major++ + this.inc('pre', identifier) + break + case 'preminor': + this.prerelease.length = 0 + this.patch = 0 + this.minor++ + this.inc('pre', identifier) + break + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0 + this.inc('patch', identifier) + this.inc('pre', identifier) + break + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if (this.prerelease.length === 0) { + this.inc('patch', identifier) + } + this.inc('pre', identifier) + break + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + if (this.minor !== 0 || + this.patch !== 0 || + this.prerelease.length === 0) { + this.major++ + } + this.minor = 0 + this.patch = 0 + this.prerelease = [] + break + case 'minor': + // If this is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++ + } + this.patch = 0 + this.prerelease = [] + break + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if (this.prerelease.length === 0) { + this.patch++ + } + this.prerelease = [] + break + // This probably shouldn't be used publicly. + // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. + case 'pre': + if (this.prerelease.length === 0) { + this.prerelease = [0] + } else { + var i = this.prerelease.length + while (--i >= 0) { + if (typeof this.prerelease[i] === 'number') { + this.prerelease[i]++ + i = -2 + } + } + if (i === -1) { + // didn't increment anything + this.prerelease.push(0) + } + } + if (identifier) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + if (this.prerelease[0] === identifier) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0] + } + } else { + this.prerelease = [identifier, 0] + } + } + break + + default: + throw new Error('invalid increment argument: ' + release) + } + this.format() + this.raw = this.version + return this +} + +exports.inc = inc +function inc (version, release, loose, identifier) { + if (typeof (loose) === 'string') { + identifier = loose + loose = undefined + } + + try { + return new SemVer(version, loose).inc(release, identifier).version + } catch (er) { + return null + } +} + +exports.diff = diff +function diff (version1, version2) { + if (eq(version1, version2)) { + return null + } else { + var v1 = parse(version1) + var v2 = parse(version2) + var prefix = '' + if (v1.prerelease.length || v2.prerelease.length) { + prefix = 'pre' + var defaultResult = 'prerelease' + } + for (var key in v1) { + if (key === 'major' || key === 'minor' || key === 'patch') { + if (v1[key] !== v2[key]) { + return prefix + key + } + } + } + return defaultResult // may be undefined + } +} + +exports.compareIdentifiers = compareIdentifiers + +var numeric = /^[0-9]+$/ +function compareIdentifiers (a, b) { + var anum = numeric.test(a) + var bnum = numeric.test(b) + + if (anum && bnum) { + a = +a + b = +b + } + + return a === b ? 0 + : (anum && !bnum) ? -1 + : (bnum && !anum) ? 1 + : a < b ? -1 + : 1 +} + +exports.rcompareIdentifiers = rcompareIdentifiers +function rcompareIdentifiers (a, b) { + return compareIdentifiers(b, a) +} + +exports.major = major +function major (a, loose) { + return new SemVer(a, loose).major +} + +exports.minor = minor +function minor (a, loose) { + return new SemVer(a, loose).minor +} + +exports.patch = patch +function patch (a, loose) { + return new SemVer(a, loose).patch +} + +exports.compare = compare +function compare (a, b, loose) { + return new SemVer(a, loose).compare(new SemVer(b, loose)) +} + +exports.compareLoose = compareLoose +function compareLoose (a, b) { + return compare(a, b, true) +} + +exports.compareBuild = compareBuild +function compareBuild (a, b, loose) { + var versionA = new SemVer(a, loose) + var versionB = new SemVer(b, loose) + return versionA.compare(versionB) || versionA.compareBuild(versionB) +} + +exports.rcompare = rcompare +function rcompare (a, b, loose) { + return compare(b, a, loose) +} + +exports.sort = sort +function sort (list, loose) { + return list.sort(function (a, b) { + return exports.compareBuild(a, b, loose) + }) +} + +exports.rsort = rsort +function rsort (list, loose) { + return list.sort(function (a, b) { + return exports.compareBuild(b, a, loose) + }) +} + +exports.gt = gt +function gt (a, b, loose) { + return compare(a, b, loose) > 0 +} + +exports.lt = lt +function lt (a, b, loose) { + return compare(a, b, loose) < 0 +} + +exports.eq = eq +function eq (a, b, loose) { + return compare(a, b, loose) === 0 +} + +exports.neq = neq +function neq (a, b, loose) { + return compare(a, b, loose) !== 0 +} + +exports.gte = gte +function gte (a, b, loose) { + return compare(a, b, loose) >= 0 +} + +exports.lte = lte +function lte (a, b, loose) { + return compare(a, b, loose) <= 0 +} + +exports.cmp = cmp +function cmp (a, op, b, loose) { + switch (op) { + case '===': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a === b + + case '!==': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a !== b + + case '': + case '=': + case '==': + return eq(a, b, loose) + + case '!=': + return neq(a, b, loose) + + case '>': + return gt(a, b, loose) + + case '>=': + return gte(a, b, loose) + + case '<': + return lt(a, b, loose) + + case '<=': + return lte(a, b, loose) + + default: + throw new TypeError('Invalid operator: ' + op) + } +} + +exports.Comparator = Comparator +function Comparator (comp, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp + } else { + comp = comp.value + } + } + + if (!(this instanceof Comparator)) { + return new Comparator(comp, options) + } + + debug('comparator', comp, options) + this.options = options + this.loose = !!options.loose + this.parse(comp) + + if (this.semver === ANY) { + this.value = '' + } else { + this.value = this.operator + this.semver.version + } + + debug('comp', this) +} + +var ANY = {} +Comparator.prototype.parse = function (comp) { + var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] + var m = comp.match(r) + + if (!m) { + throw new TypeError('Invalid comparator: ' + comp) + } + + this.operator = m[1] !== undefined ? m[1] : '' + if (this.operator === '=') { + this.operator = '' + } + + // if it literally is just '>' or '' then allow anything. + if (!m[2]) { + this.semver = ANY + } else { + this.semver = new SemVer(m[2], this.options.loose) + } +} + +Comparator.prototype.toString = function () { + return this.value +} + +Comparator.prototype.test = function (version) { + debug('Comparator.test', version, this.options.loose) + + if (this.semver === ANY || version === ANY) { + return true + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + return cmp(version, this.operator, this.semver, this.options) +} + +Comparator.prototype.intersects = function (comp, options) { + if (!(comp instanceof Comparator)) { + throw new TypeError('a Comparator is required') + } + + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + var rangeTmp + + if (this.operator === '') { + if (this.value === '') { + return true + } + rangeTmp = new Range(comp.value, options) + return satisfies(this.value, rangeTmp, options) + } else if (comp.operator === '') { + if (comp.value === '') { + return true + } + rangeTmp = new Range(this.value, options) + return satisfies(comp.semver, rangeTmp, options) + } + + var sameDirectionIncreasing = + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '>=' || comp.operator === '>') + var sameDirectionDecreasing = + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '<=' || comp.operator === '<') + var sameSemVer = this.semver.version === comp.semver.version + var differentDirectionsInclusive = + (this.operator === '>=' || this.operator === '<=') && + (comp.operator === '>=' || comp.operator === '<=') + var oppositeDirectionsLessThan = + cmp(this.semver, '<', comp.semver, options) && + ((this.operator === '>=' || this.operator === '>') && + (comp.operator === '<=' || comp.operator === '<')) + var oppositeDirectionsGreaterThan = + cmp(this.semver, '>', comp.semver, options) && + ((this.operator === '<=' || this.operator === '<') && + (comp.operator === '>=' || comp.operator === '>')) + + return sameDirectionIncreasing || sameDirectionDecreasing || + (sameSemVer && differentDirectionsInclusive) || + oppositeDirectionsLessThan || oppositeDirectionsGreaterThan +} + +exports.Range = Range +function Range (range, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (range instanceof Range) { + if (range.loose === !!options.loose && + range.includePrerelease === !!options.includePrerelease) { + return range + } else { + return new Range(range.raw, options) + } + } + + if (range instanceof Comparator) { + return new Range(range.value, options) + } + + if (!(this instanceof Range)) { + return new Range(range, options) + } + + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + + // First, split based on boolean or || + this.raw = range + this.set = range.split(/\s*\|\|\s*/).map(function (range) { + return this.parseRange(range.trim()) + }, this).filter(function (c) { + // throw out any that are not relevant for whatever reason + return c.length + }) + + if (!this.set.length) { + throw new TypeError('Invalid SemVer Range: ' + range) + } + + this.format() +} + +Range.prototype.format = function () { + this.range = this.set.map(function (comps) { + return comps.join(' ').trim() + }).join('||').trim() + return this.range +} + +Range.prototype.toString = function () { + return this.range +} + +Range.prototype.parseRange = function (range) { + var loose = this.options.loose + range = range.trim() + // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` + var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE] + range = range.replace(hr, hyphenReplace) + debug('hyphen replace', range) + // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` + range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace) + debug('comparator trim', range, re[t.COMPARATORTRIM]) + + // `~ 1.2.3` => `~1.2.3` + range = range.replace(re[t.TILDETRIM], tildeTrimReplace) + + // `^ 1.2.3` => `^1.2.3` + range = range.replace(re[t.CARETTRIM], caretTrimReplace) + + // normalize spaces + range = range.split(/\s+/).join(' ') + + // At this point, the range is completely trimmed and + // ready to be split into comparators. + + var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] + var set = range.split(' ').map(function (comp) { + return parseComparator(comp, this.options) + }, this).join(' ').split(/\s+/) + if (this.options.loose) { + // in loose mode, throw out any that are not valid comparators + set = set.filter(function (comp) { + return !!comp.match(compRe) + }) + } + set = set.map(function (comp) { + return new Comparator(comp, this.options) + }, this) + + return set +} + +Range.prototype.intersects = function (range, options) { + if (!(range instanceof Range)) { + throw new TypeError('a Range is required') + } + + return this.set.some(function (thisComparators) { + return ( + isSatisfiable(thisComparators, options) && + range.set.some(function (rangeComparators) { + return ( + isSatisfiable(rangeComparators, options) && + thisComparators.every(function (thisComparator) { + return rangeComparators.every(function (rangeComparator) { + return thisComparator.intersects(rangeComparator, options) + }) + }) + ) + }) + ) + }) +} + +// take a set of comparators and determine whether there +// exists a version which can satisfy it +function isSatisfiable (comparators, options) { + var result = true + var remainingComparators = comparators.slice() + var testComparator = remainingComparators.pop() + + while (result && remainingComparators.length) { + result = remainingComparators.every(function (otherComparator) { + return testComparator.intersects(otherComparator, options) + }) + + testComparator = remainingComparators.pop() + } + + return result +} + +// Mostly just for testing and legacy API reasons +exports.toComparators = toComparators +function toComparators (range, options) { + return new Range(range, options).set.map(function (comp) { + return comp.map(function (c) { + return c.value + }).join(' ').trim().split(' ') + }) +} + +// comprised of xranges, tildes, stars, and gtlt's at this point. +// already replaced the hyphen ranges +// turn into a set of JUST comparators. +function parseComparator (comp, options) { + debug('comp', comp, options) + comp = replaceCarets(comp, options) + debug('caret', comp) + comp = replaceTildes(comp, options) + debug('tildes', comp) + comp = replaceXRanges(comp, options) + debug('xrange', comp) + comp = replaceStars(comp, options) + debug('stars', comp) + return comp +} + +function isX (id) { + return !id || id.toLowerCase() === 'x' || id === '*' +} + +// ~, ~> --> * (any, kinda silly) +// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 +// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 +// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 +// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 +// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 +function replaceTildes (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceTilde(comp, options) + }).join(' ') +} + +function replaceTilde (comp, options) { + var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE] + return comp.replace(r, function (_, M, m, p, pr) { + debug('tilde', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + // ~1.2 == >=1.2.0 <1.3.0 + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else if (pr) { + debug('replaceTilde pr', pr) + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } else { + // ~1.2.3 == >=1.2.3 <1.3.0 + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + + debug('tilde return', ret) + return ret + }) +} + +// ^ --> * (any, kinda silly) +// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 +// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 +// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 +// ^1.2.3 --> >=1.2.3 <2.0.0 +// ^1.2.0 --> >=1.2.0 <2.0.0 +function replaceCarets (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceCaret(comp, options) + }).join(' ') +} + +function replaceCaret (comp, options) { + debug('caret', comp, options) + var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET] + return comp.replace(r, function (_, M, m, p, pr) { + debug('caret', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + if (M === '0') { + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else { + ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0' + } + } else if (pr) { + debug('replaceCaret pr', pr) + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + (+M + 1) + '.0.0' + } + } else { + debug('no pr') + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + (+M + 1) + '.0.0' + } + } + + debug('caret return', ret) + return ret + }) +} + +function replaceXRanges (comp, options) { + debug('replaceXRanges', comp, options) + return comp.split(/\s+/).map(function (comp) { + return replaceXRange(comp, options) + }).join(' ') +} + +function replaceXRange (comp, options) { + comp = comp.trim() + var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE] + return comp.replace(r, function (ret, gtlt, M, m, p, pr) { + debug('xRange', comp, ret, gtlt, M, m, p, pr) + var xM = isX(M) + var xm = xM || isX(m) + var xp = xm || isX(p) + var anyX = xp + + if (gtlt === '=' && anyX) { + gtlt = '' + } + + // if we're including prereleases in the match, then we need + // to fix this to -0, the lowest possible prerelease value + pr = options.includePrerelease ? '-0' : '' + + if (xM) { + if (gtlt === '>' || gtlt === '<') { + // nothing is allowed + ret = '<0.0.0-0' + } else { + // nothing is forbidden + ret = '*' + } + } else if (gtlt && anyX) { + // we know patch is an x, because we have any x at all. + // replace X with 0 + if (xm) { + m = 0 + } + p = 0 + + if (gtlt === '>') { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + // >1.2.3 => >= 1.2.4 + gtlt = '>=' + if (xm) { + M = +M + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === '<=') { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<' + if (xm) { + M = +M + 1 + } else { + m = +m + 1 + } + } + + ret = gtlt + M + '.' + m + '.' + p + pr + } else if (xm) { + ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr + } else if (xp) { + ret = '>=' + M + '.' + m + '.0' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + pr + } + + debug('xRange return', ret) + + return ret + }) +} + +// Because * is AND-ed with everything else in the comparator, +// and '' means "any version", just remove the *s entirely. +function replaceStars (comp, options) { + debug('replaceStars', comp, options) + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace(re[t.STAR], '') +} + +// This function is passed to string.replace(re[t.HYPHENRANGE]) +// M, m, patch, prerelease, build +// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 +// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do +// 1.2 - 3.4 => >=1.2.0 <3.5.0 +function hyphenReplace ($0, + from, fM, fm, fp, fpr, fb, + to, tM, tm, tp, tpr, tb) { + if (isX(fM)) { + from = '' + } else if (isX(fm)) { + from = '>=' + fM + '.0.0' + } else if (isX(fp)) { + from = '>=' + fM + '.' + fm + '.0' + } else { + from = '>=' + from + } + + if (isX(tM)) { + to = '' + } else if (isX(tm)) { + to = '<' + (+tM + 1) + '.0.0' + } else if (isX(tp)) { + to = '<' + tM + '.' + (+tm + 1) + '.0' + } else if (tpr) { + to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr + } else { + to = '<=' + to + } + + return (from + ' ' + to).trim() +} + +// if ANY of the sets match ALL of its comparators, then pass +Range.prototype.test = function (version) { + if (!version) { + return false + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + for (var i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true + } + } + return false +} + +function testSet (set, version, options) { + for (var i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false + } + } + + if (version.prerelease.length && !options.includePrerelease) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for (i = 0; i < set.length; i++) { + debug(set[i].semver) + if (set[i].semver === ANY) { + continue + } + + if (set[i].semver.prerelease.length > 0) { + var allowed = set[i].semver + if (allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch) { + return true + } + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false + } + + return true +} + +exports.satisfies = satisfies +function satisfies (version, range, options) { + try { + range = new Range(range, options) + } catch (er) { + return false + } + return range.test(version) +} + +exports.maxSatisfying = maxSatisfying +function maxSatisfying (versions, range, options) { + var max = null + var maxSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!max || maxSV.compare(v) === -1) { + // compare(max, v, true) + max = v + maxSV = new SemVer(max, options) + } + } + }) + return max +} + +exports.minSatisfying = minSatisfying +function minSatisfying (versions, range, options) { + var min = null + var minSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!min || minSV.compare(v) === 1) { + // compare(min, v, true) + min = v + minSV = new SemVer(min, options) + } + } + }) + return min +} + +exports.minVersion = minVersion +function minVersion (range, loose) { + range = new Range(range, loose) + + var minver = new SemVer('0.0.0') + if (range.test(minver)) { + return minver + } + + minver = new SemVer('0.0.0-0') + if (range.test(minver)) { + return minver + } + + minver = null + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + comparators.forEach(function (comparator) { + // Clone to avoid manipulating the comparator's semver object. + var compver = new SemVer(comparator.semver.version) + switch (comparator.operator) { + case '>': + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + /* fallthrough */ + case '': + case '>=': + if (!minver || gt(minver, compver)) { + minver = compver + } + break + case '<': + case '<=': + /* Ignore maximum versions */ + break + /* istanbul ignore next */ + default: + throw new Error('Unexpected operation: ' + comparator.operator) + } + }) + } + + if (minver && range.test(minver)) { + return minver + } + + return null +} + +exports.validRange = validRange +function validRange (range, options) { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range(range, options).range || '*' + } catch (er) { + return null + } +} + +// Determine if version is less than all the versions possible in the range +exports.ltr = ltr +function ltr (version, range, options) { + return outside(version, range, '<', options) +} + +// Determine if version is greater than all the versions possible in the range. +exports.gtr = gtr +function gtr (version, range, options) { + return outside(version, range, '>', options) +} + +exports.outside = outside +function outside (version, range, hilo, options) { + version = new SemVer(version, options) + range = new Range(range, options) + + var gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case '>': + gtfn = gt + ltefn = lte + ltfn = lt + comp = '>' + ecomp = '>=' + break + case '<': + gtfn = lt + ltefn = gte + ltfn = gt + comp = '<' + ecomp = '<=' + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + + // If it satisifes the range it is not outside + if (satisfies(version, range, options)) { + return false + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + var high = null + var low = null + + comparators.forEach(function (comparator) { + if (comparator.semver === ANY) { + comparator = new Comparator('>=0.0.0') + } + high = high || comparator + low = low || comparator + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator + } + }) + + // If the edge version comparator has a operator then our version + // isn't outside it + if (high.operator === comp || high.operator === ecomp) { + return false + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ((!low.operator || low.operator === comp) && + ltefn(version, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false + } + } + return true +} + +exports.prerelease = prerelease +function prerelease (version, options) { + var parsed = parse(version, options) + return (parsed && parsed.prerelease.length) ? parsed.prerelease : null +} + +exports.intersects = intersects +function intersects (r1, r2, options) { + r1 = new Range(r1, options) + r2 = new Range(r2, options) + return r1.intersects(r2) +} + +exports.coerce = coerce +function coerce (version, options) { + if (version instanceof SemVer) { + return version + } + + if (typeof version === 'number') { + version = String(version) + } + + if (typeof version !== 'string') { + return null + } + + options = options || {} + + var match = null + if (!options.rtl) { + match = version.match(re[t.COERCE]) + } else { + // Find the right-most coercible string that does not share + // a terminus with a more left-ward coercible string. + // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' + // + // Walk through the string checking with a /g regexp + // Manually set the index so as to pick up overlapping matches. + // Stop when we get a match that ends at the string end, since no + // coercible string can be more right-ward without the same terminus. + var next + while ((next = re[t.COERCERTL].exec(version)) && + (!match || match.index + match[0].length !== version.length) + ) { + if (!match || + next.index + next[0].length !== match.index + match[0].length) { + match = next + } + re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length + } + // leave it in a clean state + re[t.COERCERTL].lastIndex = -1 + } + + if (match === null) { + return null + } + + return parse(match[2] + + '.' + (match[3] || '0') + + '.' + (match[4] || '0'), options) +} + + +/***/ }), + +/***/ 586: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const lt = (a, b, loose) => compare(a, b, loose) < 0 +module.exports = lt + + +/***/ }), + +/***/ 593: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compareBuild = __webpack_require__(16) +const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose)) +module.exports = rsort + + +/***/ }), + +/***/ 605: +/***/ (function(module) { + +module.exports = require("http"); + +/***/ }), + +/***/ 612: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +module.exports = Yallist + +Yallist.Node = Node +Yallist.create = Yallist + +function Yallist (list) { + var self = this + if (!(self instanceof Yallist)) { + self = new Yallist() + } + + self.tail = null + self.head = null + self.length = 0 + + if (list && typeof list.forEach === 'function') { + list.forEach(function (item) { + self.push(item) + }) + } else if (arguments.length > 0) { + for (var i = 0, l = arguments.length; i < l; i++) { + self.push(arguments[i]) + } + } + + return self +} + +Yallist.prototype.removeNode = function (node) { + if (node.list !== this) { + throw new Error('removing node which does not belong to this list') + } + + var next = node.next + var prev = node.prev + + if (next) { + next.prev = prev + } + + if (prev) { + prev.next = next + } + + if (node === this.head) { + this.head = next + } + if (node === this.tail) { + this.tail = prev + } + + node.list.length-- + node.next = null + node.prev = null + node.list = null + + return next +} + +Yallist.prototype.unshiftNode = function (node) { + if (node === this.head) { + return + } + + if (node.list) { + node.list.removeNode(node) + } + + var head = this.head + node.list = this + node.next = head + if (head) { + head.prev = node + } + + this.head = node + if (!this.tail) { + this.tail = node + } + this.length++ +} + +Yallist.prototype.pushNode = function (node) { + if (node === this.tail) { + return + } + + if (node.list) { + node.list.removeNode(node) + } + + var tail = this.tail + node.list = this + node.prev = tail + if (tail) { + tail.next = node + } + + this.tail = node + if (!this.head) { + this.head = node + } + this.length++ +} + +Yallist.prototype.push = function () { + for (var i = 0, l = arguments.length; i < l; i++) { + push(this, arguments[i]) + } + return this.length +} + +Yallist.prototype.unshift = function () { + for (var i = 0, l = arguments.length; i < l; i++) { + unshift(this, arguments[i]) + } + return this.length +} + +Yallist.prototype.pop = function () { + if (!this.tail) { + return undefined + } + + var res = this.tail.value + this.tail = this.tail.prev + if (this.tail) { + this.tail.next = null + } else { + this.head = null + } + this.length-- + return res +} + +Yallist.prototype.shift = function () { + if (!this.head) { + return undefined + } + + var res = this.head.value + this.head = this.head.next + if (this.head) { + this.head.prev = null + } else { + this.tail = null + } + this.length-- + return res +} + +Yallist.prototype.forEach = function (fn, thisp) { + thisp = thisp || this + for (var walker = this.head, i = 0; walker !== null; i++) { + fn.call(thisp, walker.value, i, this) + walker = walker.next + } +} + +Yallist.prototype.forEachReverse = function (fn, thisp) { + thisp = thisp || this + for (var walker = this.tail, i = this.length - 1; walker !== null; i--) { + fn.call(thisp, walker.value, i, this) + walker = walker.prev + } +} + +Yallist.prototype.get = function (n) { + for (var i = 0, walker = this.head; walker !== null && i < n; i++) { + // abort out of the list early if we hit a cycle + walker = walker.next + } + if (i === n && walker !== null) { + return walker.value + } +} + +Yallist.prototype.getReverse = function (n) { + for (var i = 0, walker = this.tail; walker !== null && i < n; i++) { + // abort out of the list early if we hit a cycle + walker = walker.prev + } + if (i === n && walker !== null) { + return walker.value + } +} + +Yallist.prototype.map = function (fn, thisp) { + thisp = thisp || this + var res = new Yallist() + for (var walker = this.head; walker !== null;) { + res.push(fn.call(thisp, walker.value, this)) + walker = walker.next + } + return res +} + +Yallist.prototype.mapReverse = function (fn, thisp) { + thisp = thisp || this + var res = new Yallist() + for (var walker = this.tail; walker !== null;) { + res.push(fn.call(thisp, walker.value, this)) + walker = walker.prev + } + return res +} + +Yallist.prototype.reduce = function (fn, initial) { + var acc + var walker = this.head + if (arguments.length > 1) { + acc = initial + } else if (this.head) { + walker = this.head.next + acc = this.head.value + } else { + throw new TypeError('Reduce of empty list with no initial value') + } + + for (var i = 0; walker !== null; i++) { + acc = fn(acc, walker.value, i) + walker = walker.next + } + + return acc +} + +Yallist.prototype.reduceReverse = function (fn, initial) { + var acc + var walker = this.tail + if (arguments.length > 1) { + acc = initial + } else if (this.tail) { + walker = this.tail.prev + acc = this.tail.value + } else { + throw new TypeError('Reduce of empty list with no initial value') + } + + for (var i = this.length - 1; walker !== null; i--) { + acc = fn(acc, walker.value, i) + walker = walker.prev + } + + return acc +} + +Yallist.prototype.toArray = function () { + var arr = new Array(this.length) + for (var i = 0, walker = this.head; walker !== null; i++) { + arr[i] = walker.value + walker = walker.next + } + return arr +} + +Yallist.prototype.toArrayReverse = function () { + var arr = new Array(this.length) + for (var i = 0, walker = this.tail; walker !== null; i++) { + arr[i] = walker.value + walker = walker.prev + } + return arr +} + +Yallist.prototype.slice = function (from, to) { + to = to || this.length + if (to < 0) { + to += this.length + } + from = from || 0 + if (from < 0) { + from += this.length + } + var ret = new Yallist() + if (to < from || to < 0) { + return ret + } + if (from < 0) { + from = 0 + } + if (to > this.length) { + to = this.length + } + for (var i = 0, walker = this.head; walker !== null && i < from; i++) { + walker = walker.next + } + for (; walker !== null && i < to; i++, walker = walker.next) { + ret.push(walker.value) + } + return ret +} + +Yallist.prototype.sliceReverse = function (from, to) { + to = to || this.length + if (to < 0) { + to += this.length + } + from = from || 0 + if (from < 0) { + from += this.length + } + var ret = new Yallist() + if (to < from || to < 0) { + return ret + } + if (from < 0) { + from = 0 + } + if (to > this.length) { + to = this.length + } + for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) { + walker = walker.prev + } + for (; walker !== null && i > from; i--, walker = walker.prev) { + ret.push(walker.value) + } + return ret +} + +Yallist.prototype.splice = function (start, deleteCount, ...nodes) { + if (start > this.length) { + start = this.length - 1 + } + if (start < 0) { + start = this.length + start; + } + + for (var i = 0, walker = this.head; walker !== null && i < start; i++) { + walker = walker.next + } + + var ret = [] + for (var i = 0; walker && i < deleteCount; i++) { + ret.push(walker.value) + walker = this.removeNode(walker) + } + if (walker === null) { + walker = this.tail + } + + if (walker !== this.head && walker !== this.tail) { + walker = walker.prev + } + + for (var i = 0; i < nodes.length; i++) { + walker = insert(this, walker, nodes[i]) + } + return ret; +} + +Yallist.prototype.reverse = function () { + var head = this.head + var tail = this.tail + for (var walker = head; walker !== null; walker = walker.prev) { + var p = walker.prev + walker.prev = walker.next + walker.next = p + } + this.head = tail + this.tail = head + return this +} + +function insert (self, node, value) { + var inserted = node === self.head ? + new Node(value, null, node, self) : + new Node(value, node, node.next, self) + + if (inserted.next === null) { + self.tail = inserted + } + if (inserted.prev === null) { + self.head = inserted + } + + self.length++ + + return inserted +} + +function push (self, item) { + self.tail = new Node(item, self.tail, null, self) + if (!self.head) { + self.head = self.tail + } + self.length++ +} + +function unshift (self, item) { + self.head = new Node(item, null, self.head, self) + if (!self.tail) { + self.tail = self.head + } + self.length++ +} + +function Node (value, prev, next, list) { + if (!(this instanceof Node)) { + return new Node(value, prev, next, list) + } + + this.list = list + this.value = value + + if (prev) { + prev.next = this + this.prev = prev + } else { + this.prev = null + } + + if (next) { + next.prev = this + this.next = next + } else { + this.next = null + } +} + +try { + // add if support for Symbol.iterator is present + __webpack_require__(396)(Yallist) +} catch (er) {} + + /***/ }), /***/ 614: @@ -1475,6 +6592,23 @@ module.exports = require("path"); /***/ }), +/***/ 630: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const rcompare = (a, b, loose) => compare(b, a, loose) +module.exports = rcompare + + +/***/ }), + +/***/ 631: +/***/ (function(module) { + +module.exports = require("net"); + +/***/ }), + /***/ 669: /***/ (function(module) { @@ -1682,6 +6816,461 @@ function isUnixExecutable(stats) { } //# sourceMappingURL=io-util.js.map +/***/ }), + +/***/ 694: +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +exports.STATE_GPG_PRIVATE_KEY_FINGERPRINT = exports.INPUT_DEFAULT_GPG_PASSPHRASE = exports.INPUT_DEFAULT_GPG_PRIVATE_KEY = exports.INPUT_GPG_PASSPHRASE = exports.INPUT_GPG_PRIVATE_KEY = exports.INPUT_SETTINGS_PATH = exports.INPUT_SERVER_PASSWORD = exports.INPUT_SERVER_USERNAME = exports.INPUT_SERVER_ID = exports.INPUT_JDK_FILE = exports.INPUT_DISTRIBUTION = exports.INPUT_JAVA_PACKAGE = exports.INPUT_ARCHITECTURE = exports.INPUT_JAVA_VERSION = exports.MACOS_JAVA_CONTENT_POSTFIX = void 0; +exports.MACOS_JAVA_CONTENT_POSTFIX = 'Contents/Home'; +exports.INPUT_JAVA_VERSION = 'java-version'; +exports.INPUT_ARCHITECTURE = 'architecture'; +exports.INPUT_JAVA_PACKAGE = 'java-package'; +exports.INPUT_DISTRIBUTION = 'distribution'; +exports.INPUT_JDK_FILE = 'jdkFile'; +exports.INPUT_SERVER_ID = 'server-id'; +exports.INPUT_SERVER_USERNAME = 'server-username'; +exports.INPUT_SERVER_PASSWORD = 'server-password'; +exports.INPUT_SETTINGS_PATH = 'settings-path'; +exports.INPUT_GPG_PRIVATE_KEY = 'gpg-private-key'; +exports.INPUT_GPG_PASSPHRASE = 'gpg-passphrase'; +exports.INPUT_DEFAULT_GPG_PRIVATE_KEY = undefined; +exports.INPUT_DEFAULT_GPG_PASSPHRASE = 'GPG_PASSPHRASE'; +exports.STATE_GPG_PRIVATE_KEY_FINGERPRINT = 'gpg-private-key-fingerprint'; + + +/***/ }), + +/***/ 702: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +// A linked list to keep track of recently-used-ness +const Yallist = __webpack_require__(612) + +const MAX = Symbol('max') +const LENGTH = Symbol('length') +const LENGTH_CALCULATOR = Symbol('lengthCalculator') +const ALLOW_STALE = Symbol('allowStale') +const MAX_AGE = Symbol('maxAge') +const DISPOSE = Symbol('dispose') +const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet') +const LRU_LIST = Symbol('lruList') +const CACHE = Symbol('cache') +const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet') + +const naiveLength = () => 1 + +// lruList is a yallist where the head is the youngest +// item, and the tail is the oldest. the list contains the Hit +// objects as the entries. +// Each Hit object has a reference to its Yallist.Node. This +// never changes. +// +// cache is a Map (or PseudoMap) that matches the keys to +// the Yallist.Node object. +class LRUCache { + constructor (options) { + if (typeof options === 'number') + options = { max: options } + + if (!options) + options = {} + + if (options.max && (typeof options.max !== 'number' || options.max < 0)) + throw new TypeError('max must be a non-negative number') + // Kind of weird to have a default max of Infinity, but oh well. + const max = this[MAX] = options.max || Infinity + + const lc = options.length || naiveLength + this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc + this[ALLOW_STALE] = options.stale || false + if (options.maxAge && typeof options.maxAge !== 'number') + throw new TypeError('maxAge must be a number') + this[MAX_AGE] = options.maxAge || 0 + this[DISPOSE] = options.dispose + this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false + this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false + this.reset() + } + + // resize the cache when the max changes. + set max (mL) { + if (typeof mL !== 'number' || mL < 0) + throw new TypeError('max must be a non-negative number') + + this[MAX] = mL || Infinity + trim(this) + } + get max () { + return this[MAX] + } + + set allowStale (allowStale) { + this[ALLOW_STALE] = !!allowStale + } + get allowStale () { + return this[ALLOW_STALE] + } + + set maxAge (mA) { + if (typeof mA !== 'number') + throw new TypeError('maxAge must be a non-negative number') + + this[MAX_AGE] = mA + trim(this) + } + get maxAge () { + return this[MAX_AGE] + } + + // resize the cache when the lengthCalculator changes. + set lengthCalculator (lC) { + if (typeof lC !== 'function') + lC = naiveLength + + if (lC !== this[LENGTH_CALCULATOR]) { + this[LENGTH_CALCULATOR] = lC + this[LENGTH] = 0 + this[LRU_LIST].forEach(hit => { + hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key) + this[LENGTH] += hit.length + }) + } + trim(this) + } + get lengthCalculator () { return this[LENGTH_CALCULATOR] } + + get length () { return this[LENGTH] } + get itemCount () { return this[LRU_LIST].length } + + rforEach (fn, thisp) { + thisp = thisp || this + for (let walker = this[LRU_LIST].tail; walker !== null;) { + const prev = walker.prev + forEachStep(this, fn, walker, thisp) + walker = prev + } + } + + forEach (fn, thisp) { + thisp = thisp || this + for (let walker = this[LRU_LIST].head; walker !== null;) { + const next = walker.next + forEachStep(this, fn, walker, thisp) + walker = next + } + } + + keys () { + return this[LRU_LIST].toArray().map(k => k.key) + } + + values () { + return this[LRU_LIST].toArray().map(k => k.value) + } + + reset () { + if (this[DISPOSE] && + this[LRU_LIST] && + this[LRU_LIST].length) { + this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value)) + } + + this[CACHE] = new Map() // hash of items by key + this[LRU_LIST] = new Yallist() // list of items in order of use recency + this[LENGTH] = 0 // length of items in the list + } + + dump () { + return this[LRU_LIST].map(hit => + isStale(this, hit) ? false : { + k: hit.key, + v: hit.value, + e: hit.now + (hit.maxAge || 0) + }).toArray().filter(h => h) + } + + dumpLru () { + return this[LRU_LIST] + } + + set (key, value, maxAge) { + maxAge = maxAge || this[MAX_AGE] + + if (maxAge && typeof maxAge !== 'number') + throw new TypeError('maxAge must be a number') + + const now = maxAge ? Date.now() : 0 + const len = this[LENGTH_CALCULATOR](value, key) + + if (this[CACHE].has(key)) { + if (len > this[MAX]) { + del(this, this[CACHE].get(key)) + return false + } + + const node = this[CACHE].get(key) + const item = node.value + + // dispose of the old one before overwriting + // split out into 2 ifs for better coverage tracking + if (this[DISPOSE]) { + if (!this[NO_DISPOSE_ON_SET]) + this[DISPOSE](key, item.value) + } + + item.now = now + item.maxAge = maxAge + item.value = value + this[LENGTH] += len - item.length + item.length = len + this.get(key) + trim(this) + return true + } + + const hit = new Entry(key, value, len, now, maxAge) + + // oversized objects fall out of cache automatically. + if (hit.length > this[MAX]) { + if (this[DISPOSE]) + this[DISPOSE](key, value) + + return false + } + + this[LENGTH] += hit.length + this[LRU_LIST].unshift(hit) + this[CACHE].set(key, this[LRU_LIST].head) + trim(this) + return true + } + + has (key) { + if (!this[CACHE].has(key)) return false + const hit = this[CACHE].get(key).value + return !isStale(this, hit) + } + + get (key) { + return get(this, key, true) + } + + peek (key) { + return get(this, key, false) + } + + pop () { + const node = this[LRU_LIST].tail + if (!node) + return null + + del(this, node) + return node.value + } + + del (key) { + del(this, this[CACHE].get(key)) + } + + load (arr) { + // reset the cache + this.reset() + + const now = Date.now() + // A previous serialized cache has the most recent items first + for (let l = arr.length - 1; l >= 0; l--) { + const hit = arr[l] + const expiresAt = hit.e || 0 + if (expiresAt === 0) + // the item was created without expiration in a non aged cache + this.set(hit.k, hit.v) + else { + const maxAge = expiresAt - now + // dont add already expired items + if (maxAge > 0) { + this.set(hit.k, hit.v, maxAge) + } + } + } + } + + prune () { + this[CACHE].forEach((value, key) => get(this, key, false)) + } +} + +const get = (self, key, doUse) => { + const node = self[CACHE].get(key) + if (node) { + const hit = node.value + if (isStale(self, hit)) { + del(self, node) + if (!self[ALLOW_STALE]) + return undefined + } else { + if (doUse) { + if (self[UPDATE_AGE_ON_GET]) + node.value.now = Date.now() + self[LRU_LIST].unshiftNode(node) + } + } + return hit.value + } +} + +const isStale = (self, hit) => { + if (!hit || (!hit.maxAge && !self[MAX_AGE])) + return false + + const diff = Date.now() - hit.now + return hit.maxAge ? diff > hit.maxAge + : self[MAX_AGE] && (diff > self[MAX_AGE]) +} + +const trim = self => { + if (self[LENGTH] > self[MAX]) { + for (let walker = self[LRU_LIST].tail; + self[LENGTH] > self[MAX] && walker !== null;) { + // We know that we're about to delete this one, and also + // what the next least recently used key will be, so just + // go ahead and set it now. + const prev = walker.prev + del(self, walker) + walker = prev + } + } +} + +const del = (self, node) => { + if (node) { + const hit = node.value + if (self[DISPOSE]) + self[DISPOSE](hit.key, hit.value) + + self[LENGTH] -= hit.length + self[CACHE].delete(hit.key) + self[LRU_LIST].removeNode(node) + } +} + +class Entry { + constructor (key, value, length, now, maxAge) { + this.key = key + this.value = value + this.length = length + this.now = now + this.maxAge = maxAge || 0 + } +} + +const forEachStep = (self, fn, node, thisp) => { + let hit = node.value + if (isStale(self, hit)) { + del(self, node) + if (!self[ALLOW_STALE]) + hit = undefined + } + if (hit) + fn.call(thisp, hit.value, hit.key, self) +} + +module.exports = LRUCache + + +/***/ }), + +/***/ 714: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const parse = __webpack_require__(830) +const valid = (version, options) => { + const v = parse(version, options) + return v ? v.version : null +} +module.exports = valid + + +/***/ }), + +/***/ 722: +/***/ (function(module) { + +/** + * Convert array of 16 byte values to UUID string format of the form: + * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX + */ +var byteToHex = []; +for (var i = 0; i < 256; ++i) { + byteToHex[i] = (i + 0x100).toString(16).substr(1); +} + +function bytesToUuid(buf, offset) { + var i = offset || 0; + var bth = byteToHex; + // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4 + return ([ + bth[buf[i++]], bth[buf[i++]], + bth[buf[i++]], bth[buf[i++]], '-', + bth[buf[i++]], bth[buf[i++]], '-', + bth[buf[i++]], bth[buf[i++]], '-', + bth[buf[i++]], bth[buf[i++]], '-', + bth[buf[i++]], bth[buf[i++]], + bth[buf[i++]], bth[buf[i++]], + bth[buf[i++]], bth[buf[i++]] + ]).join(''); +} + +module.exports = bytesToUuid; + + +/***/ }), + +/***/ 740: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) +const minSatisfying = (versions, range, options) => { + let min = null + let minSV = null + let rangeObj = null + try { + rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!min || minSV.compare(v) === 1) { + // compare(min, v, true) + min = v + minSV = new SemVer(min, options) + } + } + }) + return min +} +module.exports = minSatisfying + + +/***/ }), + +/***/ 744: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const major = (a, loose) => new SemVer(a, loose).major +module.exports = major + + /***/ }), /***/ 747: @@ -1689,6 +7278,381 @@ function isUnixExecutable(stats) { module.exports = require("fs"); +/***/ }), + +/***/ 752: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const eq = __webpack_require__(298) +const neq = __webpack_require__(873) +const gt = __webpack_require__(486) +const gte = __webpack_require__(167) +const lt = __webpack_require__(586) +const lte = __webpack_require__(898) + +const cmp = (a, op, b, loose) => { + switch (op) { + case '===': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a === b + + case '!==': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a !== b + + case '': + case '=': + case '==': + return eq(a, b, loose) + + case '!=': + return neq(a, b, loose) + + case '>': + return gt(a, b, loose) + + case '>=': + return gte(a, b, loose) + + case '<': + return lt(a, b, loose) + + case '<=': + return lte(a, b, loose) + + default: + throw new TypeError(`Invalid operator: ${op}`) + } +} +module.exports = cmp + + +/***/ }), + +/***/ 760: +/***/ (function(module) { + +const numeric = /^[0-9]+$/ +const compareIdentifiers = (a, b) => { + const anum = numeric.test(a) + const bnum = numeric.test(b) + + if (anum && bnum) { + a = +a + b = +b + } + + return a === b ? 0 + : (anum && !bnum) ? -1 + : (bnum && !anum) ? 1 + : a < b ? -1 + : 1 +} + +const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a) + +module.exports = { + compareIdentifiers, + rcompareIdentifiers +} + + +/***/ }), + +/***/ 794: +/***/ (function(module) { + +module.exports = require("stream"); + +/***/ }), + +/***/ 803: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const minor = (a, loose) => new SemVer(a, loose).minor +module.exports = minor + + +/***/ }), + +/***/ 811: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) + +const maxSatisfying = (versions, range, options) => { + let max = null + let maxSV = null + let rangeObj = null + try { + rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!max || maxSV.compare(v) === -1) { + // compare(max, v, true) + max = v + maxSV = new SemVer(max, options) + } + } + }) + return max +} +module.exports = maxSatisfying + + +/***/ }), + +/***/ 818: +/***/ (function(module) { + +module.exports = require("tls"); + +/***/ }), + +/***/ 822: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const parse = __webpack_require__(830) +const eq = __webpack_require__(298) + +const diff = (version1, version2) => { + if (eq(version1, version2)) { + return null + } else { + const v1 = parse(version1) + const v2 = parse(version2) + const hasPre = v1.prerelease.length || v2.prerelease.length + const prefix = hasPre ? 'pre' : '' + const defaultResult = hasPre ? 'prerelease' : '' + for (const key in v1) { + if (key === 'major' || key === 'minor' || key === 'patch') { + if (v1[key] !== v2[key]) { + return prefix + key + } + } + } + return defaultResult // may be undefined + } +} +module.exports = diff + + +/***/ }), + +/***/ 826: +/***/ (function(module, __unusedexports, __webpack_require__) { + +var rng = __webpack_require__(139); +var bytesToUuid = __webpack_require__(722); + +function v4(options, buf, offset) { + var i = buf && offset || 0; + + if (typeof(options) == 'string') { + buf = options === 'binary' ? new Array(16) : null; + options = null; + } + options = options || {}; + + var rnds = options.random || (options.rng || rng)(); + + // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` + rnds[6] = (rnds[6] & 0x0f) | 0x40; + rnds[8] = (rnds[8] & 0x3f) | 0x80; + + // Copy bytes to buffer, if provided + if (buf) { + for (var ii = 0; ii < 16; ++ii) { + buf[i + ii] = rnds[ii]; + } + } + + return buf || bytesToUuid(rnds); +} + +module.exports = v4; + + +/***/ }), + +/***/ 830: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const {MAX_LENGTH} = __webpack_require__(181) +const { re, t } = __webpack_require__(976) +const SemVer = __webpack_require__(65) + +const parseOptions = __webpack_require__(143) +const parse = (version, options) => { + options = parseOptions(options) + + if (version instanceof SemVer) { + return version + } + + if (typeof version !== 'string') { + return null + } + + if (version.length > MAX_LENGTH) { + return null + } + + const r = options.loose ? re[t.LOOSE] : re[t.FULL] + if (!r.test(version)) { + return null + } + + try { + return new SemVer(version, options) + } catch (er) { + return null + } +} + +module.exports = parse + + +/***/ }), + +/***/ 873: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const neq = (a, b, loose) => compare(a, b, loose) !== 0 +module.exports = neq + + +/***/ }), + +/***/ 874: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const compare = (a, b, loose) => + new SemVer(a, loose).compare(new SemVer(b, loose)) + +module.exports = compare + + +/***/ }), + +/***/ 876: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// just pre-load all the stuff that index.js lazily exports +const internalRe = __webpack_require__(976) +module.exports = { + re: internalRe.re, + src: internalRe.src, + tokens: internalRe.t, + SEMVER_SPEC_VERSION: __webpack_require__(181).SEMVER_SPEC_VERSION, + SemVer: __webpack_require__(65), + compareIdentifiers: __webpack_require__(760).compareIdentifiers, + rcompareIdentifiers: __webpack_require__(760).rcompareIdentifiers, + parse: __webpack_require__(830), + valid: __webpack_require__(714), + clean: __webpack_require__(503), + inc: __webpack_require__(928), + diff: __webpack_require__(822), + major: __webpack_require__(744), + minor: __webpack_require__(803), + patch: __webpack_require__(489), + prerelease: __webpack_require__(968), + compare: __webpack_require__(874), + rcompare: __webpack_require__(630), + compareLoose: __webpack_require__(283), + compareBuild: __webpack_require__(16), + sort: __webpack_require__(120), + rsort: __webpack_require__(593), + gt: __webpack_require__(486), + lt: __webpack_require__(586), + eq: __webpack_require__(298), + neq: __webpack_require__(873), + gte: __webpack_require__(167), + lte: __webpack_require__(898), + cmp: __webpack_require__(752), + coerce: __webpack_require__(499), + Comparator: __webpack_require__(174), + Range: __webpack_require__(124), + satisfies: __webpack_require__(310), + toComparators: __webpack_require__(20), + maxSatisfying: __webpack_require__(811), + minSatisfying: __webpack_require__(740), + minVersion: __webpack_require__(164), + validRange: __webpack_require__(480), + outside: __webpack_require__(462), + gtr: __webpack_require__(531), + ltr: __webpack_require__(323), + intersects: __webpack_require__(259), + simplifyRange: __webpack_require__(877), + subset: __webpack_require__(999), +} + + +/***/ }), + +/***/ 877: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// given a set of versions and a range, create a "simplified" range +// that includes the same versions that the original range does +// If the original range is shorter than the simplified one, return that. +const satisfies = __webpack_require__(310) +const compare = __webpack_require__(874) +module.exports = (versions, range, options) => { + const set = [] + let min = null + let prev = null + const v = versions.sort((a, b) => compare(a, b, options)) + for (const version of v) { + const included = satisfies(version, range, options) + if (included) { + prev = version + if (!min) + min = version + } else { + if (prev) { + set.push([min, prev]) + } + prev = null + min = null + } + } + if (min) + set.push([min, null]) + + const ranges = [] + for (const [min, max] of set) { + if (min === max) + ranges.push(min) + else if (!max && min === v[0]) + ranges.push('*') + else if (!max) + ranges.push(`>=${min}`) + else if (min === v[0]) + ranges.push(`<=${max}`) + else + ranges.push(`${min} - ${max}`) + } + const simplified = ranges.join(' || ') + const original = typeof range.raw === 'string' ? range.raw : String(range) + return simplified.length < original.length ? simplified : range +} + + /***/ }), /***/ 884: @@ -1696,6 +7660,25 @@ module.exports = require("fs"); "use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; 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) { @@ -1705,14 +7688,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge step((generator = generator.apply(thisArg, _arguments || [])).next()); }); }; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; Object.defineProperty(exports, "__esModule", { value: true }); +exports.deleteKey = exports.importKey = exports.PRIVATE_KEY_FILE = void 0; const fs = __importStar(__webpack_require__(747)); const path = __importStar(__webpack_require__(622)); const io = __importStar(__webpack_require__(1)); @@ -1735,13 +7712,7 @@ function importKey(privateKey) { } } }; - yield exec.exec('gpg', [ - '--batch', - '--import-options', - 'import-show', - '--import', - exports.PRIVATE_KEY_FILE - ], options); + yield exec.exec('gpg', ['--batch', '--import-options', 'import-show', '--import', exports.PRIVATE_KEY_FILE], options); yield io.rmRF(exports.PRIVATE_KEY_FILE); const match = output.match(PRIVATE_KEY_FINGERPRINT_REGEX); return match && match[0]; @@ -1750,13 +7721,391 @@ function importKey(privateKey) { exports.importKey = importKey; function deleteKey(keyFingerprint) { return __awaiter(this, void 0, void 0, function* () { - yield exec.exec('gpg', ['--batch', '--yes', '--delete-secret-keys', keyFingerprint], { silent: true }); + yield exec.exec('gpg', ['--batch', '--yes', '--delete-secret-keys', keyFingerprint], { + silent: true + }); yield exec.exec('gpg', ['--batch', '--yes', '--delete-keys', keyFingerprint], { silent: true }); }); } exports.deleteKey = deleteKey; +/***/ }), + +/***/ 898: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const lte = (a, b, loose) => compare(a, b, loose) <= 0 +module.exports = lte + + +/***/ }), + +/***/ 928: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) + +const inc = (version, release, options, identifier) => { + if (typeof (options) === 'string') { + identifier = options + options = undefined + } + + try { + return new SemVer(version, options).inc(release, identifier).version + } catch (er) { + return null + } +} +module.exports = inc + + +/***/ }), + +/***/ 950: +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +function getProxyUrl(reqUrl) { + let usingSsl = reqUrl.protocol === 'https:'; + let proxyUrl; + if (checkBypass(reqUrl)) { + return proxyUrl; + } + let proxyVar; + if (usingSsl) { + proxyVar = process.env['https_proxy'] || process.env['HTTPS_PROXY']; + } + else { + proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY']; + } + if (proxyVar) { + proxyUrl = new URL(proxyVar); + } + return proxyUrl; +} +exports.getProxyUrl = getProxyUrl; +function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; + } + let noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; + if (!noProxy) { + return false; + } + // Determine the request port + let reqPort; + if (reqUrl.port) { + reqPort = Number(reqUrl.port); + } + else if (reqUrl.protocol === 'http:') { + reqPort = 80; + } + else if (reqUrl.protocol === 'https:') { + reqPort = 443; + } + // Format the request hostname and hostname with port + let upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === 'number') { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + // Compare request host against noproxy + for (let upperNoProxyItem of noProxy + .split(',') + .map(x => x.trim().toUpperCase()) + .filter(x => x)) { + if (upperReqHosts.some(x => x === upperNoProxyItem)) { + return true; + } + } + return false; +} +exports.checkBypass = checkBypass; + + +/***/ }), + +/***/ 968: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const parse = __webpack_require__(830) +const prerelease = (version, options) => { + const parsed = parse(version, options) + return (parsed && parsed.prerelease.length) ? parsed.prerelease : null +} +module.exports = prerelease + + +/***/ }), + +/***/ 976: +/***/ (function(module, exports, __webpack_require__) { + +const { MAX_SAFE_COMPONENT_LENGTH } = __webpack_require__(181) +const debug = __webpack_require__(548) +exports = module.exports = {} + +// The actual regexps go on exports.re +const re = exports.re = [] +const src = exports.src = [] +const t = exports.t = {} +let R = 0 + +const createToken = (name, value, isGlobal) => { + const index = R++ + debug(index, value) + t[name] = index + src[index] = value + re[index] = new RegExp(value, isGlobal ? 'g' : undefined) +} + +// The following Regular Expressions can be used for tokenizing, +// validating, and parsing SemVer version strings. + +// ## Numeric Identifier +// A single `0`, or a non-zero digit followed by zero or more digits. + +createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*') +createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+') + +// ## Non-numeric Identifier +// Zero or more digits, followed by a letter or hyphen, and then zero or +// more letters, digits, or hyphens. + +createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*') + +// ## Main Version +// Three dot-separated numeric identifiers. + +createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` + + `(${src[t.NUMERICIDENTIFIER]})\\.` + + `(${src[t.NUMERICIDENTIFIER]})`) + +createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + + `(${src[t.NUMERICIDENTIFIERLOOSE]})`) + +// ## Pre-release Version Identifier +// A numeric identifier, or a non-numeric identifier. + +createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER] +}|${src[t.NONNUMERICIDENTIFIER]})`) + +createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE] +}|${src[t.NONNUMERICIDENTIFIER]})`) + +// ## Pre-release Version +// Hyphen, followed by one or more dot-separated pre-release version +// identifiers. + +createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER] +}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`) + +createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE] +}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`) + +// ## Build Metadata Identifier +// Any combination of digits, letters, or hyphens. + +createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+') + +// ## Build Metadata +// Plus sign, followed by one or more period-separated build metadata +// identifiers. + +createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER] +}(?:\\.${src[t.BUILDIDENTIFIER]})*))`) + +// ## Full Version String +// A main version, followed optionally by a pre-release version and +// build metadata. + +// Note that the only major, minor, patch, and pre-release sections of +// the version string are capturing groups. The build metadata is not a +// capturing group, because it should not ever be used in version +// comparison. + +createToken('FULLPLAIN', `v?${src[t.MAINVERSION] +}${src[t.PRERELEASE]}?${ + src[t.BUILD]}?`) + +createToken('FULL', `^${src[t.FULLPLAIN]}$`) + +// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. +// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty +// common in the npm registry. +createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE] +}${src[t.PRERELEASELOOSE]}?${ + src[t.BUILD]}?`) + +createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`) + +createToken('GTLT', '((?:<|>)?=?)') + +// Something like "2.*" or "1.2.x". +// Note that "x.x" is a valid xRange identifer, meaning "any version" +// Only the first item is strictly required. +createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`) +createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`) + +createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + + `(?:${src[t.PRERELEASE]})?${ + src[t.BUILD]}?` + + `)?)?`) + +createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:${src[t.PRERELEASELOOSE]})?${ + src[t.BUILD]}?` + + `)?)?`) + +createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`) +createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`) + +// Coercion. +// Extract anything that could conceivably be a part of a valid semver +createToken('COERCE', `${'(^|[^\\d])' + + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + + `(?:$|[^\\d])`) +createToken('COERCERTL', src[t.COERCE], true) + +// Tilde ranges. +// Meaning is "reasonably at or greater than" +createToken('LONETILDE', '(?:~>?)') + +createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true) +exports.tildeTrimReplace = '$1~' + +createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`) +createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`) + +// Caret ranges. +// Meaning is "at least and backwards compatible with" +createToken('LONECARET', '(?:\\^)') + +createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true) +exports.caretTrimReplace = '$1^' + +createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`) +createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`) + +// A simple gt/lt/eq thing, or just "" to indicate "any version" +createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`) +createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`) + +// An expression to strip any whitespace between the gtlt and the thing +// it modifies, so that `> 1.2.3` ==> `>1.2.3` +createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT] +}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true) +exports.comparatorTrimReplace = '$1$2$3' + +// Something like `1.2.3 - 1.2.4` +// Note that these all use the loose form, because they'll be +// checked against either the strict or loose comparator form +// later. +createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` + + `\\s+-\\s+` + + `(${src[t.XRANGEPLAIN]})` + + `\\s*$`) + +createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + + `\\s+-\\s+` + + `(${src[t.XRANGEPLAINLOOSE]})` + + `\\s*$`) + +// Star ranges basically just allow anything at all. +createToken('STAR', '(<|>)?=?\\s*\\*') +// >=0.0.0 is like a star +createToken('GTE0', '^\\s*>=\\s*0\.0\.0\\s*$') +createToken('GTE0PRE', '^\\s*>=\\s*0\.0\.0-0\\s*$') + + +/***/ }), + +/***/ 979: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const core = __importStar(__webpack_require__(470)); +/** + * Internal class for retries + */ +class RetryHelper { + constructor(maxAttempts, minSeconds, maxSeconds) { + if (maxAttempts < 1) { + throw new Error('max attempts should be greater than or equal to 1'); + } + this.maxAttempts = maxAttempts; + this.minSeconds = Math.floor(minSeconds); + this.maxSeconds = Math.floor(maxSeconds); + if (this.minSeconds > this.maxSeconds) { + throw new Error('min seconds should be less than or equal to max seconds'); + } + } + execute(action, isRetryable) { + return __awaiter(this, void 0, void 0, function* () { + let attempt = 1; + while (attempt < this.maxAttempts) { + // Try + try { + return yield action(); + } + catch (err) { + if (isRetryable && !isRetryable(err)) { + throw err; + } + core.info(err.message); + } + // Sleep + const seconds = this.getSleepAmount(); + core.info(`Waiting ${seconds} seconds before trying again`); + yield this.sleep(seconds); + attempt++; + } + // Last attempt + return yield action(); + }); + } + getSleepAmount() { + return (Math.floor(Math.random() * (this.maxSeconds - this.minSeconds + 1)) + + this.minSeconds); + } + sleep(seconds) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise(resolve => setTimeout(resolve, seconds * 1000)); + }); + } +} +exports.RetryHelper = RetryHelper; +//# sourceMappingURL=retry-helper.js.map + /***/ }), /***/ 986: @@ -1773,8 +8122,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge step((generator = generator.apply(thisArg, _arguments || [])).next()); }); }; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const tr = __webpack_require__(9); +const tr = __importStar(__webpack_require__(9)); /** * Exec a command. * Output will be streamed to the live console. @@ -1801,6 +8157,175 @@ function exec(commandLine, args, options) { exports.exec = exec; //# sourceMappingURL=exec.js.map +/***/ }), + +/***/ 999: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) +const { ANY } = __webpack_require__(174) +const satisfies = __webpack_require__(310) +const compare = __webpack_require__(874) + +// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff: +// - Every simple range `r1, r2, ...` is a subset of some `R1, R2, ...` +// +// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff: +// - If c is only the ANY comparator +// - If C is only the ANY comparator, return true +// - Else return false +// - Let EQ be the set of = comparators in c +// - If EQ is more than one, return true (null set) +// - Let GT be the highest > or >= comparator in c +// - Let LT be the lowest < or <= comparator in c +// - If GT and LT, and GT.semver > LT.semver, return true (null set) +// - If EQ +// - If GT, and EQ does not satisfy GT, return true (null set) +// - If LT, and EQ does not satisfy LT, return true (null set) +// - If EQ satisfies every C, return true +// - Else return false +// - If GT +// - If GT.semver is lower than any > or >= comp in C, return false +// - If GT is >=, and GT.semver does not satisfy every C, return false +// - If LT +// - If LT.semver is greater than any < or <= comp in C, return false +// - If LT is <=, and LT.semver does not satisfy every C, return false +// - If any C is a = range, and GT or LT are set, return false +// - Else return true + +const subset = (sub, dom, options) => { + if (sub === dom) + return true + + sub = new Range(sub, options) + dom = new Range(dom, options) + let sawNonNull = false + + OUTER: for (const simpleSub of sub.set) { + for (const simpleDom of dom.set) { + const isSub = simpleSubset(simpleSub, simpleDom, options) + sawNonNull = sawNonNull || isSub !== null + if (isSub) + continue OUTER + } + // the null set is a subset of everything, but null simple ranges in + // a complex range should be ignored. so if we saw a non-null range, + // then we know this isn't a subset, but if EVERY simple range was null, + // then it is a subset. + if (sawNonNull) + return false + } + return true +} + +const simpleSubset = (sub, dom, options) => { + if (sub === dom) + return true + + if (sub.length === 1 && sub[0].semver === ANY) + return dom.length === 1 && dom[0].semver === ANY + + const eqSet = new Set() + let gt, lt + for (const c of sub) { + if (c.operator === '>' || c.operator === '>=') + gt = higherGT(gt, c, options) + else if (c.operator === '<' || c.operator === '<=') + lt = lowerLT(lt, c, options) + else + eqSet.add(c.semver) + } + + if (eqSet.size > 1) + return null + + let gtltComp + if (gt && lt) { + gtltComp = compare(gt.semver, lt.semver, options) + if (gtltComp > 0) + return null + else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) + return null + } + + // will iterate one or zero times + for (const eq of eqSet) { + if (gt && !satisfies(eq, String(gt), options)) + return null + + if (lt && !satisfies(eq, String(lt), options)) + return null + + for (const c of dom) { + if (!satisfies(eq, String(c), options)) + return false + } + + return true + } + + let higher, lower + let hasDomLT, hasDomGT + for (const c of dom) { + hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=' + hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=' + if (gt) { + if (c.operator === '>' || c.operator === '>=') { + higher = higherGT(gt, c, options) + if (higher === c && higher !== gt) + return false + } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) + return false + } + if (lt) { + if (c.operator === '<' || c.operator === '<=') { + lower = lowerLT(lt, c, options) + if (lower === c && lower !== lt) + return false + } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) + return false + } + if (!c.operator && (lt || gt) && gtltComp !== 0) + return false + } + + // if there was a < or >, and nothing in the dom, then must be false + // UNLESS it was limited by another range in the other direction. + // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0 + if (gt && hasDomLT && !lt && gtltComp !== 0) + return false + + if (lt && hasDomGT && !gt && gtltComp !== 0) + return false + + return true +} + +// >=1.2.3 is lower than >1.2.3 +const higherGT = (a, b, options) => { + if (!a) + return b + const comp = compare(a.semver, b.semver, options) + return comp > 0 ? a + : comp < 0 ? b + : b.operator === '>' && a.operator === '>=' ? b + : a +} + +// <=1.2.3 is higher than <1.2.3 +const lowerLT = (a, b, options) => { + if (!a) + return b + const comp = compare(a.semver, b.semver, options) + return comp < 0 ? a + : comp > 0 ? b + : b.operator === '<' && a.operator === '<=' ? b + : a +} + +module.exports = subset + + /***/ }) /******/ }); \ No newline at end of file diff --git a/dist/setup/index.js b/dist/setup/index.js index a1ef83a..bd0168d 100644 --- a/dist/setup/index.js +++ b/dist/setup/index.js @@ -41,9 +41,9 @@ module.exports = /******/ return startup(); /******/ }) /************************************************************************/ -/******/ ({ - -/***/ 1: +/******/ ([ +/* 0 */, +/* 1 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; @@ -339,602 +339,61 @@ function copyFile(srcFile, destFile, force) { //# sourceMappingURL=io.js.map /***/ }), - -/***/ 9: -/***/ (function(__unusedmodule, exports, __webpack_require__) { +/* 2 */, +/* 3 */, +/* 4 */, +/* 5 */, +/* 6 */, +/* 7 */, +/* 8 */, +/* 9 */ +/***/ (function(module, __unusedexports, __webpack_require__) { "use strict"; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const os = __webpack_require__(87); -const events = __webpack_require__(614); -const child = __webpack_require__(129); -const path = __webpack_require__(622); -const io = __webpack_require__(1); -const ioUtil = __webpack_require__(672); -/* 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); - } - } - _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)}`; - } - } - } - 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}`; - } - } - 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); - } - strBuffer = s; - } - catch (err) { - // streaming lines to console is best effort. Don't fail a build. - this._debug(`error processing line. Failed with error ${err}`); - } - } - _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) { - // 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(''); - } - _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; - } - _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* () { - // 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) => { - 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); - }); - const fileName = this._getSpawnFileName(); - const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); - const 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); - } - this._processLineBuffer(data, stdbuffer, (line) => { - if (this.options.listeners && this.options.listeners.stdline) { - this.options.listeners.stdline(line); - } - }); - }); - } - const 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); - } - 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); - } - }); - }); - }); - } + + +var loader = __webpack_require__(457); +var dumper = __webpack_require__(685); + + +function deprecated(name) { + return function () { + throw new Error('Function ' + name + ' is deprecated and cannot be used.'); + }; } -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 += '\\'; - } - 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; -} -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'); - } - 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 = setTimeout(ExecState.HandleTimeout, this.delay, this); - } - } - _debug(message) { - this.emit('debug', message); - } - _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; - } - 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 / - 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 + + +module.exports.Type = __webpack_require__(945); +module.exports.Schema = __webpack_require__(733); +module.exports.FAILSAFE_SCHEMA = __webpack_require__(265); +module.exports.JSON_SCHEMA = __webpack_require__(720); +module.exports.CORE_SCHEMA = __webpack_require__(611); +module.exports.DEFAULT_SAFE_SCHEMA = __webpack_require__(723); +module.exports.DEFAULT_FULL_SCHEMA = __webpack_require__(910); +module.exports.load = loader.load; +module.exports.loadAll = loader.loadAll; +module.exports.safeLoad = loader.safeLoad; +module.exports.safeLoadAll = loader.safeLoadAll; +module.exports.dump = dumper.dump; +module.exports.safeDump = dumper.safeDump; +module.exports.YAMLException = __webpack_require__(556); + +// Deprecated schema names from JS-YAML 2.0.x +module.exports.MINIMAL_SCHEMA = __webpack_require__(265); +module.exports.SAFE_SCHEMA = __webpack_require__(723); +module.exports.DEFAULT_SCHEMA = __webpack_require__(910); + +// Deprecated functions from JS-YAML 1.x.x +module.exports.scan = deprecated('scan'); +module.exports.parse = deprecated('parse'); +module.exports.compose = deprecated('compose'); +module.exports.addConstructor = deprecated('addConstructor'); + /***/ }), - -/***/ 11: +/* 10 */, +/* 11 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -1025,101 +484,163 @@ exports.ASCIIAlphanumeric = /[0-9A-Za-z]/; //# sourceMappingURL=CodePoints.js.map /***/ }), +/* 12 */, +/* 13 */, +/* 14 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 15: -/***/ (function(__unusedmodule, exports) { +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Determines if the given number is an ASCII byte. - * - * @param byte - a byte - */ -function isASCIIByte(byte) { - /** - * An ASCII byte is a byte in the range 0x00 (NUL) to 0x7F (DEL), inclusive. - */ - return byte >= 0x00 && byte <= 0x7F; +const maxSatisfying = (versions, range, options) => { + let max = null + let maxSV = null + let rangeObj = null + try { + rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!max || maxSV.compare(v) === -1) { + // compare(max, v, true) + max = v + maxSV = new SemVer(max, options) + } + } + }) + return max } -exports.isASCIIByte = isASCIIByte; -//# sourceMappingURL=Byte.js.map +module.exports = maxSatisfying + /***/ }), +/* 15 */, +/* 16 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 16: -/***/ (function(module) { +const SemVer = __webpack_require__(65) +const compareBuild = (a, b, loose) => { + const versionA = new SemVer(a, loose) + const versionB = new SemVer(b, loose) + return versionA.compare(versionB) || versionA.compareBuild(versionB) +} +module.exports = compareBuild -module.exports = require("tls"); /***/ }), - -/***/ 18: +/* 17 */, +/* 18 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(918); +var util_1 = __webpack_require__(918); /** * Represents a mixin that extends child nodes that can have siblings * other than doctypes. This mixin is implemented by {@link Element} and * {@link CharacterData}. */ -class NonDocumentTypeChildNodeImpl { - /** @inheritdoc */ - get previousElementSibling() { - /** - * The previousElementSibling attribute’s getter must return the first - * preceding sibling that is an element, and null otherwise. - */ - let node = util_1.Cast.asNode(this)._previousSibling; - while (node) { - if (util_1.Guard.isElementNode(node)) - return node; - else - node = node._previousSibling; - } - return null; +var NonDocumentTypeChildNodeImpl = /** @class */ (function () { + function NonDocumentTypeChildNodeImpl() { } - /** @inheritdoc */ - get nextElementSibling() { - /** - * The nextElementSibling attribute’s getter must return the first - * following sibling that is an element, and null otherwise. - */ - let node = util_1.Cast.asNode(this)._nextSibling; - while (node) { - if (util_1.Guard.isElementNode(node)) - return node; - else - node = node._nextSibling; - } - return null; - } -} + Object.defineProperty(NonDocumentTypeChildNodeImpl.prototype, "previousElementSibling", { + /** @inheritdoc */ + get: function () { + /** + * The previousElementSibling attribute’s getter must return the first + * preceding sibling that is an element, and null otherwise. + */ + var node = util_1.Cast.asNode(this)._previousSibling; + while (node) { + if (util_1.Guard.isElementNode(node)) + return node; + else + node = node._previousSibling; + } + return null; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NonDocumentTypeChildNodeImpl.prototype, "nextElementSibling", { + /** @inheritdoc */ + get: function () { + /** + * The nextElementSibling attribute’s getter must return the first + * following sibling that is an element, and null otherwise. + */ + var node = util_1.Cast.asNode(this)._nextSibling; + while (node) { + if (util_1.Guard.isElementNode(node)) + return node; + else + node = node._nextSibling; + } + return null; + }, + enumerable: true, + configurable: true + }); + return NonDocumentTypeChildNodeImpl; +}()); exports.NonDocumentTypeChildNodeImpl = NonDocumentTypeChildNodeImpl; //# sourceMappingURL=NonDocumentTypeChildNodeImpl.js.map /***/ }), - -/***/ 22: +/* 19 */, +/* 20 */, +/* 21 */, +/* 22 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const DOMException_1 = __webpack_require__(35); -const util_1 = __webpack_require__(918); -const CreateAlgorithm_1 = __webpack_require__(86); -const TreeAlgorithm_1 = __webpack_require__(873); -const BoundaryPointAlgorithm_1 = __webpack_require__(350); -const CharacterDataAlgorithm_1 = __webpack_require__(27); -const NodeAlgorithm_1 = __webpack_require__(541); -const MutationAlgorithm_1 = __webpack_require__(479); -const TextAlgorithm_1 = __webpack_require__(154); +var interfaces_1 = __webpack_require__(970); +var DOMException_1 = __webpack_require__(35); +var util_1 = __webpack_require__(918); +var CreateAlgorithm_1 = __webpack_require__(86); +var TreeAlgorithm_1 = __webpack_require__(873); +var BoundaryPointAlgorithm_1 = __webpack_require__(350); +var CharacterDataAlgorithm_1 = __webpack_require__(27); +var NodeAlgorithm_1 = __webpack_require__(541); +var MutationAlgorithm_1 = __webpack_require__(479); +var TextAlgorithm_1 = __webpack_require__(154); /** * Determines if the node's start boundary point is at its end boundary * point. @@ -1174,8 +695,8 @@ function range_isPartiallyContained(node, range) { * ancestor of the live range’s start node but not its end node, * or vice versa. */ - const startCheck = TreeAlgorithm_1.tree_isAncestorOf(range._startNode, node, true); - const endCheck = TreeAlgorithm_1.tree_isAncestorOf(range._endNode, node, true); + var startCheck = TreeAlgorithm_1.tree_isAncestorOf(range._startNode, node, true); + var endCheck = TreeAlgorithm_1.tree_isAncestorOf(range._endNode, node, true); return (startCheck && !endCheck) || (!startCheck && endCheck); } exports.range_isPartiallyContained = range_isPartiallyContained; @@ -1203,7 +724,7 @@ function range_setTheStart(range, node, offset) { if (offset > TreeAlgorithm_1.tree_nodeLength(node)) { throw new DOMException_1.IndexSizeError(); } - const bp = [node, offset]; + var bp = [node, offset]; if (range_root(range) !== TreeAlgorithm_1.tree_rootNode(node) || BoundaryPointAlgorithm_1.boundaryPoint_position(bp, range._end) === interfaces_1.BoundaryPosition.After) { range._end = bp; @@ -1235,7 +756,7 @@ function range_setTheEnd(range, node, offset) { if (offset > TreeAlgorithm_1.tree_nodeLength(node)) { throw new DOMException_1.IndexSizeError(); } - const bp = [node, offset]; + var bp = [node, offset]; if (range_root(range) !== TreeAlgorithm_1.tree_rootNode(node) || BoundaryPointAlgorithm_1.boundaryPoint_position(bp, range._start) === interfaces_1.BoundaryPosition.Before) { range._start = bp; @@ -1254,7 +775,7 @@ function range_select(node, range) { * 1. Let parent be node’s parent. * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException. */ - const parent = node._parent; + var parent = node._parent; if (parent === null) throw new DOMException_1.InvalidNodeTypeError(); /** @@ -1262,7 +783,7 @@ function range_select(node, range) { * 4. Set range’s start to boundary point (parent, index). * 5. Set range’s end to boundary point (parent, index plus 1). */ - const index = TreeAlgorithm_1.tree_index(node); + var index = TreeAlgorithm_1.tree_index(node); range._start = [parent, index]; range._end = [parent, index + 1]; } @@ -1273,12 +794,13 @@ exports.range_select = range_select; * @param range - a range */ function range_extract(range) { + var e_1, _a, e_2, _b, e_3, _c; /** * 1. Let fragment be a new DocumentFragment node whose node document is * range’s start node’s node document. * 2. If range is collapsed, then return fragment. */ - const fragment = CreateAlgorithm_1.create_documentFragment(range._startNode._nodeDocument); + var fragment = CreateAlgorithm_1.create_documentFragment(range._startNode._nodeDocument); if (range_collapsed(range)) return fragment; /** @@ -1286,10 +808,10 @@ function range_extract(range) { * and original end offset be range’s start node, start offset, end node, * and end offset, respectively. */ - const originalStartNode = range._startNode; - const originalStartOffset = range._startOffset; - const originalEndNode = range._endNode; - const originalEndOffset = range._endOffset; + var originalStartNode = range._startNode; + var originalStartOffset = range._startOffset; + var originalEndNode = range._endNode; + var originalEndOffset = range._endOffset; /** * 4. If original start node is original end node, and they are a Text, * ProcessingInstruction, or Comment node: @@ -1305,7 +827,7 @@ function range_extract(range) { */ if (originalStartNode === originalEndNode && util_1.Guard.isCharacterDataNode(originalStartNode)) { - const clone = NodeAlgorithm_1.node_clone(originalStartNode); + var clone = NodeAlgorithm_1.node_clone(originalStartNode); clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset); MutationAlgorithm_1.mutation_append(clone, fragment); CharacterDataAlgorithm_1.characterData_replaceData(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset, ''); @@ -1316,7 +838,7 @@ function range_extract(range) { * 6. While common ancestor is not an inclusive ancestor of original end * node, set common ancestor to its own parent. */ - let commonAncestor = originalStartNode; + var commonAncestor = originalStartNode; while (!TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, commonAncestor, true)) { if (commonAncestor._parent === null) { throw new Error("Parent node is null."); @@ -1329,14 +851,24 @@ function range_extract(range) { * node, set first partially contained child to the first child of common * ancestor that is partially contained in range. */ - let firstPartiallyContainedChild = null; + var firstPartiallyContainedChild = null; if (!TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, originalStartNode, true)) { - for (const node of commonAncestor._children) { - if (range_isPartiallyContained(node, range)) { - firstPartiallyContainedChild = node; - break; + try { + for (var _d = __values(commonAncestor._children), _e = _d.next(); !_e.done; _e = _d.next()) { + var node = _e.value; + if (range_isPartiallyContained(node, range)) { + firstPartiallyContainedChild = node; + break; + } } } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_e && !_e.done && (_a = _d.return)) _a.call(_d); + } + finally { if (e_1) throw e_1.error; } + } } /** * 9. Let last partially contained child be null. @@ -1344,11 +876,11 @@ function range_extract(range) { * node, set last partially contained child to the last child of common * ancestor that is partially contained in range. */ - let lastPartiallyContainedChild = null; + var lastPartiallyContainedChild = null; if (!TreeAlgorithm_1.tree_isAncestorOf(originalStartNode, originalEndNode, true)) { - const children = [...commonAncestor._children]; - for (let i = children.length - 1; i > 0; i--) { - const node = children[i]; + var children = __spread(commonAncestor._children); + for (var i = children.length - 1; i > 0; i--) { + var node = children[i]; if (range_isPartiallyContained(node, range)) { lastPartiallyContainedChild = node; break; @@ -1361,17 +893,27 @@ function range_extract(range) { * 12. If any member of contained children is a doctype, then throw a * "HierarchyRequestError" DOMException. */ - const containedChildren = []; - for (const child of commonAncestor._children) { - if (range_isContained(child, range)) { - if (util_1.Guard.isDocumentTypeNode(child)) { - throw new DOMException_1.HierarchyRequestError(); + var containedChildren = []; + try { + for (var _f = __values(commonAncestor._children), _g = _f.next(); !_g.done; _g = _f.next()) { + var child = _g.value; + if (range_isContained(child, range)) { + if (util_1.Guard.isDocumentTypeNode(child)) { + throw new DOMException_1.HierarchyRequestError(); + } + containedChildren.push(child); } - containedChildren.push(child); } } - let newNode; - let newOffset; + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_g && !_g.done && (_b = _f.return)) _b.call(_f); + } + finally { if (e_2) throw e_2.error; } + } + var newNode; + var newOffset; if (TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, originalStartNode, true)) { /** * 13. If original start node is an inclusive ancestor of original end node, @@ -1390,7 +932,7 @@ function range_extract(range) { * 14.3. Set new node to the parent of reference node, and new offset to * one plus reference node’s index. */ - let referenceNode = originalStartNode; + var referenceNode = originalStartNode; while (referenceNode._parent !== null && !TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, referenceNode._parent)) { referenceNode = referenceNode._parent; @@ -1420,7 +962,7 @@ function range_extract(range) { * start offset, count original start node’s length minus original start * offset, and data the empty string. */ - const clone = NodeAlgorithm_1.node_clone(originalStartNode); + var clone = NodeAlgorithm_1.node_clone(originalStartNode); clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalStartNode, originalStartOffset, TreeAlgorithm_1.tree_nodeLength(originalStartNode) - originalStartOffset); MutationAlgorithm_1.mutation_append(clone, fragment); CharacterDataAlgorithm_1.characterData_replaceData(originalStartNode, originalStartOffset, TreeAlgorithm_1.tree_nodeLength(originalStartNode) - originalStartOffset, ''); @@ -1436,18 +978,28 @@ function range_extract(range) { * 16.4. Let subfragment be the result of extracting subrange. * 16.5. Append subfragment to clone. */ - const clone = NodeAlgorithm_1.node_clone(firstPartiallyContainedChild); + var clone = NodeAlgorithm_1.node_clone(firstPartiallyContainedChild); MutationAlgorithm_1.mutation_append(clone, fragment); - const subrange = CreateAlgorithm_1.create_range([originalStartNode, originalStartOffset], [firstPartiallyContainedChild, TreeAlgorithm_1.tree_nodeLength(firstPartiallyContainedChild)]); - const subfragment = range_extract(subrange); + var subrange = CreateAlgorithm_1.create_range([originalStartNode, originalStartOffset], [firstPartiallyContainedChild, TreeAlgorithm_1.tree_nodeLength(firstPartiallyContainedChild)]); + var subfragment = range_extract(subrange); MutationAlgorithm_1.mutation_append(subfragment, clone); } - /** - * 17. For each contained child in contained children, append contained - * child to fragment. - */ - for (const child of containedChildren) { - MutationAlgorithm_1.mutation_append(child, fragment); + try { + /** + * 17. For each contained child in contained children, append contained + * child to fragment. + */ + for (var containedChildren_1 = __values(containedChildren), containedChildren_1_1 = containedChildren_1.next(); !containedChildren_1_1.done; containedChildren_1_1 = containedChildren_1.next()) { + var child = containedChildren_1_1.value; + MutationAlgorithm_1.mutation_append(child, fragment); + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (containedChildren_1_1 && !containedChildren_1_1.done && (_c = containedChildren_1.return)) _c.call(containedChildren_1); + } + finally { if (e_3) throw e_3.error; } } if (util_1.Guard.isCharacterDataNode(lastPartiallyContainedChild)) { /** @@ -1460,7 +1012,7 @@ function range_extract(range) { * 18.4. Replace data with node original end node, offset 0, count * original end offset, and data the empty string. */ - const clone = NodeAlgorithm_1.node_clone(originalEndNode); + var clone = NodeAlgorithm_1.node_clone(originalEndNode); clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalEndNode, 0, originalEndOffset); MutationAlgorithm_1.mutation_append(clone, fragment); CharacterDataAlgorithm_1.characterData_replaceData(originalEndNode, 0, originalEndOffset, ''); @@ -1476,10 +1028,10 @@ function range_extract(range) { * 19.4. Let subfragment be the result of extracting subrange. * 19.5. Append subfragment to clone. */ - const clone = NodeAlgorithm_1.node_clone(lastPartiallyContainedChild); + var clone = NodeAlgorithm_1.node_clone(lastPartiallyContainedChild); MutationAlgorithm_1.mutation_append(clone, fragment); - const subrange = CreateAlgorithm_1.create_range([lastPartiallyContainedChild, 0], [originalEndNode, originalEndOffset]); - const subfragment = range_extract(subrange); + var subrange = CreateAlgorithm_1.create_range([lastPartiallyContainedChild, 0], [originalEndNode, originalEndOffset]); + var subfragment = range_extract(subrange); MutationAlgorithm_1.mutation_append(subfragment, clone); } /** @@ -1499,12 +1051,13 @@ exports.range_extract = range_extract; * @param range - a range */ function range_cloneTheContents(range) { + var e_4, _a, e_5, _b, e_6, _c; /** * 1. Let fragment be a new DocumentFragment node whose node document * is range’s start node’s node document. * 2. If range is collapsed, then return fragment. */ - const fragment = CreateAlgorithm_1.create_documentFragment(range._startNode._nodeDocument); + var fragment = CreateAlgorithm_1.create_documentFragment(range._startNode._nodeDocument); if (range_collapsed(range)) return fragment; /** @@ -1520,13 +1073,13 @@ function range_cloneTheContents(range) { * 4.3. Append clone to fragment. * 4.5. Return fragment. */ - const originalStartNode = range._startNode; - const originalStartOffset = range._startOffset; - const originalEndNode = range._endNode; - const originalEndOffset = range._endOffset; + var originalStartNode = range._startNode; + var originalStartOffset = range._startOffset; + var originalEndNode = range._endNode; + var originalEndOffset = range._endOffset; if (originalStartNode === originalEndNode && util_1.Guard.isCharacterDataNode(originalStartNode)) { - const clone = NodeAlgorithm_1.node_clone(originalStartNode); + var clone = NodeAlgorithm_1.node_clone(originalStartNode); clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset); MutationAlgorithm_1.mutation_append(clone, fragment); } @@ -1535,7 +1088,7 @@ function range_cloneTheContents(range) { * 6. While common ancestor is not an inclusive ancestor of original end * node, set common ancestor to its own parent. */ - let commonAncestor = originalStartNode; + var commonAncestor = originalStartNode; while (!TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, commonAncestor, true)) { if (commonAncestor._parent === null) { throw new Error("Parent node is null."); @@ -1548,14 +1101,24 @@ function range_cloneTheContents(range) { * node, set first partially contained child to the first child of common * ancestor that is partially contained in range. */ - let firstPartiallyContainedChild = null; + var firstPartiallyContainedChild = null; if (!TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, originalStartNode, true)) { - for (const node of commonAncestor._children) { - if (range_isPartiallyContained(node, range)) { - firstPartiallyContainedChild = node; - break; + try { + for (var _d = __values(commonAncestor._children), _e = _d.next(); !_e.done; _e = _d.next()) { + var node = _e.value; + if (range_isPartiallyContained(node, range)) { + firstPartiallyContainedChild = node; + break; + } } } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (_e && !_e.done && (_a = _d.return)) _a.call(_d); + } + finally { if (e_4) throw e_4.error; } + } } /** * 9. Let last partially contained child be null. @@ -1563,11 +1126,11 @@ function range_cloneTheContents(range) { * node, set last partially contained child to the last child of common * ancestor that is partially contained in range. */ - let lastPartiallyContainedChild = null; + var lastPartiallyContainedChild = null; if (!TreeAlgorithm_1.tree_isAncestorOf(originalStartNode, originalEndNode, true)) { - const children = [...commonAncestor._children]; - for (let i = children.length - 1; i > 0; i--) { - const node = children[i]; + var children = __spread(commonAncestor._children); + for (var i = children.length - 1; i > 0; i--) { + var node = children[i]; if (range_isPartiallyContained(node, range)) { lastPartiallyContainedChild = node; break; @@ -1580,15 +1143,25 @@ function range_cloneTheContents(range) { * 12. If any member of contained children is a doctype, then throw a * "HierarchyRequestError" DOMException. */ - const containedChildren = []; - for (const child of commonAncestor._children) { - if (range_isContained(child, range)) { - if (util_1.Guard.isDocumentTypeNode(child)) { - throw new DOMException_1.HierarchyRequestError(); + var containedChildren = []; + try { + for (var _f = __values(commonAncestor._children), _g = _f.next(); !_g.done; _g = _f.next()) { + var child = _g.value; + if (range_isContained(child, range)) { + if (util_1.Guard.isDocumentTypeNode(child)) { + throw new DOMException_1.HierarchyRequestError(); + } + containedChildren.push(child); } - containedChildren.push(child); } } + catch (e_5_1) { e_5 = { error: e_5_1 }; } + finally { + try { + if (_g && !_g.done && (_b = _f.return)) _b.call(_f); + } + finally { if (e_5) throw e_5.error; } + } if (util_1.Guard.isCharacterDataNode(firstPartiallyContainedChild)) { /** * 13. If first partially contained child is a Text, ProcessingInstruction, @@ -1599,7 +1172,7 @@ function range_cloneTheContents(range) { * original start node’s length minus original start offset. * 13.3. Append clone to fragment. */ - const clone = NodeAlgorithm_1.node_clone(originalStartNode); + var clone = NodeAlgorithm_1.node_clone(originalStartNode); clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalStartNode, originalStartOffset, TreeAlgorithm_1.tree_nodeLength(originalStartNode) - originalStartOffset); MutationAlgorithm_1.mutation_append(clone, fragment); } @@ -1615,22 +1188,32 @@ function range_cloneTheContents(range) { * subrange. * 14.5. Append subfragment to clone. */ - const clone = NodeAlgorithm_1.node_clone(firstPartiallyContainedChild); + var clone = NodeAlgorithm_1.node_clone(firstPartiallyContainedChild); MutationAlgorithm_1.mutation_append(clone, fragment); - const subrange = CreateAlgorithm_1.create_range([originalStartNode, originalStartOffset], [firstPartiallyContainedChild, TreeAlgorithm_1.tree_nodeLength(firstPartiallyContainedChild)]); - const subfragment = range_cloneTheContents(subrange); + var subrange = CreateAlgorithm_1.create_range([originalStartNode, originalStartOffset], [firstPartiallyContainedChild, TreeAlgorithm_1.tree_nodeLength(firstPartiallyContainedChild)]); + var subfragment = range_cloneTheContents(subrange); MutationAlgorithm_1.mutation_append(subfragment, clone); } - /** - * 15. For each contained child in contained children, append contained - * child to fragment. - * 15.1. Let clone be a clone of contained child with the clone children - * flag set. - * 15.2. Append clone to fragment. - */ - for (const child of containedChildren) { - const clone = NodeAlgorithm_1.node_clone(child); - MutationAlgorithm_1.mutation_append(clone, fragment); + try { + /** + * 15. For each contained child in contained children, append contained + * child to fragment. + * 15.1. Let clone be a clone of contained child with the clone children + * flag set. + * 15.2. Append clone to fragment. + */ + for (var containedChildren_2 = __values(containedChildren), containedChildren_2_1 = containedChildren_2.next(); !containedChildren_2_1.done; containedChildren_2_1 = containedChildren_2.next()) { + var child = containedChildren_2_1.value; + var clone = NodeAlgorithm_1.node_clone(child); + MutationAlgorithm_1.mutation_append(clone, fragment); + } + } + catch (e_6_1) { e_6 = { error: e_6_1 }; } + finally { + try { + if (containedChildren_2_1 && !containedChildren_2_1.done && (_c = containedChildren_2.return)) _c.call(containedChildren_2); + } + finally { if (e_6) throw e_6.error; } } if (util_1.Guard.isCharacterDataNode(lastPartiallyContainedChild)) { /** @@ -1641,7 +1224,7 @@ function range_cloneTheContents(range) { * node original end node, offset 0, and count original end offset. * 16.3. Append clone to fragment. */ - const clone = NodeAlgorithm_1.node_clone(originalEndNode); + var clone = NodeAlgorithm_1.node_clone(originalEndNode); clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalEndNode, 0, originalEndOffset); MutationAlgorithm_1.mutation_append(clone, fragment); } @@ -1656,10 +1239,10 @@ function range_cloneTheContents(range) { * 17.4. Let subfragment be the result of cloning the contents of subrange. * 17.5. Append subfragment to clone. */ - const clone = NodeAlgorithm_1.node_clone(lastPartiallyContainedChild); + var clone = NodeAlgorithm_1.node_clone(lastPartiallyContainedChild); fragment.append(clone); - const subrange = CreateAlgorithm_1.create_range([lastPartiallyContainedChild, 0], [originalEndNode, originalEndOffset]); - const subfragment = range_extract(subrange); + var subrange = CreateAlgorithm_1.create_range([lastPartiallyContainedChild, 0], [originalEndNode, originalEndOffset]); + var subfragment = range_extract(subrange); MutationAlgorithm_1.mutation_append(subfragment, clone); } /** @@ -1675,6 +1258,7 @@ exports.range_cloneTheContents = range_cloneTheContents; * @param range - a range */ function range_insert(node, range) { + var e_7, _a; /** * 1. If range’s start node is a ProcessingInstruction or Comment node, is a * Text node whose parent is null, or is node, then throw a @@ -1693,25 +1277,35 @@ function range_insert(node, range) { * 4. Otherwise, set referenceNode to the child of start node whose index is * start offset, and null if there is no such child. */ - let referenceNode = null; + var referenceNode = null; if (util_1.Guard.isTextNode(range._startNode)) { referenceNode = range._startNode; } else { - let index = 0; - for (const child of range._startNode._children) { - if (index === range._startOffset) { - referenceNode = child; - break; + var index = 0; + try { + for (var _b = __values(range._startNode._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var child = _c.value; + if (index === range._startOffset) { + referenceNode = child; + break; + } + index++; } - index++; + } + catch (e_7_1) { e_7 = { error: e_7_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_7) throw e_7.error; } } } /** * 5. Let parent be range’s start node if referenceNode is null, and * referenceNode’s parent otherwise. */ - let parent; + var parent; if (referenceNode === null) { parent = range._startNode; } @@ -1748,7 +1342,7 @@ function range_insert(node, range) { * 10. Let newOffset be parent’s length if referenceNode is null, and * referenceNode’s index otherwise. */ - let newOffset = (referenceNode === null ? + var newOffset = (referenceNode === null ? TreeAlgorithm_1.tree_nodeLength(parent) : TreeAlgorithm_1.tree_index(referenceNode)); /** * 11. Increase newOffset by node’s length if node is a DocumentFragment @@ -1778,12 +1372,13 @@ exports.range_insert = range_insert; * @param range - a range */ function range_getContainedNodes(range) { - return { - [Symbol.iterator]: () => { - const container = range.commonAncestorContainer; - let currentNode = TreeAlgorithm_1.tree_getFirstDescendantNode(container); + var _a; + return _a = {}, + _a[Symbol.iterator] = function () { + var container = range.commonAncestorContainer; + var currentNode = TreeAlgorithm_1.tree_getFirstDescendantNode(container); return { - next: () => { + next: function () { while (currentNode && !range_isContained(currentNode, range)) { currentNode = TreeAlgorithm_1.tree_getNextDescendantNode(container, currentNode); } @@ -1791,14 +1386,14 @@ function range_getContainedNodes(range) { return { done: true, value: null }; } else { - const result = { done: false, value: currentNode }; + var result = { done: false, value: currentNode }; currentNode = TreeAlgorithm_1.tree_getNextDescendantNode(container, currentNode); return result; } } }; - } - }; + }, + _a; } exports.range_getContainedNodes = range_getContainedNodes; /** @@ -1807,12 +1402,13 @@ exports.range_getContainedNodes = range_getContainedNodes; * @param range - a range */ function range_getPartiallyContainedNodes(range) { - return { - [Symbol.iterator]: () => { - const container = range.commonAncestorContainer; - let currentNode = TreeAlgorithm_1.tree_getFirstDescendantNode(container); + var _a; + return _a = {}, + _a[Symbol.iterator] = function () { + var container = range.commonAncestorContainer; + var currentNode = TreeAlgorithm_1.tree_getFirstDescendantNode(container); return { - next: () => { + next: function () { while (currentNode && !range_isPartiallyContained(currentNode, range)) { currentNode = TreeAlgorithm_1.tree_getNextDescendantNode(container, currentNode); } @@ -1820,21 +1416,20 @@ function range_getPartiallyContainedNodes(range) { return { done: true, value: null }; } else { - const result = { done: false, value: currentNode }; + var result = { done: false, value: currentNode }; currentNode = TreeAlgorithm_1.tree_getNextDescendantNode(container, currentNode); return result; } } }; - } - }; + }, + _a; } exports.range_getPartiallyContainedNodes = range_getPartiallyContainedNodes; //# sourceMappingURL=RangeAlgorithm.js.map /***/ }), - -/***/ 23: +/* 23 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; @@ -1847,46 +1442,90 @@ var __importStar = (this && this.__importStar) || function (mod) { return result; }; Object.defineProperty(exports, "__esModule", { value: true }); -const base64 = __importStar(__webpack_require__(763)); +var base64 = __importStar(__webpack_require__(763)); exports.base64 = base64; -const byte = __importStar(__webpack_require__(782)); +var byte = __importStar(__webpack_require__(782)); exports.byte = byte; -const byteSequence = __importStar(__webpack_require__(263)); +var byteSequence = __importStar(__webpack_require__(263)); exports.byteSequence = byteSequence; -const codePoint = __importStar(__webpack_require__(11)); +var codePoint = __importStar(__webpack_require__(11)); exports.codePoint = codePoint; -const json = __importStar(__webpack_require__(522)); +var json = __importStar(__webpack_require__(522)); exports.json = json; -const list = __importStar(__webpack_require__(657)); +var list = __importStar(__webpack_require__(657)); exports.list = list; -const map = __importStar(__webpack_require__(279)); +var map = __importStar(__webpack_require__(279)); exports.map = map; -const namespace = __importStar(__webpack_require__(916)); +var namespace = __importStar(__webpack_require__(916)); exports.namespace = namespace; -const queue = __importStar(__webpack_require__(501)); +var queue = __importStar(__webpack_require__(501)); exports.queue = queue; -const set = __importStar(__webpack_require__(496)); +var set = __importStar(__webpack_require__(496)); exports.set = set; -const stack = __importStar(__webpack_require__(134)); +var stack = __importStar(__webpack_require__(134)); exports.stack = stack; -const string = __importStar(__webpack_require__(97)); +var string = __importStar(__webpack_require__(97)); exports.string = string; //# sourceMappingURL=index.js.map /***/ }), - -/***/ 27: +/* 24 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const util_1 = __webpack_require__(918); -const DOMException_1 = __webpack_require__(35); -const TreeAlgorithm_1 = __webpack_require__(873); -const MutationObserverAlgorithm_1 = __webpack_require__(151); -const DOMAlgorithm_1 = __webpack_require__(304); +exports.getJavaDistribution = void 0; +const installer_1 = __webpack_require__(584); +const installer_2 = __webpack_require__(144); +const installer_3 = __webpack_require__(393); +var JavaDistribution; +(function (JavaDistribution) { + JavaDistribution["Adopt"] = "adopt"; + JavaDistribution["Zulu"] = "zulu"; + JavaDistribution["JdkFile"] = "jdkfile"; +})(JavaDistribution || (JavaDistribution = {})); +function getJavaDistribution(distributionName, installerOptions, jdkFile) { + switch (distributionName) { + case JavaDistribution.JdkFile: + return new installer_2.LocalDistribution(installerOptions, jdkFile); + case JavaDistribution.Adopt: + return new installer_1.AdoptDistribution(installerOptions); + case JavaDistribution.Zulu: + return new installer_3.ZuluDistribution(installerOptions); + default: + return null; + } +} +exports.getJavaDistribution = getJavaDistribution; + + +/***/ }), +/* 25 */, +/* 26 */, +/* 27 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var DOMImpl_1 = __webpack_require__(648); +var util_1 = __webpack_require__(918); +var DOMException_1 = __webpack_require__(35); +var TreeAlgorithm_1 = __webpack_require__(873); +var MutationObserverAlgorithm_1 = __webpack_require__(151); +var DOMAlgorithm_1 = __webpack_require__(304); /** * Replaces character data. * @@ -1896,6 +1535,7 @@ const DOMAlgorithm_1 = __webpack_require__(304); * @param data - new data */ function characterData_replaceData(node, offset, count, data) { + var e_1, _a; /** * 1. Let length be node’s length. * 2. If offset is greater than length, then throw an "IndexSizeError" @@ -1903,9 +1543,9 @@ function characterData_replaceData(node, offset, count, data) { * 3. If offset plus count is greater than length, then set count to length * minus offset. */ - const length = TreeAlgorithm_1.tree_nodeLength(node); + var length = TreeAlgorithm_1.tree_nodeLength(node); if (offset > length) { - throw new DOMException_1.IndexSizeError(`Offset exceeds character data length. Offset: ${offset}, Length: ${length}, Node is ${node.nodeName}.`); + throw new DOMException_1.IndexSizeError("Offset exceeds character data length. Offset: " + offset + ", Length: " + length + ", Node is " + node.nodeName + "."); } if (offset + count > length) { count = length - offset; @@ -1914,7 +1554,7 @@ function characterData_replaceData(node, offset, count, data) { * 4. Queue a mutation record of "characterData" for node with null, null, * node’s data, « », « », null, and null. */ - if (dom_1.dom.features.mutationObservers) { + if (DOMImpl_1.dom.features.mutationObservers) { MutationObserverAlgorithm_1.observer_queueMutationRecord("characterData", node, null, null, node._data, [], [], null, null); } /** @@ -1923,42 +1563,52 @@ function characterData_replaceData(node, offset, count, data) { * 7. Starting from delete offset code units, remove count code units from * node’s data. */ - const newData = node._data.substring(0, offset) + data + + var newData = node._data.substring(0, offset) + data + node._data.substring(offset + count); node._data = newData; - /** - * 8. For each live range whose start node is node and start offset is - * greater than offset but less than or equal to offset plus count, set its - * start offset to offset. - * 9. For each live range whose end node is node and end offset is greater - * than offset but less than or equal to offset plus count, set its end - * offset to offset. - * 10. For each live range whose start node is node and start offset is - * greater than offset plus count, increase its start offset by data’s - * length and decrease it by count. - * 11. For each live range whose end node is node and end offset is greater - * than offset plus count, increase its end offset by data’s length and - * decrease it by count. - */ - for (const range of dom_1.dom.rangeList) { - if (range._start[0] === node && range._start[1] > offset && range._start[1] <= offset + count) { - range._start[1] = offset; + try { + /** + * 8. For each live range whose start node is node and start offset is + * greater than offset but less than or equal to offset plus count, set its + * start offset to offset. + * 9. For each live range whose end node is node and end offset is greater + * than offset but less than or equal to offset plus count, set its end + * offset to offset. + * 10. For each live range whose start node is node and start offset is + * greater than offset plus count, increase its start offset by data’s + * length and decrease it by count. + * 11. For each live range whose end node is node and end offset is greater + * than offset plus count, increase its end offset by data’s length and + * decrease it by count. + */ + for (var _b = __values(DOMImpl_1.dom.rangeList), _c = _b.next(); !_c.done; _c = _b.next()) { + var range = _c.value; + if (range._start[0] === node && range._start[1] > offset && range._start[1] <= offset + count) { + range._start[1] = offset; + } + if (range._end[0] === node && range._end[1] > offset && range._end[1] <= offset + count) { + range._end[1] = offset; + } + if (range._start[0] === node && range._start[1] > offset + count) { + range._start[1] += data.length - count; + } + if (range._end[0] === node && range._end[1] > offset + count) { + range._end[1] += data.length - count; + } } - if (range._end[0] === node && range._end[1] > offset && range._end[1] <= offset + count) { - range._end[1] = offset; - } - if (range._start[0] === node && range._start[1] > offset + count) { - range._start[1] += data.length - count; - } - if (range._end[0] === node && range._end[1] > offset + count) { - range._end[1] += data.length - count; + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); } + finally { if (e_1) throw e_1.error; } } /** * 12. If node is a Text node and its parent is not null, run the child * text content change steps for node’s parent. */ - if (dom_1.dom.features.steps) { + if (DOMImpl_1.dom.features.steps) { if (util_1.Guard.isTextNode(node) && node._parent !== null) { DOMAlgorithm_1.dom_runChildTextContentChangeSteps(node._parent); } @@ -1984,9 +1634,9 @@ function characterData_substringData(node, offset, count) { * 4. Return a string whose value is the code units from the offsetth code * unit to the offset+countth code unit in node’s data. */ - const length = TreeAlgorithm_1.tree_nodeLength(node); + var length = TreeAlgorithm_1.tree_nodeLength(node); if (offset > length) { - throw new DOMException_1.IndexSizeError(`Offset exceeds character data length. Offset: ${offset}, Length: ${length}, Node is ${node.nodeName}.`); + throw new DOMException_1.IndexSizeError("Offset exceeds character data length. Offset: " + offset + ", Length: " + length + ", Node is " + node.nodeName + "."); } if (offset + count > length) { return node._data.substr(offset); @@ -1999,23 +1649,138 @@ exports.characterData_substringData = characterData_substringData; //# sourceMappingURL=CharacterDataAlgorithm.js.map /***/ }), +/* 28 */, +/* 29 */, +/* 30 */, +/* 31 */ +/***/ (function(module, exports, __webpack_require__) { -/***/ 33: +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const semver = __importStar(__webpack_require__(550)); +const core_1 = __webpack_require__(470); +// needs to be require for core node modules to be mocked +/* eslint @typescript-eslint/no-require-imports: 0 */ +const os = __webpack_require__(87); +const cp = __webpack_require__(129); +const fs = __webpack_require__(747); +function _findMatch(versionSpec, stable, candidates, archFilter) { + return __awaiter(this, void 0, void 0, function* () { + const platFilter = os.platform(); + let result; + let match; + let file; + for (const candidate of candidates) { + const version = candidate.version; + core_1.debug(`check ${version} satisfies ${versionSpec}`); + if (semver.satisfies(version, versionSpec) && + (!stable || candidate.stable === stable)) { + file = candidate.files.find(item => { + core_1.debug(`${item.arch}===${archFilter} && ${item.platform}===${platFilter}`); + let chk = item.arch === archFilter && item.platform === platFilter; + if (chk && item.platform_version) { + const osVersion = module.exports._getOsVersion(); + if (osVersion === item.platform_version) { + chk = true; + } + else { + chk = semver.satisfies(osVersion, item.platform_version); + } + } + return chk; + }); + if (file) { + core_1.debug(`matched ${candidate.version}`); + match = candidate; + break; + } + } + } + if (match && file) { + // clone since we're mutating the file list to be only the file that matches + result = Object.assign({}, match); + result.files = [file]; + } + return result; + }); +} +exports._findMatch = _findMatch; +function _getOsVersion() { + // TODO: add windows and other linux, arm variants + // right now filtering on version is only an ubuntu and macos scenario for tools we build for hosted (python) + const plat = os.platform(); + let version = ''; + if (plat === 'darwin') { + version = cp.execSync('sw_vers -productVersion').toString(); + } + else if (plat === 'linux') { + // lsb_release process not in some containers, readfile + // Run cat /etc/lsb-release + // DISTRIB_ID=Ubuntu + // DISTRIB_RELEASE=18.04 + // DISTRIB_CODENAME=bionic + // DISTRIB_DESCRIPTION="Ubuntu 18.04.4 LTS" + const lsbContents = module.exports._readLinuxVersionFile(); + if (lsbContents) { + const lines = lsbContents.split('\n'); + for (const line of lines) { + const parts = line.split('='); + if (parts.length === 2 && parts[0].trim() === 'DISTRIB_RELEASE') { + version = parts[1].trim(); + break; + } + } + } + } + return version; +} +exports._getOsVersion = _getOsVersion; +function _readLinuxVersionFile() { + const lsbFile = '/etc/lsb-release'; + let contents = ''; + if (fs.existsSync(lsbFile)) { + contents = fs.readFileSync(lsbFile).toString(); + } + return contents; +} +exports._readLinuxVersionFile = _readLinuxVersionFile; +//# sourceMappingURL=manifest.js.map + +/***/ }), +/* 32 */, +/* 33 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const infra_1 = __webpack_require__(23); -const util_1 = __webpack_require__(918); -const DOMException_1 = __webpack_require__(35); -const CreateAlgorithm_1 = __webpack_require__(86); -const CustomElementAlgorithm_1 = __webpack_require__(344); -const MutationObserverAlgorithm_1 = __webpack_require__(151); -const DOMAlgorithm_1 = __webpack_require__(304); -const MutationAlgorithm_1 = __webpack_require__(479); -const DocumentAlgorithm_1 = __webpack_require__(493); +var DOMImpl_1 = __webpack_require__(648); +var infra_1 = __webpack_require__(23); +var util_1 = __webpack_require__(918); +var DOMException_1 = __webpack_require__(35); +var CreateAlgorithm_1 = __webpack_require__(86); +var CustomElementAlgorithm_1 = __webpack_require__(344); +var MutationObserverAlgorithm_1 = __webpack_require__(151); +var DOMAlgorithm_1 = __webpack_require__(304); +var MutationAlgorithm_1 = __webpack_require__(479); +var DocumentAlgorithm_1 = __webpack_require__(493); /** * Determines whether the element's attribute list contains the given * attribute. @@ -2042,7 +1807,7 @@ function element_change(attribute, element, value) { * 1. Queue an attribute mutation record for element with attribute’s * local name, attribute’s namespace, and attribute’s value. */ - if (dom_1.dom.features.mutationObservers) { + if (DOMImpl_1.dom.features.mutationObservers) { MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord(element, attribute._localName, attribute._namespace, attribute._value); } /** @@ -2051,7 +1816,7 @@ function element_change(attribute, element, value) { * list containing attribute’s local name, attribute’s value, value, and * attribute’s namespace. */ - if (dom_1.dom.features.customElements) { + if (DOMImpl_1.dom.features.customElements) { if (util_1.Guard.isCustomElementNode(element)) { CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(element, "attributeChangedCallback", [attribute._localName, attribute._value, value, attribute._namespace]); } @@ -2061,7 +1826,7 @@ function element_change(attribute, element, value) { * attribute’s value, value, and attribute’s namespace. * 4. Set attribute’s value to value. */ - if (dom_1.dom.features.steps) { + if (DOMImpl_1.dom.features.steps) { DOMAlgorithm_1.dom_runAttributeChangeSteps(element, attribute._localName, attribute._value, value, attribute._namespace); } attribute._value = value; @@ -2078,7 +1843,7 @@ function element_append(attribute, element) { * 1. Queue an attribute mutation record for element with attribute’s * local name, attribute’s namespace, and null. */ - if (dom_1.dom.features.mutationObservers) { + if (DOMImpl_1.dom.features.mutationObservers) { MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord(element, attribute._localName, attribute._namespace, null); } /** @@ -2087,7 +1852,7 @@ function element_append(attribute, element) { * list containing attribute’s local name, null, attribute’s value, and * attribute’s namespace. */ - if (dom_1.dom.features.customElements) { + if (DOMImpl_1.dom.features.customElements) { if (util_1.Guard.isCustomElementNode(element)) { CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(element, "attributeChangedCallback", [attribute._localName, null, attribute._value, attribute._namespace]); } @@ -2096,7 +1861,7 @@ function element_append(attribute, element) { * 3. Run the attribute change steps with element, attribute’s local name, * null, attribute’s value, and attribute’s namespace. */ - if (dom_1.dom.features.steps) { + if (DOMImpl_1.dom.features.steps) { DOMAlgorithm_1.dom_runAttributeChangeSteps(element, attribute._localName, null, attribute._value, attribute._namespace); } /** @@ -2123,7 +1888,7 @@ function element_remove(attribute, element) { * 1. Queue an attribute mutation record for element with attribute’s * local name, attribute’s namespace, and attribute’s value. */ - if (dom_1.dom.features.mutationObservers) { + if (DOMImpl_1.dom.features.mutationObservers) { MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord(element, attribute._localName, attribute._namespace, attribute._value); } /** @@ -2132,7 +1897,7 @@ function element_remove(attribute, element) { * list containing attribute’s local name, attribute’s value, null, * and attribute’s namespace. */ - if (dom_1.dom.features.customElements) { + if (DOMImpl_1.dom.features.customElements) { if (util_1.Guard.isCustomElementNode(element)) { CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(element, "attributeChangedCallback", [attribute._localName, attribute._value, null, attribute._namespace]); } @@ -2141,14 +1906,14 @@ function element_remove(attribute, element) { * 3. Run the attribute change steps with element, attribute’s local name, * attribute’s value, null, and attribute’s namespace. */ - if (dom_1.dom.features.steps) { + if (DOMImpl_1.dom.features.steps) { DOMAlgorithm_1.dom_runAttributeChangeSteps(element, attribute._localName, attribute._value, null, attribute._namespace); } /** * 3. Remove attribute from element’s attribute list. * 5. Set attribute’s element to null. */ - const index = element._attributeList._asArray().indexOf(attribute); + var index = element._attributeList._asArray().indexOf(attribute); element._attributeList._asArray().splice(index, 1); attribute._element = null; } @@ -2165,7 +1930,7 @@ function element_replace(oldAttr, newAttr, element) { * 1. Queue an attribute mutation record for element with oldAttr’s * local name, oldAttr’s namespace, and oldAttr’s value. */ - if (dom_1.dom.features.mutationObservers) { + if (DOMImpl_1.dom.features.mutationObservers) { MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord(element, oldAttr._localName, oldAttr._namespace, oldAttr._value); } /** @@ -2174,7 +1939,7 @@ function element_replace(oldAttr, newAttr, element) { * list containing oldAttr’s local name, oldAttr’s value, newAttr’s value, * and oldAttr’s namespace. */ - if (dom_1.dom.features.customElements) { + if (DOMImpl_1.dom.features.customElements) { if (util_1.Guard.isCustomElementNode(element)) { CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(element, "attributeChangedCallback", [oldAttr._localName, oldAttr._value, newAttr._value, oldAttr._namespace]); } @@ -2183,7 +1948,7 @@ function element_replace(oldAttr, newAttr, element) { * 3. Run the attribute change steps with element, oldAttr’s local name, * oldAttr’s value, newAttr’s value, and oldAttr’s namespace. */ - if (dom_1.dom.features.steps) { + if (DOMImpl_1.dom.features.steps) { DOMAlgorithm_1.dom_runAttributeChangeSteps(element, oldAttr._localName, oldAttr._value, newAttr._value, oldAttr._namespace); } /** @@ -2191,7 +1956,7 @@ function element_replace(oldAttr, newAttr, element) { * 5. Set oldAttr’s element to null. * 6. Set newAttr’s element to element. */ - const index = element._attributeList._asArray().indexOf(oldAttr); + var index = element._attributeList._asArray().indexOf(oldAttr); if (index !== -1) { element._attributeList._asArray()[index] = newAttr; } @@ -2220,7 +1985,7 @@ function element_getAnAttributeByName(qualifiedName, element) { if (element._namespace === infra_1.namespace.HTML && element._nodeDocument._type === "html") { qualifiedName = qualifiedName.toLowerCase(); } - return element._attributeList._asArray().find(attr => attr._qualifiedName === qualifiedName) || null; + return element._attributeList._asArray().find(function (attr) { return attr._qualifiedName === qualifiedName; }) || null; } exports.element_getAnAttributeByName = element_getAnAttributeByName; /** @@ -2237,8 +2002,8 @@ function element_getAnAttributeByNamespaceAndLocalName(namespace, localName, ele * 2. Return the attribute in element’s attribute list whose namespace is * namespace and local name is localName, if any, and null otherwise. */ - const ns = namespace || null; - return element._attributeList._asArray().find(attr => attr._namespace === ns && attr._localName === localName) || null; + var ns = namespace || null; + return element._attributeList._asArray().find(function (attr) { return attr._namespace === ns && attr._localName === localName; }) || null; } exports.element_getAnAttributeByNamespaceAndLocalName = element_getAnAttributeByNamespaceAndLocalName; /** @@ -2249,14 +2014,15 @@ exports.element_getAnAttributeByNamespaceAndLocalName = element_getAnAttributeBy * @param localName - an attribute local name * @param namespace - an attribute namespace */ -function element_getAnAttributeValue(element, localName, namespace = '') { +function element_getAnAttributeValue(element, localName, namespace) { + if (namespace === void 0) { namespace = ''; } /** * 1. Let attr be the result of getting an attribute given namespace, * localName, and element. * 2. If attr is null, then return the empty string. * 3. Return attr’s value. */ - const attr = element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element); + var attr = element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element); if (attr === null) return ''; else @@ -2281,8 +2047,8 @@ function element_setAnAttribute(attr, element) { * 6. Return oldAttr. */ if (attr._element !== null && attr._element !== element) - throw new DOMException_1.InUseAttributeError(`This attribute already exists in the document: ${attr._qualifiedName} as a child of ${attr._element._qualifiedName}.`); - const oldAttr = element_getAnAttributeByNamespaceAndLocalName(attr._namespace || '', attr._localName, element); + throw new DOMException_1.InUseAttributeError("This attribute already exists in the document: " + attr._qualifiedName + " as a child of " + attr._element._qualifiedName + "."); + var oldAttr = element_getAnAttributeByNamespaceAndLocalName(attr._namespace || '', attr._localName, element); if (oldAttr === attr) return attr; if (oldAttr !== null) { @@ -2303,7 +2069,9 @@ exports.element_setAnAttribute = element_setAnAttribute; * @param prefix - an attribute prefix * @param namespace - an attribute namespace */ -function element_setAnAttributeValue(element, localName, value, prefix = null, namespace = null) { +function element_setAnAttributeValue(element, localName, value, prefix, namespace) { + if (prefix === void 0) { prefix = null; } + if (namespace === void 0) { namespace = null; } /** * 1. If prefix is not given, set it to null. * 2. If namespace is not given, set it to null. @@ -2315,9 +2083,9 @@ function element_setAnAttributeValue(element, localName, value, prefix = null, n * attribute to element, and then return. * 5. Change attribute from element to value. */ - const attribute = element_getAnAttributeByNamespaceAndLocalName(namespace || '', localName, element); + var attribute = element_getAnAttributeByNamespaceAndLocalName(namespace || '', localName, element); if (attribute === null) { - const newAttr = CreateAlgorithm_1.create_attr(element._nodeDocument, localName); + var newAttr = CreateAlgorithm_1.create_attr(element._nodeDocument, localName); newAttr._namespace = namespace; newAttr._namespacePrefix = prefix; newAttr._value = value; @@ -2340,7 +2108,7 @@ function element_removeAnAttributeByName(qualifiedName, element) { * 2. If attr is non-null, remove it from element. * 3. Return attr. */ - const attr = element_getAnAttributeByName(qualifiedName, element); + var attr = element_getAnAttributeByName(qualifiedName, element); if (attr !== null) { element_remove(attr, element); } @@ -2361,7 +2129,7 @@ function element_removeAnAttributeByNamespaceAndLocalName(namespace, localName, * 2. If attr is non-null, remove it from element. * 3. Return attr. */ - const attr = element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element); + var attr = element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element); if (attr !== null) { element_remove(attr, element); } @@ -2379,14 +2147,17 @@ exports.element_removeAnAttributeByNamespaceAndLocalName = element_removeAnAttri * @param is - the "is" value * @param synchronousCustomElementsFlag - synchronous custom elements flag */ -function element_createAnElement(document, localName, namespace, prefix = null, is = null, synchronousCustomElementsFlag = false) { +function element_createAnElement(document, localName, namespace, prefix, is, synchronousCustomElementsFlag) { + if (prefix === void 0) { prefix = null; } + if (is === void 0) { is = null; } + if (synchronousCustomElementsFlag === void 0) { synchronousCustomElementsFlag = false; } /** * 1. If prefix was not given, let prefix be null. * 2. If is was not given, let is be null. * 3. Let result be null. */ - let result = null; - if (!dom_1.dom.features.customElements) { + var result = null; + if (!DOMImpl_1.dom.features.customElements) { result = CreateAlgorithm_1.create_element(document, localName, namespace, prefix); result._customElementState = "uncustomized"; result._customElementDefinition = null; @@ -2397,7 +2168,7 @@ function element_createAnElement(document, localName, namespace, prefix = null, * 4. Let definition be the result of looking up a custom element definition * given document, namespace, localName, and is. */ - const definition = CustomElementAlgorithm_1.customElement_lookUpACustomElementDefinition(document, namespace, localName, is); + var definition = CustomElementAlgorithm_1.customElement_lookUpACustomElementDefinition(document, namespace, localName, is); if (definition !== null && definition.name !== definition.localName) { /** * 5. If definition is non-null, and definition’s name is not equal to @@ -2415,7 +2186,7 @@ function element_createAnElement(document, localName, namespace, prefix = null, * 5.4. Otherwise, enqueue a custom element upgrade reaction given result * and definition. */ - const elemenInterface = DocumentAlgorithm_1.document_elementInterface(localName, infra_1.namespace.HTML); + var elemenInterface = DocumentAlgorithm_1.document_elementInterface(localName, infra_1.namespace.HTML); result = new elemenInterface(); result._localName = localName; result._namespace = infra_1.namespace.HTML; @@ -2450,11 +2221,11 @@ function element_createAnElement(document, localName, namespace, prefix = null, * _Note:_ IDL enforces that result is an HTMLElement object, which all * use the HTML namespace. */ - const C = definition.constructor; - const result = new C(); - console.assert(result._customElementState !== undefined); - console.assert(result._customElementDefinition !== undefined); - console.assert(result._namespace === infra_1.namespace.HTML); + var C = definition.constructor; + var result_1 = new C(); + console.assert(result_1._customElementState !== undefined); + console.assert(result_1._customElementDefinition !== undefined); + console.assert(result_1._namespace === infra_1.namespace.HTML); /** * 6.1.5. If result’s attribute list is not empty, then throw a * "NotSupportedError" DOMException. @@ -2467,22 +2238,22 @@ function element_createAnElement(document, localName, namespace, prefix = null, * 6.1.9. If result’s local name is not equal to localName, then throw * a "NotSupportedError" DOMException. */ - if (result._attributeList.length !== 0) + if (result_1._attributeList.length !== 0) throw new DOMException_1.NotSupportedError("Custom element already has attributes."); - if (result._children.size !== 0) + if (result_1._children.size !== 0) throw new DOMException_1.NotSupportedError("Custom element already has child nodes."); - if (result._parent !== null) + if (result_1._parent !== null) throw new DOMException_1.NotSupportedError("Custom element already has a parent node."); - if (result._nodeDocument !== document) + if (result_1._nodeDocument !== document) throw new DOMException_1.NotSupportedError("Custom element is already in a document."); - if (result._localName !== localName) + if (result_1._localName !== localName) throw new DOMException_1.NotSupportedError("Custom element has a different local name."); /** * 6.1.10. Set result’s namespace prefix to prefix. * 6.1.11. Set result’s is value to null. */ - result._namespacePrefix = prefix; - result._is = null; + result_1._namespacePrefix = prefix; + result_1._is = null; } catch (e) { /** @@ -2530,7 +2301,7 @@ function element_createAnElement(document, localName, namespace, prefix = null, * "uncustomized", custom element definition set to null, is value set to * is, and node document set to document. */ - const elementInterface = DocumentAlgorithm_1.document_elementInterface(localName, namespace); + var elementInterface = DocumentAlgorithm_1.document_elementInterface(localName, namespace); result = new elementInterface(); result._localName = localName; result._namespace = namespace; @@ -2601,659 +2372,997 @@ function element_insertAdjacent(element, where, node) { return null; return MutationAlgorithm_1.mutation_preInsert(node, element._parent, element._nextSibling); default: - throw new DOMException_1.SyntaxError(`Invalid 'where' argument. "beforebegin", "afterbegin", "beforeend" or "afterend" expected`); + throw new DOMException_1.SyntaxError("Invalid 'where' argument. \"beforebegin\", \"afterbegin\", \"beforeend\" or \"afterend\" expected"); } } exports.element_insertAdjacent = element_insertAdjacent; //# sourceMappingURL=ElementAlgorithm.js.map /***/ }), +/* 34 */ +/***/ (function(module) { -/***/ 35: +module.exports = require("https"); + +/***/ }), +/* 35 */ /***/ (function(__unusedmodule, exports) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); /** * Represents the base class of `Error` objects used by this module. */ -class DOMException extends Error { +var DOMException = /** @class */ (function (_super) { + __extends(DOMException, _super); /** * * @param name - message name * @param message - error message */ - constructor(name, message = "") { - super(message); - this.name = name; + function DOMException(name, message) { + if (message === void 0) { message = ""; } + var _this = _super.call(this, message) || this; + _this.name = name; + return _this; } -} + return DOMException; +}(Error)); exports.DOMException = DOMException; -class DOMStringSizeError extends DOMException { +var DOMStringSizeError = /** @class */ (function (_super) { + __extends(DOMStringSizeError, _super); /** * @param message - error message */ - constructor(message = "") { - super("DOMStringSizeError", message); + function DOMStringSizeError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "DOMStringSizeError", message) || this; } -} + return DOMStringSizeError; +}(DOMException)); exports.DOMStringSizeError = DOMStringSizeError; -class WrongDocumentError extends DOMException { +var WrongDocumentError = /** @class */ (function (_super) { + __extends(WrongDocumentError, _super); /** * @param message - error message */ - constructor(message = "") { - super("WrongDocumentError", "The object is in the wrong document. " + message); + function WrongDocumentError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "WrongDocumentError", "The object is in the wrong document. " + message) || this; } -} + return WrongDocumentError; +}(DOMException)); exports.WrongDocumentError = WrongDocumentError; -class NoDataAllowedError extends DOMException { +var NoDataAllowedError = /** @class */ (function (_super) { + __extends(NoDataAllowedError, _super); /** * @param message - error message */ - constructor(message = "") { - super("NoDataAllowedError", message); + function NoDataAllowedError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "NoDataAllowedError", message) || this; } -} + return NoDataAllowedError; +}(DOMException)); exports.NoDataAllowedError = NoDataAllowedError; -class NoModificationAllowedError extends DOMException { +var NoModificationAllowedError = /** @class */ (function (_super) { + __extends(NoModificationAllowedError, _super); /** * @param message - error message */ - constructor(message = "") { - super("NoModificationAllowedError", "The object can not be modified. " + message); + function NoModificationAllowedError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "NoModificationAllowedError", "The object can not be modified. " + message) || this; } -} + return NoModificationAllowedError; +}(DOMException)); exports.NoModificationAllowedError = NoModificationAllowedError; -class NotSupportedError extends DOMException { +var NotSupportedError = /** @class */ (function (_super) { + __extends(NotSupportedError, _super); /** * @param message - error message */ - constructor(message = "") { - super("NotSupportedError", "The operation is not supported. " + message); + function NotSupportedError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "NotSupportedError", "The operation is not supported. " + message) || this; } -} + return NotSupportedError; +}(DOMException)); exports.NotSupportedError = NotSupportedError; -class InUseAttributeError extends DOMException { +var InUseAttributeError = /** @class */ (function (_super) { + __extends(InUseAttributeError, _super); /** * @param message - error message */ - constructor(message = "") { - super("InUseAttributeError", message); + function InUseAttributeError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "InUseAttributeError", message) || this; } -} + return InUseAttributeError; +}(DOMException)); exports.InUseAttributeError = InUseAttributeError; -class InvalidStateError extends DOMException { +var InvalidStateError = /** @class */ (function (_super) { + __extends(InvalidStateError, _super); /** * @param message - error message */ - constructor(message = "") { - super("InvalidStateError", "The object is in an invalid state. " + message); + function InvalidStateError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "InvalidStateError", "The object is in an invalid state. " + message) || this; } -} + return InvalidStateError; +}(DOMException)); exports.InvalidStateError = InvalidStateError; -class InvalidModificationError extends DOMException { +var InvalidModificationError = /** @class */ (function (_super) { + __extends(InvalidModificationError, _super); /** * @param message - error message */ - constructor(message = "") { - super("InvalidModificationError", "The object can not be modified in this way. " + message); + function InvalidModificationError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "InvalidModificationError", "The object can not be modified in this way. " + message) || this; } -} + return InvalidModificationError; +}(DOMException)); exports.InvalidModificationError = InvalidModificationError; -class NamespaceError extends DOMException { +var NamespaceError = /** @class */ (function (_super) { + __extends(NamespaceError, _super); /** * @param message - error message */ - constructor(message = "") { - super("NamespaceError", "The operation is not allowed by Namespaces in XML. [XMLNS] " + message); + function NamespaceError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "NamespaceError", "The operation is not allowed by Namespaces in XML. [XMLNS] " + message) || this; } -} + return NamespaceError; +}(DOMException)); exports.NamespaceError = NamespaceError; -class InvalidAccessError extends DOMException { +var InvalidAccessError = /** @class */ (function (_super) { + __extends(InvalidAccessError, _super); /** * @param message - error message */ - constructor(message = "") { - super("InvalidAccessError", "The object does not support the operation or argument. " + message); + function InvalidAccessError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "InvalidAccessError", "The object does not support the operation or argument. " + message) || this; } -} + return InvalidAccessError; +}(DOMException)); exports.InvalidAccessError = InvalidAccessError; -class ValidationError extends DOMException { +var ValidationError = /** @class */ (function (_super) { + __extends(ValidationError, _super); /** * @param message - error message */ - constructor(message = "") { - super("ValidationError", message); + function ValidationError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "ValidationError", message) || this; } -} + return ValidationError; +}(DOMException)); exports.ValidationError = ValidationError; -class TypeMismatchError extends DOMException { +var TypeMismatchError = /** @class */ (function (_super) { + __extends(TypeMismatchError, _super); /** * @param message - error message */ - constructor(message = "") { - super("TypeMismatchError", message); + function TypeMismatchError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "TypeMismatchError", message) || this; } -} + return TypeMismatchError; +}(DOMException)); exports.TypeMismatchError = TypeMismatchError; -class SecurityError extends DOMException { +var SecurityError = /** @class */ (function (_super) { + __extends(SecurityError, _super); /** * @param message - error message */ - constructor(message = "") { - super("SecurityError", "The operation is insecure. " + message); + function SecurityError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "SecurityError", "The operation is insecure. " + message) || this; } -} + return SecurityError; +}(DOMException)); exports.SecurityError = SecurityError; -class NetworkError extends DOMException { +var NetworkError = /** @class */ (function (_super) { + __extends(NetworkError, _super); /** * @param message - error message */ - constructor(message = "") { - super("NetworkError", "A network error occurred. " + message); + function NetworkError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "NetworkError", "A network error occurred. " + message) || this; } -} + return NetworkError; +}(DOMException)); exports.NetworkError = NetworkError; -class AbortError extends DOMException { +var AbortError = /** @class */ (function (_super) { + __extends(AbortError, _super); /** * @param message - error message */ - constructor(message = "") { - super("AbortError", "The operation was aborted. " + message); + function AbortError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "AbortError", "The operation was aborted. " + message) || this; } -} + return AbortError; +}(DOMException)); exports.AbortError = AbortError; -class URLMismatchError extends DOMException { +var URLMismatchError = /** @class */ (function (_super) { + __extends(URLMismatchError, _super); /** * @param message - error message */ - constructor(message = "") { - super("URLMismatchError", "The given URL does not match another URL. " + message); + function URLMismatchError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "URLMismatchError", "The given URL does not match another URL. " + message) || this; } -} + return URLMismatchError; +}(DOMException)); exports.URLMismatchError = URLMismatchError; -class QuotaExceededError extends DOMException { +var QuotaExceededError = /** @class */ (function (_super) { + __extends(QuotaExceededError, _super); /** * @param message - error message */ - constructor(message = "") { - super("QuotaExceededError", "The quota has been exceeded. " + message); + function QuotaExceededError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "QuotaExceededError", "The quota has been exceeded. " + message) || this; } -} + return QuotaExceededError; +}(DOMException)); exports.QuotaExceededError = QuotaExceededError; -class TimeoutError extends DOMException { +var TimeoutError = /** @class */ (function (_super) { + __extends(TimeoutError, _super); /** * @param message - error message */ - constructor(message = "") { - super("TimeoutError", "The operation timed out. " + message); + function TimeoutError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "TimeoutError", "The operation timed out. " + message) || this; } -} + return TimeoutError; +}(DOMException)); exports.TimeoutError = TimeoutError; -class InvalidNodeTypeError extends DOMException { +var InvalidNodeTypeError = /** @class */ (function (_super) { + __extends(InvalidNodeTypeError, _super); /** * @param message - error message */ - constructor(message = "") { - super("InvalidNodeTypeError", "The supplied node is incorrect or has an incorrect ancestor for this operation. " + message); + function InvalidNodeTypeError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "InvalidNodeTypeError", "The supplied node is incorrect or has an incorrect ancestor for this operation. " + message) || this; } -} + return InvalidNodeTypeError; +}(DOMException)); exports.InvalidNodeTypeError = InvalidNodeTypeError; -class DataCloneError extends DOMException { +var DataCloneError = /** @class */ (function (_super) { + __extends(DataCloneError, _super); /** * @param message - error message */ - constructor(message = "") { - super("DataCloneError", "The object can not be cloned. " + message); + function DataCloneError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "DataCloneError", "The object can not be cloned. " + message) || this; } -} + return DataCloneError; +}(DOMException)); exports.DataCloneError = DataCloneError; -class NotImplementedError extends DOMException { +var NotImplementedError = /** @class */ (function (_super) { + __extends(NotImplementedError, _super); /** * @param message - error message */ - constructor(message = "") { - super("NotImplementedError", "The DOM method is not implemented by this module. " + message); + function NotImplementedError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "NotImplementedError", "The DOM method is not implemented by this module. " + message) || this; } -} + return NotImplementedError; +}(DOMException)); exports.NotImplementedError = NotImplementedError; -class HierarchyRequestError extends DOMException { +var HierarchyRequestError = /** @class */ (function (_super) { + __extends(HierarchyRequestError, _super); /** * @param message - error message */ - constructor(message = "") { - super("HierarchyRequestError", "The operation would yield an incorrect node tree. " + message); + function HierarchyRequestError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "HierarchyRequestError", "The operation would yield an incorrect node tree. " + message) || this; } -} + return HierarchyRequestError; +}(DOMException)); exports.HierarchyRequestError = HierarchyRequestError; -class NotFoundError extends DOMException { +var NotFoundError = /** @class */ (function (_super) { + __extends(NotFoundError, _super); /** * @param message - error message */ - constructor(message = "") { - super("NotFoundError", "The object can not be found here. " + message); + function NotFoundError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "NotFoundError", "The object can not be found here. " + message) || this; } -} + return NotFoundError; +}(DOMException)); exports.NotFoundError = NotFoundError; -class IndexSizeError extends DOMException { +var IndexSizeError = /** @class */ (function (_super) { + __extends(IndexSizeError, _super); /** * @param message - error message */ - constructor(message = "") { - super("IndexSizeError", "The index is not in the allowed range. " + message); + function IndexSizeError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "IndexSizeError", "The index is not in the allowed range. " + message) || this; } -} + return IndexSizeError; +}(DOMException)); exports.IndexSizeError = IndexSizeError; -class SyntaxError extends DOMException { +var SyntaxError = /** @class */ (function (_super) { + __extends(SyntaxError, _super); /** * @param message - error message */ - constructor(message = "") { - super("SyntaxError", "The string did not match the expected pattern. " + message); + function SyntaxError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "SyntaxError", "The string did not match the expected pattern. " + message) || this; } -} + return SyntaxError; +}(DOMException)); exports.SyntaxError = SyntaxError; -class InvalidCharacterError extends DOMException { +var InvalidCharacterError = /** @class */ (function (_super) { + __extends(InvalidCharacterError, _super); /** * @param message - error message */ - constructor(message = "") { - super("InvalidCharacterError", "The string contains invalid characters. " + message); + function InvalidCharacterError(message) { + if (message === void 0) { message = ""; } + return _super.call(this, "InvalidCharacterError", "The string contains invalid characters. " + message) || this; } -} + return InvalidCharacterError; +}(DOMException)); exports.InvalidCharacterError = InvalidCharacterError; //# sourceMappingURL=DOMException.js.map /***/ }), - -/***/ 42: +/* 36 */, +/* 37 */, +/* 38 */, +/* 39 */, +/* 40 */, +/* 41 */, +/* 42 */, +/* 43 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -var ObjectCache_1 = __webpack_require__(568); -exports.ObjectCache = ObjectCache_1.ObjectCache; -var CompareCache_1 = __webpack_require__(938); -exports.CompareCache = CompareCache_1.CompareCache; -/** - * Applies the mixin to a given class. - * - * @param baseClass - class to receive the mixin - * @param mixinClass - mixin class - * @param overrides - an array with names of function overrides. Base class - * functions whose names are in this array will be kept by prepending an - * underscore to their names. - */ -function applyMixin(baseClass, mixinClass, ...overrides) { - Object.getOwnPropertyNames(mixinClass.prototype).forEach(name => { - if (overrides.includes(name)) { - const orgPropDesc = Object.getOwnPropertyDescriptor(baseClass.prototype, name); - /* istanbul ignore else */ - if (orgPropDesc) { - Object.defineProperty(baseClass.prototype, "_" + name, orgPropDesc); - } - } - const propDesc = Object.getOwnPropertyDescriptor(mixinClass.prototype, name); - /* istanbul ignore else */ - if (propDesc) { - Object.defineProperty(baseClass.prototype, name, propDesc); - } - }); -} -exports.applyMixin = applyMixin; -/** - * Applies default values to the given object. - * - * @param obj - an object - * @param defaults - an object with default values - * @param overwrite - if set to `true` defaults object always overwrites object - * values, whether they are `undefined` or not. - */ -function applyDefaults(obj, defaults, overwrite = false) { - const result = clone(obj || {}); - for (const [key, val] of forEachObject(defaults)) { - if (isObject(val)) { - result[key] = applyDefaults(result[key], val); - } - else if (overwrite || result[key] === undefined) { - result[key] = val; - } - } - return result; -} -exports.applyDefaults = applyDefaults; -/** - * Iterates over items pairs of an array. - * - * @param arr - array to iterate - */ -function* forEachArray(arr) { - yield* arr; -} -exports.forEachArray = forEachArray; -/** - * Iterates over key/value pairs of a map or object. - * - * @param obj - map or object to iterate - */ -function* forEachObject(obj) { - if (isMap(obj)) { - yield* obj; - } - else { - for (const key in obj) { - /* istanbul ignore next */ - if (!obj.hasOwnProperty(key)) - continue; - yield [key, obj[key]]; - } - } -} -exports.forEachObject = forEachObject; -/** - * Returns the number of entries in a map or object. - * - * @param obj - map or object - */ -function objectLength(obj) { - if (isMap(obj)) { - return obj.size; - } - else { - return Object.keys(obj).length; - } -} -exports.objectLength = objectLength; -/** - * Gets the value of a key from a map or object. - * - * @param obj - map or object - * @param key - the key to retrieve - */ -function getObjectValue(obj, key) { - if (isMap(obj)) { - return obj.get(key); - } - else { - return obj[key]; - } -} -exports.getObjectValue = getObjectValue; -/** - * Removes a property from a map or object. - * - * @param obj - map or object - * @param key - the key to remove - */ -function removeObjectValue(obj, key) { - if (isMap(obj)) { - obj.delete(key); - } - else { - delete obj[key]; - } -} -exports.removeObjectValue = removeObjectValue; -/** - * Deep clones the given object. - * - * @param obj - an object - */ -function clone(obj) { - if (isFunction(obj)) { - return obj; - } - else if (isArray(obj)) { - const result = []; - for (const item of obj) { - result.push(clone(item)); - } - return result; - } - else if (isObject(obj)) { - const result = {}; - for (const key in obj) { - /* istanbul ignore next */ - if (obj.hasOwnProperty(key)) { - const val = obj[key]; - result[key] = clone(val); - } - } - return result; - } - else { - return obj; - } -} -exports.clone = clone; -/** - * Type guard for boolean types - * - * @param x - a variable to type check - */ -function isBoolean(x) { - return typeof x === "boolean"; -} -exports.isBoolean = isBoolean; -/** - * Type guard for numeric types - * - * @param x - a variable to type check - */ -function isNumber(x) { - return typeof x === "number"; -} -exports.isNumber = isNumber; -/** - * Type guard for strings - * - * @param x - a variable to type check - */ -function isString(x) { - return typeof x === "string"; -} -exports.isString = isString; -/** - * Type guard for function objects - * - * @param x - a variable to type check - */ -function isFunction(x) { - return !!x && Object.prototype.toString.call(x) === '[object Function]'; -} -exports.isFunction = isFunction; -/** - * Type guard for JS objects - * - * _Note:_ Functions are objects too - * - * @param x - a variable to type check - */ -function isObject(x) { - const type = typeof x; - return !!x && (type === 'function' || type === 'object'); -} -exports.isObject = isObject; -/** - * Type guard for arrays - * - * @param x - a variable to type check - */ -function isArray(x) { - return Array.isArray(x); -} -exports.isArray = isArray; -/** - * Type guard for maps. - * - * @param x - a variable to check - */ -function isMap(x) { - return x instanceof Map; -} -exports.isMap = isMap; -/** - * Determines if `x` is an empty Array or an Object with no own properties. - * - * @param x - a variable to check - */ -function isEmpty(x) { - if (isArray(x)) { - return !x.length; - } - else if (isObject(x)) { - for (const key in x) { - if (x.hasOwnProperty(key)) { - return false; - } - } - return true; - } - return false; -} -exports.isEmpty = isEmpty; -/** - * Determines if `x` is a plain Object. - * - * @param x - a variable to check - */ -function isPlainObject(x) { - if (isObject(x)) { - const proto = Object.getPrototypeOf(x); - const ctor = proto.constructor; - return proto && ctor && - (typeof ctor === 'function') && (ctor instanceof ctor) && - (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object)); - } - return false; -} -exports.isPlainObject = isPlainObject; -/** - * Determines if `x` is an iterable Object. - * - * @param x - a variable to check - */ -function isIterable(x) { - return x && (typeof x[Symbol.iterator] === 'function'); -} -exports.isIterable = isIterable; -/** - * Gets the primitive value of an object. - */ -function getValue(obj) { - if (isFunction(obj.valueOf)) { - return obj.valueOf(); - } - else { - return obj; - } -} -exports.getValue = getValue; -//# sourceMappingURL=index.js.map - -/***/ }), - -/***/ 43: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const NodeImpl_1 = __webpack_require__(935); -const algorithm_1 = __webpack_require__(163); +var NodeImpl_1 = __webpack_require__(935); +var algorithm_1 = __webpack_require__(163); /** * Represents a generic text node. */ -class CharacterDataImpl extends NodeImpl_1.NodeImpl { +var CharacterDataImpl = /** @class */ (function (_super) { + __extends(CharacterDataImpl, _super); /** * Initializes a new instance of `CharacterData`. * * @param data - the text content */ - constructor(data) { - super(); - this._data = data; + function CharacterDataImpl(data) { + var _this = _super.call(this) || this; + _this._data = data; + return _this; } + Object.defineProperty(CharacterDataImpl.prototype, "data", { + /** @inheritdoc */ + get: function () { return this._data; }, + set: function (value) { + algorithm_1.characterData_replaceData(this, 0, this._data.length, value); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CharacterDataImpl.prototype, "length", { + /** @inheritdoc */ + get: function () { return this._data.length; }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get data() { return this._data; } - set data(value) { - algorithm_1.characterData_replaceData(this, 0, this._data.length, value); - } - /** @inheritdoc */ - get length() { return this._data.length; } - /** @inheritdoc */ - substringData(offset, count) { + CharacterDataImpl.prototype.substringData = function (offset, count) { /** * The substringData(offset, count) method, when invoked, must return the * result of running substring data with node context object, offset offset, and count count. */ return algorithm_1.characterData_substringData(this, offset, count); - } + }; /** @inheritdoc */ - appendData(data) { + CharacterDataImpl.prototype.appendData = function (data) { /** * The appendData(data) method, when invoked, must replace data with node * context object, offset context object’s length, count 0, and data data. */ return algorithm_1.characterData_replaceData(this, this._data.length, 0, data); - } + }; /** @inheritdoc */ - insertData(offset, data) { + CharacterDataImpl.prototype.insertData = function (offset, data) { /** * The insertData(offset, data) method, when invoked, must replace data with * node context object, offset offset, count 0, and data data. */ algorithm_1.characterData_replaceData(this, offset, 0, data); - } + }; /** @inheritdoc */ - deleteData(offset, count) { + CharacterDataImpl.prototype.deleteData = function (offset, count) { /** * The deleteData(offset, count) method, when invoked, must replace data * with node context object, offset offset, count count, and data the * empty string. */ algorithm_1.characterData_replaceData(this, offset, count, ''); - } + }; /** @inheritdoc */ - replaceData(offset, count, data) { + CharacterDataImpl.prototype.replaceData = function (offset, count, data) { /** * The replaceData(offset, count, data) method, when invoked, must replace * data with node context object, offset offset, count count, and data data. */ algorithm_1.characterData_replaceData(this, offset, count, data); - } - // MIXIN: NonDocumentTypeChildNode - /* istanbul ignore next */ - get previousElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); } - /* istanbul ignore next */ - get nextElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); } + }; + Object.defineProperty(CharacterDataImpl.prototype, "previousElementSibling", { + // MIXIN: NonDocumentTypeChildNode + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CharacterDataImpl.prototype, "nextElementSibling", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }, + enumerable: true, + configurable: true + }); // MIXIN: ChildNode /* istanbul ignore next */ - before(...nodes) { throw new Error("Mixin: ChildNode not implemented."); } + CharacterDataImpl.prototype.before = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ChildNode not implemented."); + }; /* istanbul ignore next */ - after(...nodes) { throw new Error("Mixin: ChildNode not implemented."); } + CharacterDataImpl.prototype.after = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ChildNode not implemented."); + }; /* istanbul ignore next */ - replaceWith(...nodes) { throw new Error("Mixin: ChildNode not implemented."); } + CharacterDataImpl.prototype.replaceWith = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ChildNode not implemented."); + }; /* istanbul ignore next */ - remove() { throw new Error("Mixin: ChildNode not implemented."); } -} + CharacterDataImpl.prototype.remove = function () { throw new Error("Mixin: ChildNode not implemented."); }; + return CharacterDataImpl; +}(NodeImpl_1.NodeImpl)); exports.CharacterDataImpl = CharacterDataImpl; //# sourceMappingURL=CharacterDataImpl.js.map /***/ }), +/* 44 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 54: +"use strict"; + + +var common = __webpack_require__(740); +var Type = __webpack_require__(945); + +function isHexCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) || + ((0x41/* A */ <= c) && (c <= 0x46/* F */)) || + ((0x61/* a */ <= c) && (c <= 0x66/* f */)); +} + +function isOctCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */)); +} + +function isDecCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)); +} + +function resolveYamlInteger(data) { + if (data === null) return false; + + var max = data.length, + index = 0, + hasDigits = false, + ch; + + if (!max) return false; + + ch = data[index]; + + // sign + if (ch === '-' || ch === '+') { + ch = data[++index]; + } + + if (ch === '0') { + // 0 + if (index + 1 === max) return true; + ch = data[++index]; + + // base 2, base 8, base 16 + + if (ch === 'b') { + // base 2 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (ch !== '0' && ch !== '1') return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + + if (ch === 'x') { + // base 16 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isHexCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + // base 8 + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isOctCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + // base 10 (except 0) or base 60 + + // value should not start with `_`; + if (ch === '_') return false; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (ch === ':') break; + if (!isDecCode(data.charCodeAt(index))) { + return false; + } + hasDigits = true; + } + + // Should have digits and should not end with `_` + if (!hasDigits || ch === '_') return false; + + // if !base60 - done; + if (ch !== ':') return true; + + // base60 almost not used, no needs to optimize + return /^(:[0-5]?[0-9])+$/.test(data.slice(index)); +} + +function constructYamlInteger(data) { + var value = data, sign = 1, ch, base, digits = []; + + if (value.indexOf('_') !== -1) { + value = value.replace(/_/g, ''); + } + + ch = value[0]; + + if (ch === '-' || ch === '+') { + if (ch === '-') sign = -1; + value = value.slice(1); + ch = value[0]; + } + + if (value === '0') return 0; + + if (ch === '0') { + if (value[1] === 'b') return sign * parseInt(value.slice(2), 2); + if (value[1] === 'x') return sign * parseInt(value, 16); + return sign * parseInt(value, 8); + } + + if (value.indexOf(':') !== -1) { + value.split(':').forEach(function (v) { + digits.unshift(parseInt(v, 10)); + }); + + value = 0; + base = 1; + + digits.forEach(function (d) { + value += (d * base); + base *= 60; + }); + + return sign * value; + + } + + return sign * parseInt(value, 10); +} + +function isInteger(object) { + return (Object.prototype.toString.call(object)) === '[object Number]' && + (object % 1 === 0 && !common.isNegativeZero(object)); +} + +module.exports = new Type('tag:yaml.org,2002:int', { + kind: 'scalar', + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); }, + octal: function (obj) { return obj >= 0 ? '0' + obj.toString(8) : '-0' + obj.toString(8).slice(1); }, + decimal: function (obj) { return obj.toString(10); }, + /* eslint-disable max-len */ + hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1); } + }, + defaultStyle: 'decimal', + styleAliases: { + binary: [ 2, 'bin' ], + octal: [ 8, 'oct' ], + decimal: [ 10, 'dec' ], + hexadecimal: [ 16, 'hex' ] + } +}); + + +/***/ }), +/* 45 */, +/* 46 */, +/* 47 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Walks through the code points of a string. + */ +var StringWalker = /** @class */ (function () { + /** + * Initializes a new `StringWalker`. + * + * @param input - input string + */ + function StringWalker(input) { + this._pointer = 0; + this._chars = Array.from(input); + this._length = this._chars.length; + } + Object.defineProperty(StringWalker.prototype, "eof", { + /** + * Determines if the current position is beyond the end of string. + */ + get: function () { return this._pointer >= this._length; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StringWalker.prototype, "length", { + /** + * Returns the number of code points in the input string. + */ + get: function () { return this._length; }, + enumerable: true, + configurable: true + }); + /** + * Returns the current code point. Returns `-1` if the position is beyond + * the end of string. + */ + StringWalker.prototype.codePoint = function () { + if (this._codePoint === undefined) { + if (this.eof) { + this._codePoint = -1; + } + else { + var cp = this._chars[this._pointer].codePointAt(0); + /* istanbul ignore else */ + if (cp !== undefined) { + this._codePoint = cp; + } + else { + this._codePoint = -1; + } + } + } + return this._codePoint; + }; + /** + * Returns the current character. Returns an empty string if the position is + * beyond the end of string. + */ + StringWalker.prototype.c = function () { + if (this._c === undefined) { + this._c = (this.eof ? "" : this._chars[this._pointer]); + } + return this._c; + }; + /** + * Returns the remaining string. + */ + StringWalker.prototype.remaining = function () { + if (this._remaining === undefined) { + this._remaining = (this.eof ? + "" : this._chars.slice(this._pointer + 1).join('')); + } + return this._remaining; + }; + /** + * Returns the substring from the current character to the end of string. + */ + StringWalker.prototype.substring = function () { + if (this._substring === undefined) { + this._substring = (this.eof ? + "" : this._chars.slice(this._pointer).join('')); + } + return this._substring; + }; + Object.defineProperty(StringWalker.prototype, "pointer", { + /** + * Gets or sets the current position. + */ + get: function () { return this._pointer; }, + set: function (val) { + if (val === this._pointer) + return; + this._pointer = val; + this._codePoint = undefined; + this._c = undefined; + this._remaining = undefined; + this._substring = undefined; + }, + enumerable: true, + configurable: true + }); + return StringWalker; +}()); +exports.StringWalker = StringWalker; +//# sourceMappingURL=StringWalker.js.map + +/***/ }), +/* 48 */, +/* 49 */, +/* 50 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var util_1 = __webpack_require__(592); +var BaseReader_1 = __webpack_require__(305); +var dom_1 = __webpack_require__(743); +/** + * Parses XML nodes from objects and arrays. + * ES6 maps and sets are also supoorted. + */ +var ObjectReader = /** @class */ (function (_super) { + __extends(ObjectReader, _super); + function ObjectReader() { + return _super !== null && _super.apply(this, arguments) || this; + } + /** + * Parses the given document representation. + * + * @param node - node receive parsed XML nodes + * @param obj - object to parse + */ + ObjectReader.prototype._parse = function (node, obj) { + var _this = this; + var options = this._builderOptions; + // sanitizes input characters + var invalidCharReplacement = options.invalidCharReplacement; + var s = function (str) { + return dom_1.sanitizeInput(str, invalidCharReplacement); + }; + var lastChild = null; + if (util_1.isFunction(obj)) { + // evaluate if function + lastChild = this.parse(node, obj.apply(this)); + } + else if (util_1.isArray(obj) || util_1.isSet(obj)) { + util_1.forEachArray(obj, function (item) { return lastChild = _this.parse(node, item); }, this); + } + else /* if (isMap(obj) || isObject(obj)) */ { + // expand if object + util_1.forEachObject(obj, function (key, val) { + if (util_1.isFunction(val)) { + // evaluate if function + val = val.apply(_this); + } + if (!options.ignoreConverters && key.indexOf(options.convert.att) === 0) { + // assign attributes + if (key === options.convert.att) { + if (util_1.isArray(val) || util_1.isSet(val)) { + throw new Error("Invalid attribute: " + val.toString() + ". " + node._debugInfo()); + } + else /* if (isMap(val) || isObject(val)) */ { + util_1.forEachObject(val, function (attrKey, attrVal) { + lastChild = _this.attribute(node, undefined, s(attrKey), s(attrVal)) || lastChild; + }); + } + } + else { + lastChild = _this.attribute(node, undefined, s(key.substr(options.convert.att.length)), s(val)) || lastChild; + } + } + else if (!options.ignoreConverters && key.indexOf(options.convert.text) === 0) { + // text node + if (util_1.isMap(val) || util_1.isObject(val)) { + // if the key is #text expand child nodes under this node to support mixed content + lastChild = _this.parse(node, val); + } + else { + lastChild = _this.text(node, s(val)) || lastChild; + } + } + else if (!options.ignoreConverters && key.indexOf(options.convert.cdata) === 0) { + // cdata node + if (util_1.isArray(val) || util_1.isSet(val)) { + util_1.forEachArray(val, function (item) { return lastChild = _this.cdata(node, s(item)) || lastChild; }, _this); + } + else { + lastChild = _this.cdata(node, s(val)) || lastChild; + } + } + else if (!options.ignoreConverters && key.indexOf(options.convert.comment) === 0) { + // comment node + if (util_1.isArray(val) || util_1.isSet(val)) { + util_1.forEachArray(val, function (item) { return lastChild = _this.comment(node, s(item)) || lastChild; }, _this); + } + else { + lastChild = _this.comment(node, s(val)) || lastChild; + } + } + else if (!options.ignoreConverters && key.indexOf(options.convert.ins) === 0) { + // processing instruction + if (util_1.isString(val)) { + var insIndex = val.indexOf(' '); + var insTarget = (insIndex === -1 ? val : val.substr(0, insIndex)); + var insValue = (insIndex === -1 ? '' : val.substr(insIndex + 1)); + lastChild = _this.instruction(node, s(insTarget), s(insValue)) || lastChild; + } + else if (util_1.isArray(val) || util_1.isSet(val)) { + util_1.forEachArray(val, function (item) { + var insIndex = item.indexOf(' '); + var insTarget = (insIndex === -1 ? item : item.substr(0, insIndex)); + var insValue = (insIndex === -1 ? '' : item.substr(insIndex + 1)); + lastChild = _this.instruction(node, s(insTarget), s(insValue)) || lastChild; + }, _this); + } + else /* if (isMap(target) || isObject(target)) */ { + util_1.forEachObject(val, function (insTarget, insValue) { return lastChild = _this.instruction(node, s(insTarget), s(insValue)) || lastChild; }, _this); + } + } + else if ((util_1.isArray(val) || util_1.isSet(val)) && util_1.isEmpty(val)) { + // skip empty arrays + } + else if ((util_1.isMap(val) || util_1.isObject(val)) && util_1.isEmpty(val)) { + // empty objects produce one node + lastChild = _this.element(node, undefined, s(key)) || lastChild; + } + else if (!options.keepNullNodes && (val == null)) { + // skip null and undefined nodes + } + else if (util_1.isArray(val) || util_1.isSet(val)) { + // expand list by creating child nodes + util_1.forEachArray(val, function (item) { + var childNode = {}; + childNode[key] = item; + lastChild = _this.parse(node, childNode); + }, _this); + } + else if (util_1.isMap(val) || util_1.isObject(val)) { + // create a parent node + var parent = _this.element(node, undefined, key); + if (parent) { + lastChild = parent; + // expand child nodes under parent + _this.parse(parent, val); + } + } + else if (val != null && val !== '') { + // leaf element node with a single text node + var parent = _this.element(node, undefined, key); + if (parent) { + lastChild = parent; + _this.text(parent, s(val)); + } + } + else { + // leaf element node + lastChild = _this.element(node, undefined, s(key)) || lastChild; + } + }, this); + } + return lastChild || node; + }; + return ObjectReader; +}(BaseReader_1.BaseReader)); +exports.ObjectReader = ObjectReader; +//# sourceMappingURL=ObjectReader.js.map + +/***/ }), +/* 51 */, +/* 52 */, +/* 53 */, +/* 54 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const OrderedSetAlgorithm_1 = __webpack_require__(146); -const DOMAlgorithm_1 = __webpack_require__(304); -const ElementAlgorithm_1 = __webpack_require__(33); +var OrderedSetAlgorithm_1 = __webpack_require__(146); +var DOMAlgorithm_1 = __webpack_require__(304); +var ElementAlgorithm_1 = __webpack_require__(33); /** * Validates a given token against the supported tokens defined for the given * token lists' associated attribute. @@ -3270,7 +3379,7 @@ function tokenList_validationSteps(tokenList, token) { * 4. Return false. */ if (!DOMAlgorithm_1.dom_hasSupportedTokens(tokenList._attribute._localName)) { - throw new TypeError(`There are no supported tokens defined for attribute name: '${tokenList._attribute._localName}'.`); + throw new TypeError("There are no supported tokens defined for attribute name: '" + tokenList._attribute._localName + "'."); } return DOMAlgorithm_1.dom_getSupportedTokens(tokenList._attribute._localName).has(token.toLowerCase()); } @@ -3312,15 +3421,43 @@ exports.tokenList_serializeSteps = tokenList_serializeSteps; //# sourceMappingURL=DOMTokenListAlgorithm.js.map /***/ }), +/* 55 */, +/* 56 */, +/* 57 */, +/* 58 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 60: +// Unique ID creation requires a high quality random # generator. In node.js +// this is pretty straight-forward - we use the crypto API. + +var crypto = __webpack_require__(373); + +module.exports = function nodeRNG() { + return crypto.randomBytes(16); +}; + + +/***/ }), +/* 59 */, +/* 60 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(337); -const CreateAlgorithm_1 = __webpack_require__(86); +var util_1 = __webpack_require__(592); +var CreateAlgorithm_1 = __webpack_require__(86); /** * Converts the given nodes or strings into a node (if `nodes` has * only one element) or a document fragment. @@ -3329,16 +3466,17 @@ const CreateAlgorithm_1 = __webpack_require__(86); * @param document - owner document */ function parentNode_convertNodesIntoANode(nodes, document) { + var e_1, _a; /** * 1. Let node be null. * 2. Replace each string in nodes with a new Text node whose data is the * string and node document is document. */ - let node = null; - for (let i = 0; i < nodes.length; i++) { - const item = nodes[i]; + var node = null; + for (var i = 0; i < nodes.length; i++) { + var item = nodes[i]; if (util_1.isString(item)) { - const text = CreateAlgorithm_1.create_text(document, item); + var text = CreateAlgorithm_1.create_text(document, item); nodes[i] = text; } } @@ -3352,9 +3490,19 @@ function parentNode_convertNodesIntoANode(nodes, document) { } else { node = CreateAlgorithm_1.create_documentFragment(document); - const ns = node; - for (const item of nodes) { - ns.appendChild(item); + var ns = node; + try { + for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) { + var item = nodes_1_1.value; + ns.appendChild(item); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1); + } + finally { if (e_1) throw e_1.error; } } } /** @@ -3366,423 +3514,379 @@ exports.parentNode_convertNodesIntoANode = parentNode_convertNodesIntoANode; //# sourceMappingURL=ParentNodeAlgorithm.js.map /***/ }), +/* 61 */, +/* 62 */, +/* 63 */, +/* 64 */, +/* 65 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 68: -/***/ (function(__unusedmodule, exports, __webpack_require__) { +const debug = __webpack_require__(548) +const { MAX_LENGTH, MAX_SAFE_INTEGER } = __webpack_require__(181) +const { re, t } = __webpack_require__(976) + +const parseOptions = __webpack_require__(143) +const { compareIdentifiers } = __webpack_require__(954) +class SemVer { + constructor (version, options) { + options = parseOptions(options) + + if (version instanceof SemVer) { + if (version.loose === !!options.loose && + version.includePrerelease === !!options.includePrerelease) { + return version + } else { + version = version.version + } + } else if (typeof version !== 'string') { + throw new TypeError(`Invalid Version: ${version}`) + } + + if (version.length > MAX_LENGTH) { + throw new TypeError( + `version is longer than ${MAX_LENGTH} characters` + ) + } + + debug('SemVer', version, options) + this.options = options + this.loose = !!options.loose + // this isn't actually relevant for versions, but keep it so that we + // don't run into trouble passing this.options around. + this.includePrerelease = !!options.includePrerelease + + const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]) + + if (!m) { + throw new TypeError(`Invalid Version: ${version}`) + } + + this.raw = version + + // these are actually numbers + this.major = +m[1] + this.minor = +m[2] + this.patch = +m[3] + + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError('Invalid major version') + } + + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError('Invalid minor version') + } + + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError('Invalid patch version') + } + + // numberify any prerelease numeric ids + if (!m[4]) { + this.prerelease = [] + } else { + this.prerelease = m[4].split('.').map((id) => { + if (/^[0-9]+$/.test(id)) { + const num = +id + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id + }) + } + + this.build = m[5] ? m[5].split('.') : [] + this.format() + } + + format () { + this.version = `${this.major}.${this.minor}.${this.patch}` + if (this.prerelease.length) { + this.version += `-${this.prerelease.join('.')}` + } + return this.version + } + + toString () { + return this.version + } + + compare (other) { + debug('SemVer.compare', this.version, this.options, other) + if (!(other instanceof SemVer)) { + if (typeof other === 'string' && other === this.version) { + return 0 + } + other = new SemVer(other, this.options) + } + + if (other.version === this.version) { + return 0 + } + + return this.compareMain(other) || this.comparePre(other) + } + + compareMain (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return ( + compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) + ) + } + + comparePre (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + // NOT having a prerelease is > having one + if (this.prerelease.length && !other.prerelease.length) { + return -1 + } else if (!this.prerelease.length && other.prerelease.length) { + return 1 + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0 + } + + let i = 0 + do { + const a = this.prerelease[i] + const b = other.prerelease[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) + } + + compareBuild (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + let i = 0 + do { + const a = this.build[i] + const b = other.build[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) + } + + // preminor will bump the version up to the next minor release, and immediately + // down to pre-release. premajor and prepatch work the same way. + inc (release, identifier) { + switch (release) { + case 'premajor': + this.prerelease.length = 0 + this.patch = 0 + this.minor = 0 + this.major++ + this.inc('pre', identifier) + break + case 'preminor': + this.prerelease.length = 0 + this.patch = 0 + this.minor++ + this.inc('pre', identifier) + break + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0 + this.inc('patch', identifier) + this.inc('pre', identifier) + break + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if (this.prerelease.length === 0) { + this.inc('patch', identifier) + } + this.inc('pre', identifier) + break + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + if ( + this.minor !== 0 || + this.patch !== 0 || + this.prerelease.length === 0 + ) { + this.major++ + } + this.minor = 0 + this.patch = 0 + this.prerelease = [] + break + case 'minor': + // If this is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++ + } + this.patch = 0 + this.prerelease = [] + break + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if (this.prerelease.length === 0) { + this.patch++ + } + this.prerelease = [] + break + // This probably shouldn't be used publicly. + // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction. + case 'pre': + if (this.prerelease.length === 0) { + this.prerelease = [0] + } else { + let i = this.prerelease.length + while (--i >= 0) { + if (typeof this.prerelease[i] === 'number') { + this.prerelease[i]++ + i = -2 + } + } + if (i === -1) { + // didn't increment anything + this.prerelease.push(0) + } + } + if (identifier) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + if (this.prerelease[0] === identifier) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0] + } + } else { + this.prerelease = [identifier, 0] + } + } + break + + default: + throw new Error(`invalid increment argument: ${release}`) + } + this.format() + this.raw = this.version + return this + } +} + +module.exports = SemVer + + +/***/ }), +/* 66 */, +/* 67 */, +/* 68 */, +/* 69 */, +/* 70 */, +/* 71 */, +/* 72 */, +/* 73 */, +/* 74 */, +/* 75 */ +/***/ (function(module, __unusedexports, __webpack_require__) { "use strict"; -Object.defineProperty(exports, "__esModule", { value: true }); -var FixedSizeSet_1 = __webpack_require__(319); -exports.FixedSizeSet = FixedSizeSet_1.FixedSizeSet; -var ObjectCache_1 = __webpack_require__(973); -exports.ObjectCache = ObjectCache_1.ObjectCache; -var CompareCache_1 = __webpack_require__(441); -exports.CompareCache = CompareCache_1.CompareCache; -var Lazy_1 = __webpack_require__(271); -exports.Lazy = Lazy_1.Lazy; -/** - * Applies the mixin to a given class. - * - * @param baseClass - class to receive the mixin - * @param mixinClass - mixin class - * @param overrides - an array with names of function overrides. Base class - * functions whose names are in this array will be kept by prepending an - * underscore to their names. - */ -function applyMixin(baseClass, mixinClass, ...overrides) { - Object.getOwnPropertyNames(mixinClass.prototype).forEach(name => { - if (overrides.includes(name)) { - const orgPropDesc = Object.getOwnPropertyDescriptor(baseClass.prototype, name); - /* istanbul ignore else */ - if (orgPropDesc) { - Object.defineProperty(baseClass.prototype, "_" + name, orgPropDesc); - } - } - const propDesc = Object.getOwnPropertyDescriptor(mixinClass.prototype, name); - /* istanbul ignore else */ - if (propDesc) { - Object.defineProperty(baseClass.prototype, name, propDesc); - } - }); + +var Type = __webpack_require__(945); + +var _toString = Object.prototype.toString; + +function resolveYamlPairs(data) { + if (data === null) return true; + + var index, length, pair, keys, result, + object = data; + + result = new Array(object.length); + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + + if (_toString.call(pair) !== '[object Object]') return false; + + keys = Object.keys(pair); + + if (keys.length !== 1) return false; + + result[index] = [ keys[0], pair[keys[0]] ]; + } + + return true; } -exports.applyMixin = applyMixin; -/** - * Applies default values to the given object. - * - * @param obj - an object - * @param defaults - an object with default values - * @param overwrite - if set to `true` defaults object always overwrites object - * values, whether they are `undefined` or not. - */ -function applyDefaults(obj, defaults, overwrite = false) { - const result = clone(obj || {}); - forEachObject(defaults, (key, val) => { - if (isObject(val)) { - result[key] = applyDefaults(result[key], val); - } - else if (overwrite || result[key] === undefined) { - result[key] = val; - } - }); - return result; + +function constructYamlPairs(data) { + if (data === null) return []; + + var index, length, pair, keys, result, + object = data; + + result = new Array(object.length); + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + + keys = Object.keys(pair); + + result[index] = [ keys[0], pair[keys[0]] ]; + } + + return result; } -exports.applyDefaults = applyDefaults; -/** - * Iterates over items of an array or set. - * - * @param arr - array or set to iterate - * @param callback - a callback function which receives each array item as its - * single argument - * @param thisArg - the value of this inside callback - */ -function forEachArray(arr, callback, thisArg) { - arr.forEach(callback, thisArg); -} -exports.forEachArray = forEachArray; -/** - * Iterates over key/value pairs of a map or object. - * - * @param obj - map or object to iterate - * @param callback - a callback function which receives object key as its first - * argument and object value as its second argument - * @param thisArg - the value of this inside callback - */ -function forEachObject(obj, callback, thisArg) { - if (isMap(obj)) { - obj.forEach((value, key) => callback.call(thisArg, key, value)); - } - else { - for (const key in obj) { - /* istanbul ignore else */ - if (obj.hasOwnProperty(key)) { - callback.call(thisArg, key, obj[key]); - } - } - } -} -exports.forEachObject = forEachObject; -/** - * Returns the number of entries in an array or set. - * - * @param arr - array or set - */ -function arrayLength(obj) { - if (isSet(obj)) { - return obj.size; - } - else { - return obj.length; - } -} -exports.arrayLength = arrayLength; -/** - * Returns the number of entries in a map or object. - * - * @param obj - map or object - */ -function objectLength(obj) { - if (isMap(obj)) { - return obj.size; - } - else { - return Object.keys(obj).length; - } -} -exports.objectLength = objectLength; -/** - * Gets the value of a key from a map or object. - * - * @param obj - map or object - * @param key - the key to retrieve - */ -function getObjectValue(obj, key) { - if (isMap(obj)) { - return obj.get(key); - } - else { - return obj[key]; - } -} -exports.getObjectValue = getObjectValue; -/** - * Removes a property from a map or object. - * - * @param obj - map or object - * @param key - the key to remove - */ -function removeObjectValue(obj, key) { - if (isMap(obj)) { - obj.delete(key); - } - else { - delete obj[key]; - } -} -exports.removeObjectValue = removeObjectValue; -/** - * Deep clones the given object. - * - * @param obj - an object - */ -function clone(obj) { - if (isFunction(obj)) { - return obj; - } - else if (isArray(obj)) { - const result = []; - for (const item of obj) { - result.push(clone(item)); - } - return result; - } - else if (isObject(obj)) { - const result = {}; - for (const key in obj) { - /* istanbul ignore next */ - if (obj.hasOwnProperty(key)) { - const val = obj[key]; - result[key] = clone(val); - } - } - return result; - } - else { - return obj; - } -} -exports.clone = clone; -/** - * Type guard for boolean types - * - * @param x - a variable to type check - */ -function isBoolean(x) { - return typeof x === "boolean"; -} -exports.isBoolean = isBoolean; -/** - * Type guard for numeric types - * - * @param x - a variable to type check - */ -function isNumber(x) { - return typeof x === "number"; -} -exports.isNumber = isNumber; -/** - * Type guard for strings - * - * @param x - a variable to type check - */ -function isString(x) { - return typeof x === "string"; -} -exports.isString = isString; -/** - * Type guard for function objects - * - * @param x - a variable to type check - */ -function isFunction(x) { - return !!x && Object.prototype.toString.call(x) === '[object Function]'; -} -exports.isFunction = isFunction; -/** - * Type guard for JS objects - * - * _Note:_ Functions are objects too - * - * @param x - a variable to type check - */ -function isObject(x) { - const type = typeof x; - return !!x && (type === 'function' || type === 'object'); -} -exports.isObject = isObject; -/** - * Type guard for arrays - * - * @param x - a variable to type check - */ -function isArray(x) { - return Array.isArray(x); -} -exports.isArray = isArray; -/** - * Type guard for sets. - * - * @param x - a variable to check - */ -function isSet(x) { - return x instanceof Set; -} -exports.isSet = isSet; -/** - * Type guard for maps. - * - * @param x - a variable to check - */ -function isMap(x) { - return x instanceof Map; -} -exports.isMap = isMap; -/** - * Determines if `x` is an empty Array or an Object with no own properties. - * - * @param x - a variable to check - */ -function isEmpty(x) { - if (isArray(x)) { - return !x.length; - } - else if (isSet(x)) { - return !x.size; - } - else if (isMap(x)) { - return !x.size; - } - else if (isObject(x)) { - for (const key in x) { - if (x.hasOwnProperty(key)) { - return false; - } - } - return true; - } - return false; -} -exports.isEmpty = isEmpty; -/** - * Determines if `x` is a plain Object. - * - * @param x - a variable to check - */ -function isPlainObject(x) { - if (isObject(x)) { - const proto = Object.getPrototypeOf(x); - const ctor = proto.constructor; - return proto && ctor && - (typeof ctor === 'function') && (ctor instanceof ctor) && - (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object)); - } - return false; -} -exports.isPlainObject = isPlainObject; -/** - * Determines if `x` is an iterable Object. - * - * @param x - a variable to check - */ -function isIterable(x) { - return x && (typeof x[Symbol.iterator] === 'function'); -} -exports.isIterable = isIterable; -/** - * Gets the primitive value of an object. - */ -function getValue(obj) { - if (isFunction(obj.valueOf)) { - return obj.valueOf(); - } - else { - return obj; - } -} -exports.getValue = getValue; -/** - * UTF-8 encodes the given string. - * - * @param input - a string - */ -function utf8Encode(input) { - const bytes = new Uint8Array(input.length * 4); - let byteIndex = 0; - for (let i = 0; i < input.length; i++) { - let char = input.charCodeAt(i); - if (char < 128) { - bytes[byteIndex++] = char; - continue; - } - else if (char < 2048) { - bytes[byteIndex++] = char >> 6 | 192; - } - else { - if (char > 0xd7ff && char < 0xdc00) { - if (++i >= input.length) { - throw new Error("Incomplete surrogate pair."); - } - const c2 = input.charCodeAt(i); - if (c2 < 0xdc00 || c2 > 0xdfff) { - throw new Error("Invalid surrogate character."); - } - char = 0x10000 + ((char & 0x03ff) << 10) + (c2 & 0x03ff); - bytes[byteIndex++] = char >> 18 | 240; - bytes[byteIndex++] = char >> 12 & 63 | 128; - } - else { - bytes[byteIndex++] = char >> 12 | 224; - } - bytes[byteIndex++] = char >> 6 & 63 | 128; - } - bytes[byteIndex++] = char & 63 | 128; - } - return bytes.subarray(0, byteIndex); -} -exports.utf8Encode = utf8Encode; -/** - * UTF-8 decodes the given byte sequence into a string. - * - * @param bytes - a byte sequence - */ -function utf8Decode(bytes) { - let result = ""; - let i = 0; - while (i < bytes.length) { - var c = bytes[i++]; - if (c > 127) { - if (c > 191 && c < 224) { - if (i >= bytes.length) { - throw new Error("Incomplete 2-byte sequence."); - } - c = (c & 31) << 6 | bytes[i++] & 63; - } - else if (c > 223 && c < 240) { - if (i + 1 >= bytes.length) { - throw new Error("Incomplete 3-byte sequence."); - } - c = (c & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63; - } - else if (c > 239 && c < 248) { - if (i + 2 >= bytes.length) { - throw new Error("Incomplete 4-byte sequence."); - } - c = (c & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63; - } - else { - throw new Error("Unknown multi-byte start."); - } - } - if (c <= 0xffff) { - result += String.fromCharCode(c); - } - else if (c <= 0x10ffff) { - c -= 0x10000; - result += String.fromCharCode(c >> 10 | 0xd800); - result += String.fromCharCode(c & 0x3FF | 0xdc00); - } - else { - throw new Error("Code point exceeds UTF-16 limit."); - } - } - return result; -} -exports.utf8Decode = utf8Decode; -//# sourceMappingURL=index.js.map + +module.exports = new Type('tag:yaml.org,2002:pairs', { + kind: 'sequence', + resolve: resolveYamlPairs, + construct: constructYamlPairs +}); + /***/ }), - -/***/ 82: +/* 76 */, +/* 77 */, +/* 78 */, +/* 79 */, +/* 80 */, +/* 81 */, +/* 82 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -3807,38 +3911,181 @@ exports.toCommandValue = toCommandValue; //# sourceMappingURL=utils.js.map /***/ }), +/* 83 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { -/***/ 86: +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +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.JavaBase = void 0; +const tc = __importStar(__webpack_require__(139)); +const core = __importStar(__webpack_require__(470)); +const semver_1 = __importDefault(__webpack_require__(876)); +const path_1 = __importDefault(__webpack_require__(622)); +const httpm = __importStar(__webpack_require__(539)); +const util_1 = __webpack_require__(322); +class JavaBase { + constructor(distribution, installerOptions) { + this.distribution = distribution; + this.http = new httpm.HttpClient('actions/setup-java', undefined, { + allowRetries: true, + maxRetries: 3 + }); + ({ version: this.version, stable: this.stable } = this.normalizeVersion(installerOptions.version)); + this.architecture = installerOptions.architecture; + this.packageType = installerOptions.packageType; + } + setupJava() { + return __awaiter(this, void 0, void 0, function* () { + let foundJava = this.findInToolcache(); + if (foundJava) { + core.info(`Resolved Java ${foundJava.version} from tool-cache`); + } + else { + core.info(`Java ${this.version} was not found in tool-cache. Trying to download...`); + const javaRelease = yield this.findPackageForDownload(this.version); + foundJava = yield this.downloadTool(javaRelease); + core.info(`Java ${foundJava.version} was downloaded`); + } + core.info(`Setting Java ${foundJava.version} as the default`); + this.setJavaDefault(foundJava.version, foundJava.path); + return foundJava; + }); + } + get toolcacheFolderName() { + return `Java_${this.distribution}_${this.packageType}`; + } + getToolcacheVersionName(version) { + if (!this.stable) { + const cleanVersion = semver_1.default.clean(version); + return `${cleanVersion}-ea`; + } + return version; + } + findInToolcache() { + // we can't use tc.find directly because firstly, we need to filter versions by stability flag + // if *-ea is provided, take only ea versions from toolcache, otherwise - only stable versions + const availableVersions = tc + .findAllVersions(this.toolcacheFolderName, this.architecture) + .filter(item => item.endsWith('-ea') === !this.stable); + const satisfiedVersions = availableVersions + .filter(item => util_1.isVersionSatisfies(this.version, item.replace(/-ea$/, ''))) + .sort(semver_1.default.rcompare); + if (!satisfiedVersions || satisfiedVersions.length === 0) { + return null; + } + const javaPath = util_1.getToolcachePath(this.toolcacheFolderName, satisfiedVersions[0], this.architecture); + if (!javaPath) { + return null; + } + return { + version: util_1.getVersionFromToolcachePath(javaPath), + path: javaPath + }; + } + normalizeVersion(version) { + let stable = true; + if (version.endsWith('-ea')) { + version = version.replace(/-ea$/, ''); + stable = false; + } + else if (version.includes('-ea.')) { + // transform '11.0.3-ea.2' -> '11.0.3+2' + version = version.replace('-ea.', '+'); + stable = false; + } + if (!semver_1.default.validRange(version)) { + throw new Error(`The string '${version}' is not valid SemVer notation for a Java version. Please check README file for code snippets and more detailed information`); + } + return { + version, + stable + }; + } + setJavaDefault(version, toolPath) { + core.exportVariable('JAVA_HOME', toolPath); + core.addPath(path_1.default.join(toolPath, 'bin')); + core.setOutput('distribution', this.distribution); + core.setOutput('path', toolPath); + core.setOutput('version', version); + } +} +exports.JavaBase = JavaBase; + + +/***/ }), +/* 84 */, +/* 85 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const neq = (a, b, loose) => compare(a, b, loose) !== 0 +module.exports = neq + + +/***/ }), +/* 86 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const DOMImplementationImpl_1 = __webpack_require__(290); -const WindowImpl_1 = __webpack_require__(932); -const XMLDocumentImpl_1 = __webpack_require__(661); -const DocumentImpl_1 = __webpack_require__(488); -const AbortControllerImpl_1 = __webpack_require__(990); -const AbortSignalImpl_1 = __webpack_require__(784); -const DocumentTypeImpl_1 = __webpack_require__(558); -const ElementImpl_1 = __webpack_require__(695); -const DocumentFragmentImpl_1 = __webpack_require__(796); -const ShadowRootImpl_1 = __webpack_require__(581); -const AttrImpl_1 = __webpack_require__(866); -const TextImpl_1 = __webpack_require__(820); -const CDATASectionImpl_1 = __webpack_require__(920); -const CommentImpl_1 = __webpack_require__(760); -const ProcessingInstructionImpl_1 = __webpack_require__(619); -const HTMLCollectionImpl_1 = __webpack_require__(204); -const NodeListImpl_1 = __webpack_require__(636); -const NodeListStaticImpl_1 = __webpack_require__(266); -const NamedNodeMapImpl_1 = __webpack_require__(88); -const RangeImpl_1 = __webpack_require__(90); -const NodeIteratorImpl_1 = __webpack_require__(800); -const TreeWalkerImpl_1 = __webpack_require__(646); -const NodeFilterImpl_1 = __webpack_require__(774); -const MutationRecordImpl_1 = __webpack_require__(730); -const DOMTokenListImpl_1 = __webpack_require__(742); +var DOMImplementationImpl_1 = __webpack_require__(174); +var WindowImpl_1 = __webpack_require__(932); +var XMLDocumentImpl_1 = __webpack_require__(661); +var DocumentImpl_1 = __webpack_require__(488); +var AbortControllerImpl_1 = __webpack_require__(990); +var AbortSignalImpl_1 = __webpack_require__(784); +var DocumentTypeImpl_1 = __webpack_require__(558); +var ElementImpl_1 = __webpack_require__(695); +var DocumentFragmentImpl_1 = __webpack_require__(796); +var ShadowRootImpl_1 = __webpack_require__(581); +var AttrImpl_1 = __webpack_require__(866); +var TextImpl_1 = __webpack_require__(820); +var CDATASectionImpl_1 = __webpack_require__(920); +var CommentImpl_1 = __webpack_require__(760); +var ProcessingInstructionImpl_1 = __webpack_require__(619); +var HTMLCollectionImpl_1 = __webpack_require__(204); +var NodeListImpl_1 = __webpack_require__(636); +var NodeListStaticImpl_1 = __webpack_require__(266); +var NamedNodeMapImpl_1 = __webpack_require__(88); +var RangeImpl_1 = __webpack_require__(90); +var NodeIteratorImpl_1 = __webpack_require__(800); +var TreeWalkerImpl_1 = __webpack_require__(646); +var NodeFilterImpl_1 = __webpack_require__(774); +var MutationRecordImpl_1 = __webpack_require__(730); +var DOMTokenListImpl_1 = __webpack_require__(425); /** * Creates a `DOMImplementation`. * @@ -4009,7 +4256,8 @@ exports.create_processingInstruction = create_processingInstruction; * @param root - root node * @param filter - node filter */ -function create_htmlCollection(root, filter = (() => true)) { +function create_htmlCollection(root, filter) { + if (filter === void 0) { filter = (function () { return true; }); } return HTMLCollectionImpl_1.HTMLCollectionImpl._create(root, filter); } exports.create_htmlCollection = create_htmlCollection; @@ -4116,38 +4364,53 @@ exports.create_domTokenList = create_domTokenList; //# sourceMappingURL=CreateAlgorithm.js.map /***/ }), - -/***/ 87: +/* 87 */ /***/ (function(module) { module.exports = require("os"); /***/ }), - -/***/ 88: +/* 88 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const DOMException_1 = __webpack_require__(35); -const algorithm_1 = __webpack_require__(163); +var DOMException_1 = __webpack_require__(35); +var algorithm_1 = __webpack_require__(163); /** * Represents a collection of attributes. */ -class NamedNodeMapImpl extends Array { +var NamedNodeMapImpl = /** @class */ (function (_super) { + __extends(NamedNodeMapImpl, _super); /** * Initializes a new instance of `NamedNodeMap`. * * @param element - parent element */ - constructor(element) { - super(); - this._element = element; + function NamedNodeMapImpl(element) { + var _this = _super.call(this) || this; + _this._element = element; + // TODO: This workaround is needed to extend Array in ES5 + Object.setPrototypeOf(_this, NamedNodeMapImpl.prototype); + return _this; } - _asArray() { return this; } + NamedNodeMapImpl.prototype._asArray = function () { return this; }; /** @inheritdoc */ - item(index) { + NamedNodeMapImpl.prototype.item = function (index) { /** * 1. If index is equal to or greater than context object’s attribute list’s * size, then return null. @@ -4155,194 +4418,225 @@ class NamedNodeMapImpl extends Array { * */ return this[index] || null; - } + }; /** @inheritdoc */ - getNamedItem(qualifiedName) { + NamedNodeMapImpl.prototype.getNamedItem = function (qualifiedName) { /** * The getNamedItem(qualifiedName) method, when invoked, must return the * result of getting an attribute given qualifiedName and element. */ return algorithm_1.element_getAnAttributeByName(qualifiedName, this._element); - } + }; /** @inheritdoc */ - getNamedItemNS(namespace, localName) { + NamedNodeMapImpl.prototype.getNamedItemNS = function (namespace, localName) { /** * The getNamedItemNS(namespace, localName) method, when invoked, must * return the result of getting an attribute given namespace, localName, * and element. */ return algorithm_1.element_getAnAttributeByNamespaceAndLocalName(namespace || '', localName, this._element); - } + }; /** @inheritdoc */ - setNamedItem(attr) { + NamedNodeMapImpl.prototype.setNamedItem = function (attr) { /** * The setNamedItem(attr) and setNamedItemNS(attr) methods, when invoked, * must return the result of setting an attribute given attr and element. */ return algorithm_1.element_setAnAttribute(attr, this._element); - } + }; /** @inheritdoc */ - setNamedItemNS(attr) { + NamedNodeMapImpl.prototype.setNamedItemNS = function (attr) { return algorithm_1.element_setAnAttribute(attr, this._element); - } + }; /** @inheritdoc */ - removeNamedItem(qualifiedName) { + NamedNodeMapImpl.prototype.removeNamedItem = function (qualifiedName) { /** * 1. Let attr be the result of removing an attribute given qualifiedName * and element. * 2. If attr is null, then throw a "NotFoundError" DOMException. * 3. Return attr. */ - const attr = algorithm_1.element_removeAnAttributeByName(qualifiedName, this._element); + var attr = algorithm_1.element_removeAnAttributeByName(qualifiedName, this._element); if (attr === null) throw new DOMException_1.NotFoundError(); return attr; - } + }; /** @inheritdoc */ - removeNamedItemNS(namespace, localName) { + NamedNodeMapImpl.prototype.removeNamedItemNS = function (namespace, localName) { /** * 1. Let attr be the result of removing an attribute given namespace, * localName, and element. * 2. If attr is null, then throw a "NotFoundError" DOMException. * 3. Return attr. */ - const attr = algorithm_1.element_removeAnAttributeByNamespaceAndLocalName(namespace || '', localName, this._element); + var attr = algorithm_1.element_removeAnAttributeByNamespaceAndLocalName(namespace || '', localName, this._element); if (attr === null) throw new DOMException_1.NotFoundError(); return attr; - } + }; /** * Creates a new `NamedNodeMap`. * * @param element - parent element */ - static _create(element) { + NamedNodeMapImpl._create = function (element) { return new NamedNodeMapImpl(element); - } -} + }; + return NamedNodeMapImpl; +}(Array)); exports.NamedNodeMapImpl = NamedNodeMapImpl; //# sourceMappingURL=NamedNodeMapImpl.js.map /***/ }), - -/***/ 90: +/* 89 */, +/* 90 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const _1 = __webpack_require__(113); -const interfaces_1 = __webpack_require__(970); -const AbstractRangeImpl_1 = __webpack_require__(537); -const DOMException_1 = __webpack_require__(35); -const algorithm_1 = __webpack_require__(163); -const WebIDLAlgorithm_1 = __webpack_require__(495); -const util_1 = __webpack_require__(918); +var DOMImpl_1 = __webpack_require__(648); +var interfaces_1 = __webpack_require__(970); +var AbstractRangeImpl_1 = __webpack_require__(413); +var DOMException_1 = __webpack_require__(35); +var algorithm_1 = __webpack_require__(163); +var WebIDLAlgorithm_1 = __webpack_require__(495); +var util_1 = __webpack_require__(918); /** * Represents a live range. */ -class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { +var RangeImpl = /** @class */ (function (_super) { + __extends(RangeImpl, _super); /** * Initializes a new instance of `Range`. */ - constructor() { - super(); + function RangeImpl() { + var _this = _super.call(this) || this; /** * The Range() constructor, when invoked, must return a new live range with * (current global object’s associated Document, 0) as its start and end. */ - const doc = _1.dom.window._associatedDocument; - this._start = [doc, 0]; - this._end = [doc, 0]; - _1.dom.rangeList.add(this); + var doc = DOMImpl_1.dom.window._associatedDocument; + _this._start = [doc, 0]; + _this._end = [doc, 0]; + DOMImpl_1.dom.rangeList.add(_this); + return _this; } - /** @inheritdoc */ - get commonAncestorContainer() { - /** - * 1. Let container be start node. - * 2. While container is not an inclusive ancestor of end node, let - * container be container’s parent. - * 3. Return container. - */ - let container = this._start[0]; - while (!algorithm_1.tree_isAncestorOf(this._end[0], container, true)) { - if (container._parent === null) { - throw new Error("Parent node is null."); + Object.defineProperty(RangeImpl.prototype, "commonAncestorContainer", { + /** @inheritdoc */ + get: function () { + /** + * 1. Let container be start node. + * 2. While container is not an inclusive ancestor of end node, let + * container be container’s parent. + * 3. Return container. + */ + var container = this._start[0]; + while (!algorithm_1.tree_isAncestorOf(this._end[0], container, true)) { + if (container._parent === null) { + throw new Error("Parent node is null."); + } + container = container._parent; } - container = container._parent; - } - return container; - } + return container; + }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - setStart(node, offset) { + RangeImpl.prototype.setStart = function (node, offset) { /** * The setStart(node, offset) method, when invoked, must set the start of * context object to boundary point (node, offset). */ algorithm_1.range_setTheStart(this, node, offset); - } + }; /** @inheritdoc */ - setEnd(node, offset) { + RangeImpl.prototype.setEnd = function (node, offset) { /** * The setEnd(node, offset) method, when invoked, must set the end of * context object to boundary point (node, offset). */ algorithm_1.range_setTheEnd(this, node, offset); - } + }; /** @inheritdoc */ - setStartBefore(node) { + RangeImpl.prototype.setStartBefore = function (node) { /** * 1. Let parent be node’s parent. * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException. * 3. Set the start of the context object to boundary point * (parent, node’s index). */ - let parent = node._parent; + var parent = node._parent; if (parent === null) throw new DOMException_1.InvalidNodeTypeError(); algorithm_1.range_setTheStart(this, parent, algorithm_1.tree_index(node)); - } + }; /** @inheritdoc */ - setStartAfter(node) { + RangeImpl.prototype.setStartAfter = function (node) { /** * 1. Let parent be node’s parent. * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException. * 3. Set the start of the context object to boundary point * (parent, node’s index plus 1). */ - let parent = node._parent; + var parent = node._parent; if (parent === null) throw new DOMException_1.InvalidNodeTypeError(); algorithm_1.range_setTheStart(this, parent, algorithm_1.tree_index(node) + 1); - } + }; /** @inheritdoc */ - setEndBefore(node) { + RangeImpl.prototype.setEndBefore = function (node) { /** * 1. Let parent be node’s parent. * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException. * 3. Set the end of the context object to boundary point * (parent, node’s index). */ - let parent = node._parent; + var parent = node._parent; if (parent === null) throw new DOMException_1.InvalidNodeTypeError(); algorithm_1.range_setTheEnd(this, parent, algorithm_1.tree_index(node)); - } + }; /** @inheritdoc */ - setEndAfter(node) { + RangeImpl.prototype.setEndAfter = function (node) { /** * 1. Let parent be node’s parent. * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException. * 3. Set the end of the context object to boundary point * (parent, node’s index plus 1). */ - let parent = node._parent; + var parent = node._parent; if (parent === null) throw new DOMException_1.InvalidNodeTypeError(); algorithm_1.range_setTheEnd(this, parent, algorithm_1.tree_index(node) + 1); - } + }; /** @inheritdoc */ - collapse(toStart) { + RangeImpl.prototype.collapse = function (toStart) { /** * The collapse(toStart) method, when invoked, must if toStart is true, * set end to start, and set start to end otherwise. @@ -4353,17 +4647,17 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { else { this._start = this._end; } - } + }; /** @inheritdoc */ - selectNode(node) { + RangeImpl.prototype.selectNode = function (node) { /** * The selectNode(node) method, when invoked, must select node within * context object. */ algorithm_1.range_select(node, this); - } + }; /** @inheritdoc */ - selectNodeContents(node) { + RangeImpl.prototype.selectNodeContents = function (node) { /** * 1. If node is a doctype, throw an "InvalidNodeTypeError" DOMException. * 2. Let length be the length of node. @@ -4372,12 +4666,12 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { */ if (util_1.Guard.isDocumentTypeNode(node)) throw new DOMException_1.InvalidNodeTypeError(); - const length = algorithm_1.tree_nodeLength(node); + var length = algorithm_1.tree_nodeLength(node); this._start = [node, 0]; this._end = [node, length]; - } + }; /** @inheritdoc */ - compareBoundaryPoints(how, sourceRange) { + RangeImpl.prototype.compareBoundaryPoints = function (how, sourceRange) { /** * 1. If how is not one of * - START_TO_START, @@ -4410,8 +4704,8 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { * Let this point be the context object’s start. Let other point be * sourceRange’s end. */ - let thisPoint; - let otherPoint; + var thisPoint; + var otherPoint; switch (how) { case interfaces_1.HowToCompare.StartToStart: thisPoint = this._start; @@ -4442,7 +4736,7 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { * - after * Return 1. */ - const position = algorithm_1.boundaryPoint_position(thisPoint, otherPoint); + var position = algorithm_1.boundaryPoint_position(thisPoint, otherPoint); if (position === interfaces_1.BoundaryPosition.Before) { return -1; } @@ -4452,9 +4746,10 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { else { return 0; } - } + }; /** @inheritdoc */ - deleteContents() { + RangeImpl.prototype.deleteContents = function () { + var e_1, _a, e_2, _b; /** * 1. If the context object is collapsed, then return. * 2. Let original start node, original start offset, original end node, @@ -4463,10 +4758,10 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { */ if (algorithm_1.range_collapsed(this)) return; - const originalStartNode = this._startNode; - const originalStartOffset = this._startOffset; - const originalEndNode = this._endNode; - const originalEndOffset = this._endOffset; + var originalStartNode = this._startNode; + var originalStartOffset = this._startOffset; + var originalEndNode = this._endNode; + var originalEndOffset = this._endOffset; /** * 3. If original start node and original end node are the same, and they * are a Text, ProcessingInstruction, or Comment node, replace data with @@ -4484,16 +4779,26 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { * the context object, in tree order, omitting any node whose parent is also * contained in the context object. */ - const nodesToRemove = []; - for (const node of algorithm_1.range_getContainedNodes(this)) { - const parent = node._parent; - if (parent !== null && algorithm_1.range_isContained(parent, this)) { - continue; + var nodesToRemove = []; + try { + for (var _c = __values(algorithm_1.range_getContainedNodes(this)), _d = _c.next(); !_d.done; _d = _c.next()) { + var node = _d.value; + var parent = node._parent; + if (parent !== null && algorithm_1.range_isContained(parent, this)) { + continue; + } + nodesToRemove.push(node); } - nodesToRemove.push(node); } - let newNode; - let newOffset; + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_d && !_d.done && (_a = _c.return)) _a.call(_c); + } + finally { if (e_1) throw e_1.error; } + } + var newNode; + var newOffset; if (algorithm_1.tree_isAncestorOf(originalEndNode, originalStartNode, true)) { /** * 5. If original start node is an inclusive ancestor of original end @@ -4512,7 +4817,7 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { * 6.3. Set new node to the parent of reference node, and new offset to * one plus the index of reference node. */ - let referenceNode = originalStartNode; + var referenceNode = originalStartNode; while (referenceNode._parent !== null && !algorithm_1.tree_isAncestorOf(originalEndNode, referenceNode._parent, true)) { referenceNode = referenceNode._parent; @@ -4533,16 +4838,26 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { if (util_1.Guard.isCharacterDataNode(originalStartNode)) { algorithm_1.characterData_replaceData(originalStartNode, originalStartOffset, algorithm_1.tree_nodeLength(originalStartNode) - originalStartOffset, ''); } - /** - * 8. For each node in nodes to remove, in tree order, remove node from its - * parent. - */ - for (const node of nodesToRemove) { - /* istanbul ignore else */ - if (node._parent) { - algorithm_1.mutation_remove(node, node._parent); + try { + /** + * 8. For each node in nodes to remove, in tree order, remove node from its + * parent. + */ + for (var nodesToRemove_1 = __values(nodesToRemove), nodesToRemove_1_1 = nodesToRemove_1.next(); !nodesToRemove_1_1.done; nodesToRemove_1_1 = nodesToRemove_1.next()) { + var node = nodesToRemove_1_1.value; + /* istanbul ignore else */ + if (node._parent) { + algorithm_1.mutation_remove(node, node._parent); + } } } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (nodesToRemove_1_1 && !nodesToRemove_1_1.done && (_b = nodesToRemove_1.return)) _b.call(nodesToRemove_1); + } + finally { if (e_2) throw e_2.error; } + } /** * 9. If original end node is a Text, ProcessingInstruction, or Comment * node, replace data with node original end node, offset 0, count original @@ -4556,42 +4871,53 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { */ this._start = [newNode, newOffset]; this._end = [newNode, newOffset]; - } + }; /** @inheritdoc */ - extractContents() { + RangeImpl.prototype.extractContents = function () { /** * The extractContents() method, when invoked, must return the result of * extracting the context object. */ return algorithm_1.range_extract(this); - } + }; /** @inheritdoc */ - cloneContents() { + RangeImpl.prototype.cloneContents = function () { /** * The cloneContents() method, when invoked, must return the result of * cloning the contents of the context object. */ return algorithm_1.range_cloneTheContents(this); - } + }; /** @inheritdoc */ - insertNode(node) { + RangeImpl.prototype.insertNode = function (node) { /** * The insertNode(node) method, when invoked, must insert node into the * context object. */ return algorithm_1.range_insert(node, this); - } + }; /** @inheritdoc */ - surroundContents(newParent) { - /** - * 1. If a non-Text node is partially contained in the context object, then - * throw an "InvalidStateError" DOMException. - */ - for (const node of algorithm_1.range_getPartiallyContainedNodes(this)) { - if (!util_1.Guard.isTextNode(node)) { - throw new DOMException_1.InvalidStateError(); + RangeImpl.prototype.surroundContents = function (newParent) { + var e_3, _a; + try { + /** + * 1. If a non-Text node is partially contained in the context object, then + * throw an "InvalidStateError" DOMException. + */ + for (var _b = __values(algorithm_1.range_getPartiallyContainedNodes(this)), _c = _b.next(); !_c.done; _c = _b.next()) { + var node = _c.value; + if (!util_1.Guard.isTextNode(node)) { + throw new DOMException_1.InvalidStateError(); + } } } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_3) throw e_3.error; } + } /** * 2. If newParent is a Document, DocumentType, or DocumentFragment node, * then throw an "InvalidNodeTypeError" DOMException. @@ -4604,7 +4930,7 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { /** * 3. Let fragment be the result of extracting the context object. */ - const fragment = algorithm_1.range_extract(this); + var fragment = algorithm_1.range_extract(this); /** * 4. If newParent has children, then replace all with null within newParent. */ @@ -4621,26 +4947,26 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { * 7. Select newParent within the context object. */ algorithm_1.range_select(newParent, this); - } + }; /** @inheritdoc */ - cloneRange() { + RangeImpl.prototype.cloneRange = function () { /** * The cloneRange() method, when invoked, must return a new live range with * the same start and end as the context object. */ return algorithm_1.create_range(this._start, this._end); - } + }; /** @inheritdoc */ - detach() { + RangeImpl.prototype.detach = function () { /** * The detach() method, when invoked, must do nothing. * * since JS lacks weak references, we still use detach */ - _1.dom.rangeList.delete(this); - } + DOMImpl_1.dom.rangeList.delete(this); + }; /** @inheritdoc */ - isPointInRange(node, offset) { + RangeImpl.prototype.isPointInRange = function (node, offset) { /** * 1. If node’s root is different from the context object’s root, return false. */ @@ -4659,7 +4985,7 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { /** * 4. If (node, offset) is before start or after end, return false. */ - const bp = [node, offset]; + var bp = [node, offset]; if (algorithm_1.boundaryPoint_position(bp, this._start) === interfaces_1.BoundaryPosition.Before || algorithm_1.boundaryPoint_position(bp, this._end) === interfaces_1.BoundaryPosition.After) { return false; @@ -4668,9 +4994,9 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { * 5. Return true. */ return true; - } + }; /** @inheritdoc */ - comparePoint(node, offset) { + RangeImpl.prototype.comparePoint = function (node, offset) { /** * 1. If node’s root is different from the context object’s root, then throw * a "WrongDocumentError" DOMException. @@ -4689,7 +5015,7 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { * 5. If (node, offset) is after end, return 1. * 6. Return 0. */ - const bp = [node, offset]; + var bp = [node, offset]; if (algorithm_1.boundaryPoint_position(bp, this._start) === interfaces_1.BoundaryPosition.Before) { return -1; } @@ -4699,9 +5025,9 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { else { return 0; } - } + }; /** @inheritdoc */ - intersectsNode(node) { + RangeImpl.prototype.intersectsNode = function (node) { /** * 1. If node’s root is different from the context object’s root, return false. */ @@ -4712,13 +5038,13 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { * 2. Let parent be node’s parent. * 3. If parent is null, return true. */ - const parent = node._parent; + var parent = node._parent; if (parent === null) return true; /** * 4. Let offset be node’s index. */ - const offset = algorithm_1.tree_index(node); + var offset = algorithm_1.tree_index(node); /** * 5. If (parent, offset) is before end and (parent, offset plus 1) is * after start, return true. @@ -4731,12 +5057,13 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { * 6. Return false. */ return false; - } - toString() { + }; + RangeImpl.prototype.toString = function () { + var e_4, _a; /** * 1. Let s be the empty string. */ - let s = ''; + var s = ''; /** * 2. If the context object’s start node is the context object’s end node * and it is a Text node, then return the substring of that Text node’s data @@ -4754,15 +5081,25 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { if (util_1.Guard.isTextNode(this._startNode)) { s += this._startNode._data.substring(this._startOffset); } - /** - * 4. Append the concatenation of the data of all Text nodes that are - * contained in the context object, in tree order, to s. - */ - for (const child of algorithm_1.range_getContainedNodes(this)) { - if (util_1.Guard.isTextNode(child)) { - s += child._data; + try { + /** + * 4. Append the concatenation of the data of all Text nodes that are + * contained in the context object, in tree order, to s. + */ + for (var _b = __values(algorithm_1.range_getContainedNodes(this)), _c = _b.next(); !_c.done; _c = _b.next()) { + var child = _c.value; + if (util_1.Guard.isTextNode(child)) { + s += child._data; + } } } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_4) throw e_4.error; } + } /** * 5. If the context object’s end node is a Text node, then append the * substring of that node’s data from its start until the context object’s @@ -4775,27 +5112,28 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { * 6. Return s. */ return s; - } + }; /** * Creates a new `Range`. * * @param start - start point * @param end - end point */ - static _create(start, end) { - const range = new RangeImpl(); + RangeImpl._create = function (start, end) { + var range = new RangeImpl(); if (start) range._start = start; if (end) range._end = end; return range; - } -} + }; + RangeImpl.START_TO_START = 0; + RangeImpl.START_TO_END = 1; + RangeImpl.END_TO_END = 2; + RangeImpl.END_TO_START = 3; + return RangeImpl; +}(AbstractRangeImpl_1.AbstractRangeImpl)); exports.RangeImpl = RangeImpl; -RangeImpl.START_TO_START = 0; -RangeImpl.START_TO_END = 1; -RangeImpl.END_TO_END = 2; -RangeImpl.END_TO_START = 3; /** * Define constants on prototype. */ @@ -4806,48 +5144,84 @@ WebIDLAlgorithm_1.idl_defineConst(RangeImpl.prototype, "END_TO_START", 3); //# sourceMappingURL=RangeImpl.js.map /***/ }), - -/***/ 92: +/* 91 */, +/* 92 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const ObjectWriter_1 = __webpack_require__(419); -const util_1 = __webpack_require__(592); -const BaseWriter_1 = __webpack_require__(462); +var ObjectWriter_1 = __webpack_require__(419); +var util_1 = __webpack_require__(592); +var BaseWriter_1 = __webpack_require__(462); /** * Serializes XML nodes into a JSON string. */ -class JSONWriter extends BaseWriter_1.BaseWriter { +var JSONWriter = /** @class */ (function (_super) { + __extends(JSONWriter, _super); /** - * Produces an XML serialization of the given node. + * Initializes a new instance of `JSONWriter`. * - * @param node - node to serialize + * @param builderOptions - XML builder options * @param writerOptions - serialization options */ - serialize(node, writerOptions) { + function JSONWriter(builderOptions, writerOptions) { + var _this = _super.call(this, builderOptions) || this; // provide default options - const options = util_1.applyDefaults(writerOptions, { + _this._writerOptions = util_1.applyDefaults(writerOptions, { wellFormed: false, noDoubleEncoding: false, prettyPrint: false, indent: ' ', newline: '\n', offset: 0, - group: false + group: false, + verbose: false }); + return _this; + } + /** + * Produces an XML serialization of the given node. + * + * @param node - node to serialize + * @param writerOptions - serialization options + */ + JSONWriter.prototype.serialize = function (node) { // convert to object - const objectWriterOptions = util_1.applyDefaults(options, { + var objectWriterOptions = util_1.applyDefaults(this._writerOptions, { format: "object", wellFormed: false, noDoubleEncoding: false, }); - const objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions); - const val = objectWriter.serialize(node, objectWriterOptions); + var objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions); + var val = objectWriter.serialize(node); // recursively convert object into JSON string - return this._beginLine(options, 0) + this._convertObject(val, options); - } + return this._beginLine(this._writerOptions, 0) + this._convertObject(val, this._writerOptions); + }; /** * Produces an XML serialization of the given object. * @@ -4855,45 +5229,58 @@ class JSONWriter extends BaseWriter_1.BaseWriter { * @param options - serialization options * @param level - depth of the XML tree */ - _convertObject(obj, options, level = 0) { - let markup = ''; - const isLeaf = this._isLeafNode(obj); + JSONWriter.prototype._convertObject = function (obj, options, level) { + var e_1, _a; + var _this = this; + if (level === void 0) { level = 0; } + var markup = ''; + var isLeaf = this._isLeafNode(obj); if (util_1.isArray(obj)) { markup += '['; - const len = obj.length; - let i = 0; - for (const val of obj) { - markup += this._endLine(options, level + 1) + - this._beginLine(options, level + 1) + - this._convertObject(val, options, level + 1); - if (i < len - 1) { - markup += ','; + var len = obj.length; + var i = 0; + try { + for (var obj_1 = __values(obj), obj_1_1 = obj_1.next(); !obj_1_1.done; obj_1_1 = obj_1.next()) { + var val = obj_1_1.value; + markup += this._endLine(options, level + 1) + + this._beginLine(options, level + 1) + + this._convertObject(val, options, level + 1); + if (i < len - 1) { + markup += ','; + } + i++; } - i++; + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (obj_1_1 && !obj_1_1.done && (_a = obj_1.return)) _a.call(obj_1); + } + finally { if (e_1) throw e_1.error; } } markup += this._endLine(options, level) + this._beginLine(options, level); markup += ']'; } else if (util_1.isObject(obj)) { markup += '{'; - const len = util_1.objectLength(obj); - let i = 0; - util_1.forEachObject(obj, (key, val) => { + var len_1 = util_1.objectLength(obj); + var i_1 = 0; + util_1.forEachObject(obj, function (key, val) { if (isLeaf && options.prettyPrint) { markup += ' '; } else { - markup += this._endLine(options, level + 1) + this._beginLine(options, level + 1); + markup += _this._endLine(options, level + 1) + _this._beginLine(options, level + 1); } - markup += '"' + key + '":'; + markup += _this._key(key); if (options.prettyPrint) { markup += ' '; } - markup += this._convertObject(val, options, level + 1); - if (i < len - 1) { + markup += _this._convertObject(val, options, level + 1); + if (i_1 < len_1 - 1) { markup += ','; } - i++; + i_1++; }, this); if (isLeaf && options.prettyPrint) { markup += ' '; @@ -4904,10 +5291,10 @@ class JSONWriter extends BaseWriter_1.BaseWriter { markup += '}'; } else { - markup += '"' + obj + '"'; + markup += this._val(obj); } return markup; - } + }; /** * Produces characters to be prepended to a line of string in pretty-print * mode. @@ -4915,18 +5302,18 @@ class JSONWriter extends BaseWriter_1.BaseWriter { * @param options - serialization options * @param level - current depth of the XML tree */ - _beginLine(options, level) { + JSONWriter.prototype._beginLine = function (options, level) { if (!options.prettyPrint) { return ''; } else { - const indentLevel = options.offset + level + 1; + var indentLevel = options.offset + level + 1; if (indentLevel > 0) { return new Array(indentLevel).join(options.indent); } } return ''; - } + }; /** * Produces characters to be appended to a line of string in pretty-print * mode. @@ -4934,47 +5321,145 @@ class JSONWriter extends BaseWriter_1.BaseWriter { * @param options - serialization options * @param level - current depth of the XML tree */ - _endLine(options, level) { + JSONWriter.prototype._endLine = function (options, level) { if (!options.prettyPrint) { return ''; } else { return options.newline; } - } + }; + /** + * Produces a JSON key string delimited with double quotes. + */ + JSONWriter.prototype._key = function (key) { + return "\"" + key + "\":"; + }; + /** + * Produces a JSON value string delimited with double quotes. + */ + JSONWriter.prototype._val = function (val) { + return JSON.stringify(val); + }; /** * Determines if an object is a leaf node. * * @param obj */ - _isLeafNode(obj) { + JSONWriter.prototype._isLeafNode = function (obj) { return this._descendantCount(obj) <= 1; - } + }; /** * Counts the number of descendants of the given object. * * @param obj * @param count */ - _descendantCount(obj, count = 0) { + JSONWriter.prototype._descendantCount = function (obj, count) { + var _this = this; + if (count === void 0) { count = 0; } if (util_1.isArray(obj)) { - util_1.forEachArray(obj, val => count += this._descendantCount(val, count), this); + util_1.forEachArray(obj, function (val) { return count += _this._descendantCount(val, count); }, this); } else if (util_1.isObject(obj)) { - util_1.forEachObject(obj, (key, val) => count += this._descendantCount(val, count), this); + util_1.forEachObject(obj, function (key, val) { return count += _this._descendantCount(val, count); }, this); } else { count++; } return count; - } -} + }; + return JSONWriter; +}(BaseWriter_1.BaseWriter)); exports.JSONWriter = JSONWriter; //# sourceMappingURL=JSONWriter.js.map /***/ }), +/* 93 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 95: +"use strict"; + + + +var common = __webpack_require__(740); + + +function Mark(name, buffer, position, line, column) { + this.name = name; + this.buffer = buffer; + this.position = position; + this.line = line; + this.column = column; +} + + +Mark.prototype.getSnippet = function getSnippet(indent, maxLength) { + var head, start, tail, end, snippet; + + if (!this.buffer) return null; + + indent = indent || 4; + maxLength = maxLength || 75; + + head = ''; + start = this.position; + + while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) { + start -= 1; + if (this.position - start > (maxLength / 2 - 1)) { + head = ' ... '; + start += 5; + break; + } + } + + tail = ''; + end = this.position; + + while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) { + end += 1; + if (end - this.position > (maxLength / 2 - 1)) { + tail = ' ... '; + end -= 5; + break; + } + } + + snippet = this.buffer.slice(start, end); + + return common.repeat(' ', indent) + head + snippet + tail + '\n' + + common.repeat(' ', indent + this.position - start + head.length) + '^'; +}; + + +Mark.prototype.toString = function toString(compact) { + var snippet, where = ''; + + if (this.name) { + where += 'in "' + this.name + '" '; + } + + where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1); + + if (!compact) { + snippet = this.getSnippet(); + + if (snippet) { + where += ':\n' + snippet; + } + } + + return where; +}; + + +module.exports = Mark; + + +/***/ }), +/* 94 */, +/* 95 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; @@ -4988,20 +5473,33 @@ var ObjectWriter_1 = __webpack_require__(419); exports.ObjectWriter = ObjectWriter_1.ObjectWriter; var JSONWriter_1 = __webpack_require__(92); exports.JSONWriter = JSONWriter_1.JSONWriter; +var YAMLWriter_1 = __webpack_require__(325); +exports.YAMLWriter = YAMLWriter_1.YAMLWriter; //# sourceMappingURL=index.js.map /***/ }), - -/***/ 97: +/* 96 */, +/* 97 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const CodePoints_1 = __webpack_require__(11); -const ByteSequence_1 = __webpack_require__(263); -const Byte_1 = __webpack_require__(782); -const util_1 = __webpack_require__(68); +var CodePoints_1 = __webpack_require__(11); +var ByteSequence_1 = __webpack_require__(263); +var Byte_1 = __webpack_require__(782); +var util_1 = __webpack_require__(592); /** * Determines if the string `a` is a code unit prefix of string `b`. * @@ -5020,10 +5518,10 @@ function isCodeUnitPrefix(a, b) { * 2.4. Return false if aCodeUnit is different from bCodeUnit. * 2.5. Set i to i + 1. */ - let i = 0; + var i = 0; while (true) { - const aCodeUnit = i < a.length ? a.charCodeAt(i) : null; - const bCodeUnit = i < b.length ? b.charCodeAt(i) : null; + var aCodeUnit = i < a.length ? a.charCodeAt(i) : null; + var bCodeUnit = i < b.length ? b.charCodeAt(i) : null; if (aCodeUnit === null) return true; if (aCodeUnit !== bCodeUnit) @@ -5053,9 +5551,9 @@ function isCodeUnitLessThan(a, b) { return false; if (isCodeUnitPrefix(a, b)) return true; - for (let i = 0; i < Math.min(a.length, b.length); i++) { - const aCodeUnit = a.charCodeAt(i); - const bCodeUnit = b.charCodeAt(i); + for (var i = 0; i < Math.min(a.length, b.length); i++) { + var aCodeUnit = a.charCodeAt(i); + var bCodeUnit = b.charCodeAt(i); if (aCodeUnit === bCodeUnit) continue; return (aCodeUnit < bCodeUnit); @@ -5070,21 +5568,32 @@ exports.isCodeUnitLessThan = isCodeUnitLessThan; * @param str - a string */ function isomorphicEncode(str) { + var e_1, _a; /** * 1. Assert: input contains no code points greater than U+00FF. * 2. Return a byte sequence whose length is equal to input’s length and whose * bytes have the same values as input’s code points, in the same order. */ - const codePoints = Array.from(str); - const bytes = new Uint8Array(codePoints.length); - let i = 0; - for (const codePoint of str) { - const byte = codePoint.codePointAt(0); - console.assert(byte !== undefined && byte <= 0x00FF, "isomorphicEncode requires string bytes to be less than or equal to 0x00FF."); - if (byte !== undefined && byte <= 0x00FF) { - bytes[i++] = byte; + var codePoints = Array.from(str); + var bytes = new Uint8Array(codePoints.length); + var i = 0; + try { + for (var str_1 = __values(str), str_1_1 = str_1.next(); !str_1_1.done; str_1_1 = str_1.next()) { + var codePoint = str_1_1.value; + var byte = codePoint.codePointAt(0); + console.assert(byte !== undefined && byte <= 0x00FF, "isomorphicEncode requires string bytes to be less than or equal to 0x00FF."); + if (byte !== undefined && byte <= 0x00FF) { + bytes[i++] = byte; + } } } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (str_1_1 && !str_1_1.done && (_a = str_1.return)) _a.call(str_1); + } + finally { if (e_1) throw e_1.error; } + } return bytes; } exports.isomorphicEncode = isomorphicEncode; @@ -5106,19 +5615,30 @@ exports.isASCIIString = isASCIIString; * @param str - a string */ function asciiLowercase(str) { + var e_2, _a; /** * To ASCII lowercase a string, replace all ASCII upper alphas in the string * with their corresponding code point in ASCII lower alpha. */ - let result = ""; - for (const c of str) { - const code = c.codePointAt(0); - if (code !== undefined && code >= 0x41 && code <= 0x5A) { - result += String.fromCodePoint(code + 0x20); + var result = ""; + try { + for (var str_2 = __values(str), str_2_1 = str_2.next(); !str_2_1.done; str_2_1 = str_2.next()) { + var c = str_2_1.value; + var code = c.codePointAt(0); + if (code !== undefined && code >= 0x41 && code <= 0x5A) { + result += String.fromCodePoint(code + 0x20); + } + else { + result += c; + } } - else { - result += c; + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (str_2_1 && !str_2_1.done && (_a = str_2.return)) _a.call(str_2); } + finally { if (e_2) throw e_2.error; } } return result; } @@ -5129,19 +5649,30 @@ exports.asciiLowercase = asciiLowercase; * @param str - a string */ function asciiUppercase(str) { + var e_3, _a; /** * To ASCII uppercase a string, replace all ASCII lower alphas in the string * with their corresponding code point in ASCII upper alpha. */ - let result = ""; - for (const c of str) { - const code = c.codePointAt(0); - if (code !== undefined && code >= 0x61 && code <= 0x7A) { - result += String.fromCodePoint(code - 0x20); + var result = ""; + try { + for (var str_3 = __values(str), str_3_1 = str_3.next(); !str_3_1.done; str_3_1 = str_3.next()) { + var c = str_3_1.value; + var code = c.codePointAt(0); + if (code !== undefined && code >= 0x61 && code <= 0x7A) { + result += String.fromCodePoint(code - 0x20); + } + else { + result += c; + } } - else { - result += c; + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (str_3_1 && !str_3_1.done && (_a = str_3.return)) _a.call(str_3); } + finally { if (e_3) throw e_3.error; } } return result; } @@ -5180,12 +5711,23 @@ exports.asciiEncode = asciiEncode; * @param bytes - a byte sequence */ function asciiDecode(bytes) { - /** - * 1. Assert: All bytes in input are ASCII bytes. - * 2. Return the isomorphic decoding of input. - */ - for (const byte of bytes) { - console.assert(Byte_1.isASCIIByte(byte), "asciiDecode requires an ASCII byte sequence."); + var e_4, _a; + try { + /** + * 1. Assert: All bytes in input are ASCII bytes. + * 2. Return the isomorphic decoding of input. + */ + for (var bytes_1 = __values(bytes), bytes_1_1 = bytes_1.next(); !bytes_1_1.done; bytes_1_1 = bytes_1.next()) { + var byte = bytes_1_1.value; + console.assert(Byte_1.isASCIIByte(byte), "asciiDecode requires an ASCII byte sequence."); + } + } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (bytes_1_1 && !bytes_1_1.done && (_a = bytes_1.return)) _a.call(bytes_1); + } + finally { if (e_4) throw e_4.error; } } return ByteSequence_1.isomorphicDecode(bytes); } @@ -5266,7 +5808,7 @@ function collectASequenceOfCodePoints(condition, input, options) { */ if (!util_1.isArray(input)) return collectASequenceOfCodePoints(condition, Array.from(input), options); - let result = ""; + var result = ""; while (options.position < input.length && !!condition.call(null, input[options.position])) { result += input[options.position]; options.position++; @@ -5287,7 +5829,7 @@ function skipASCIIWhitespace(input, options) { * input given position. The collected code points are not used, but position * is still updated. */ - collectASequenceOfCodePoints(str => CodePoints_1.ASCIIWhiteSpace.test(str), input, options); + collectASequenceOfCodePoints(function (str) { return CodePoints_1.ASCIIWhiteSpace.test(str); }, input, options); } exports.skipASCIIWhitespace = skipASCIIWhitespace; /** @@ -5314,14 +5856,14 @@ function strictlySplit(input, delimiter) { */ if (!util_1.isArray(input)) return strictlySplit(Array.from(input), delimiter); - const options = { position: 0 }; - const tokens = []; - let token = collectASequenceOfCodePoints(str => delimiter !== str, input, options); + var options = { position: 0 }; + var tokens = []; + var token = collectASequenceOfCodePoints(function (str) { return delimiter !== str; }, input, options); tokens.push(token); while (options.position < input.length) { console.assert(input[options.position] === delimiter, "strictlySplit found no delimiter in input string."); options.position++; - token = collectASequenceOfCodePoints(str => delimiter !== str, input, options); + token = collectASequenceOfCodePoints(function (str) { return delimiter !== str; }, input, options); tokens.push(token); } return tokens; @@ -5347,11 +5889,11 @@ function splitAStringOnASCIIWhitespace(input) { */ if (!util_1.isArray(input)) return splitAStringOnASCIIWhitespace(Array.from(input)); - const options = { position: 0 }; - const tokens = []; + var options = { position: 0 }; + var tokens = []; skipASCIIWhitespace(input, options); while (options.position < input.length) { - const token = collectASequenceOfCodePoints(str => !CodePoints_1.ASCIIWhiteSpace.test(str), input, options); + var token = collectASequenceOfCodePoints(function (str) { return !CodePoints_1.ASCIIWhiteSpace.test(str); }, input, options); tokens.push(token); skipASCIIWhitespace(input, options); } @@ -5380,10 +5922,10 @@ function splitAStringOnCommas(input) { */ if (!util_1.isArray(input)) return splitAStringOnCommas(Array.from(input)); - const options = { position: 0 }; - const tokens = []; + var options = { position: 0 }; + var tokens = []; while (options.position < input.length) { - const token = collectASequenceOfCodePoints(str => str !== ',', input, options); + var token = collectASequenceOfCodePoints(function (str) { return str !== ','; }, input, options); tokens.push(stripLeadingAndTrailingASCIIWhitespace(token)); if (options.position < input.length) { console.assert(input[options.position] === ',', "splitAStringOnCommas found no delimiter in input string."); @@ -5399,7 +5941,8 @@ exports.splitAStringOnCommas = splitAStringOnCommas; * @param list - a list of strings * @param separator - a separator string */ -function concatenate(list, separator = "") { +function concatenate(list, separator) { + if (separator === void 0) { separator = ""; } /** * 1. If list is empty, then return the empty string. * 2. If separator is not given, then set separator to the empty string. @@ -5414,41 +5957,53 @@ exports.concatenate = concatenate; //# sourceMappingURL=String.js.map /***/ }), - -/***/ 98: +/* 98 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const LocalNameSet_1 = __webpack_require__(575); -const NamespacePrefixMap_1 = __webpack_require__(392); -const DOMException_1 = __webpack_require__(35); -const infra_1 = __webpack_require__(23); -const algorithm_1 = __webpack_require__(163); +var interfaces_1 = __webpack_require__(970); +var LocalNameSet_1 = __webpack_require__(575); +var NamespacePrefixMap_1 = __webpack_require__(392); +var DOMException_1 = __webpack_require__(35); +var infra_1 = __webpack_require__(23); +var algorithm_1 = __webpack_require__(163); /** * Represents an XML serializer. * * Implements: https://www.w3.org/TR/DOM-Parsing/#serializing */ -class XMLSerializerImpl { +var XMLSerializerImpl = /** @class */ (function () { + function XMLSerializerImpl() { + } /** @inheritdoc */ - serializeToString(root) { + XMLSerializerImpl.prototype.serializeToString = function (root) { /** * The serializeToString(root) method must produce an XML serialization * of root passing a value of false for the require well-formed parameter, * and return the result. */ return this._xmlSerialization(root, false); - } + }; /** * Produces an XML serialization of the given node. * * @param node - node to serialize * @param requireWellFormed - whether to check conformance */ - _xmlSerialization(node, requireWellFormed) { + XMLSerializerImpl.prototype._xmlSerialization = function (node, requireWellFormed) { // To increase performance, use a namespace-aware serializer only if the // document has namespaced elements if (node._nodeDocument === undefined || node._nodeDocument._hasNamespaces) { @@ -5468,10 +6023,10 @@ class XMLSerializerImpl { * serialize a node's namespaceURI (or the namespaceURI of one of node's * attributes). See the generate a prefix algorithm. */ - const namespace = null; - const prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap(); + var namespace = null; + var prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap(); prefixMap.set("xml", infra_1.namespace.XML); - const prefixIndex = { value: 1 }; + var prefixIndex = { value: 1 }; /** * 5. Return the result of running the XML serialization algorithm on node * passing the context namespace namespace, namespace prefix map prefix map, @@ -5495,7 +6050,7 @@ class XMLSerializerImpl { throw new DOMException_1.InvalidStateError(); } } - } + }; /** * Produces an XML serialization of a node. * @@ -5505,7 +6060,7 @@ class XMLSerializerImpl { * @param prefixIndex - generated namespace prefix index * @param requireWellFormed - whether to check conformance */ - _serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) { + XMLSerializerImpl.prototype._serializeNodeNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) { switch (node.nodeType) { case interfaces_1.NodeType.Element: return this._serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed); @@ -5524,16 +6079,16 @@ class XMLSerializerImpl { case interfaces_1.NodeType.CData: return this._serializeCData(node, requireWellFormed); default: - throw new Error(`Unknown node type: ${node.nodeType}`); + throw new Error("Unknown node type: " + node.nodeType); } - } + }; /** * Produces an XML serialization of a node. * * @param node - node to serialize * @param requireWellFormed - whether to check conformance */ - _serializeNode(node, requireWellFormed) { + XMLSerializerImpl.prototype._serializeNode = function (node, requireWellFormed) { switch (node.nodeType) { case interfaces_1.NodeType.Element: return this._serializeElement(node, requireWellFormed); @@ -5552,9 +6107,9 @@ class XMLSerializerImpl { case interfaces_1.NodeType.CData: return this._serializeCData(node, requireWellFormed); default: - throw new Error(`Unknown node type: ${node.nodeType}`); + throw new Error("Unknown node type: " + node.nodeType); } - } + }; /** * Produces an XML serialization of an element node. * @@ -5564,7 +6119,8 @@ class XMLSerializerImpl { * @param prefixIndex - generated namespace prefix index * @param requireWellFormed - whether to check conformance */ - _serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) { + XMLSerializerImpl.prototype._serializeElementNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) { + var e_1, _a; /** * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node * @@ -5607,15 +6163,15 @@ class XMLSerializerImpl { * 9. Let inherited ns be a copy of namespace. * 10. Let ns be the value of node's namespaceURI attribute. */ - let markup = "<"; - let qualifiedName = ''; - let skipEndTag = false; - let ignoreNamespaceDefinitionAttribute = false; - let map = prefixMap.copy(); - let localPrefixesMap = {}; - let localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap); - let inheritedNS = namespace; - let ns = node.namespaceURI; + var markup = "<"; + var qualifiedName = ''; + var skipEndTag = false; + var ignoreNamespaceDefinitionAttribute = false; + var map = prefixMap.copy(); + var localPrefixesMap = {}; + var localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap); + var inheritedNS = namespace; + var ns = node.namespaceURI; /** 11. If inherited ns is equal to ns, then: */ if (inheritedNS === ns) { /** @@ -5651,14 +6207,14 @@ class XMLSerializerImpl { * prefix string prefix from map given namespace ns. The above may return * null if no namespace key ns exists in map. */ - let prefix = node.prefix; + var prefix = node.prefix; /** * We don't need to run "retrieving a preferred prefix string" algorithm if * the element has no prefix and its namespace matches to the default * namespace. * See: https://github.com/web-platform-tests/wpt/pull/16703 */ - let candidatePrefix = null; + var candidatePrefix = null; if (prefix !== null || ns !== localDefaultNamespace) { candidatePrefix = map.get(prefix, ns); } @@ -5847,7 +6403,7 @@ class XMLSerializerImpl { * tag flag to true. * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup. */ - const isHTML = (ns === infra_1.namespace.HTML); + var isHTML = (ns === infra_1.namespace.HTML); if (isHTML && node.childNodes.length === 0 && XMLSerializerImpl._VoidElementNames.has(node.localName)) { markup += " /"; @@ -5883,8 +6439,18 @@ class XMLSerializerImpl { // TODO: serialize template contents } else { - for (const childNode of node._children || node.childNodes) { - markup += this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed); + try { + for (var _b = __values(node._children || node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + markup += this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } } } /** @@ -5898,7 +6464,7 @@ class XMLSerializerImpl { * 21. Return the value of markup. */ return markup; - } + }; /** * Produces an XML serialization of a document node. * @@ -5908,7 +6474,8 @@ class XMLSerializerImpl { * @param prefixIndex - generated namespace prefix index * @param requireWellFormed - whether to check conformance */ - _serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) { + XMLSerializerImpl.prototype._serializeDocumentNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) { + var e_2, _a; /** * If the require well-formed flag is set (its value is true), and this node * has no documentElement (the documentElement attribute's value is null), @@ -5932,19 +6499,29 @@ class XMLSerializerImpl { * * 3. Return the value of serialized document. */ - let serializedDocument = ""; - for (const childNode of node._children || node.childNodes) { - serializedDocument += this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed); + var serializedDocument = ""; + try { + for (var _b = __values(node._children || node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + serializedDocument += this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed); + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_2) throw e_2.error; } } return serializedDocument; - } + }; /** * Produces an XML serialization of a comment node. * * @param node - node to serialize * @param requireWellFormed - whether to check conformance */ - _serializeComment(node, requireWellFormed) { + XMLSerializerImpl.prototype._serializeComment = function (node, requireWellFormed) { /** * If the require well-formed flag is set (its value is true), and node's * data contains characters that are not matched by the XML Char production @@ -5960,7 +6537,7 @@ class XMLSerializerImpl { * Otherwise, return the concatenation of "". */ return ""; - } + }; /** * Produces an XML serialization of a text node. * @@ -5968,7 +6545,7 @@ class XMLSerializerImpl { * @param requireWellFormed - whether to check conformance * @param level - current depth of the XML tree */ - _serializeText(node, requireWellFormed) { + XMLSerializerImpl.prototype._serializeText = function (node, requireWellFormed) { /** * 1. If the require well-formed flag is set (its value is true), and * node's data contains characters that are not matched by the XML Char @@ -5985,9 +6562,9 @@ class XMLSerializerImpl { * 5. Replace any occurrences of ">" in markup by ">". * 6. Return the value of markup. */ - let result = ""; - for (let i = 0; i < node.data.length; i++) { - const c = node.data[i]; + var result = ""; + for (var i = 0; i < node.data.length; i++) { + var c = node.data[i]; if (c === "&") result += "&"; else if (c === "<") @@ -5998,7 +6575,7 @@ class XMLSerializerImpl { result += c; } return result; - } + }; /** * Produces an XML serialization of a document fragment node. * @@ -6008,7 +6585,8 @@ class XMLSerializerImpl { * @param prefixIndex - generated namespace prefix index * @param requireWellFormed - whether to check conformance */ - _serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) { + XMLSerializerImpl.prototype._serializeDocumentFragmentNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) { + var e_3, _a; /** * 1. Let markup the empty string. * 2. For each child child of node, in tree order, run the XML serialization @@ -6016,19 +6594,29 @@ class XMLSerializerImpl { * index, and flag require well-formed. Concatenate the result to markup. * 3. Return the value of markup. */ - let markup = ""; - for (const childNode of node._children || node.childNodes) { - markup += this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed); + var markup = ""; + try { + for (var _b = __values(node._children || node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + markup += this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed); + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_3) throw e_3.error; } } return markup; - } + }; /** * Produces an XML serialization of a document type node. * * @param node - node to serialize * @param requireWellFormed - whether to check conformance */ - _serializeDocumentType(node, requireWellFormed) { + XMLSerializerImpl.prototype._serializeDocumentType = function (node, requireWellFormed) { /** * 1. If the require well-formed flag is true and the node's publicId * attribute contains characters that are not matched by the XML PubidChar @@ -6086,14 +6674,14 @@ class XMLSerializerImpl { "" : ""; - } + }; /** * Produces an XML serialization of a processing instruction node. * * @param node - node to serialize * @param requireWellFormed - whether to check conformance */ - _serializeProcessingInstruction(node, requireWellFormed) { + XMLSerializerImpl.prototype._serializeProcessingInstruction = function (node, requireWellFormed) { /** * 1. If the require well-formed flag is set (its value is true), and node's * target contains a ":" (U+003A COLON) character or is an ASCII @@ -6124,19 +6712,19 @@ class XMLSerializerImpl { * 4. Return the value of markup. */ return ""; - } + }; /** * Produces an XML serialization of a CDATA node. * * @param node - node to serialize * @param requireWellFormed - whether to check conformance */ - _serializeCData(node, requireWellFormed) { + XMLSerializerImpl.prototype._serializeCData = function (node, requireWellFormed) { if (requireWellFormed && (node.data.indexOf("]]>") !== -1)) { throw new Error("CDATA contains invalid characters (well-formed required)."); } return ""; - } + }; /** * Produces an XML serialization of the attributes of an element node. * @@ -6148,7 +6736,8 @@ class XMLSerializerImpl { * attributes * @param requireWellFormed - whether to check conformance */ - _serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) { + XMLSerializerImpl.prototype._serializeAttributesNS = function (node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) { + var e_4, _a; /** * 1. Let result be the empty string. * 2. Let localname set be a new empty namespace localname set. This @@ -6159,191 +6748,201 @@ class XMLSerializerImpl { * This can occur when two otherwise identical attributes on the same * element differ only by their prefix values. */ - let result = ""; - const localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined; - /** - * 3. Loop: For each attribute attr in element's attributes, in the order - * they are specified in the element's attribute list: - */ - for (const attr of node.attributes) { - // Optimize common case - if (!ignoreNamespaceDefinitionAttribute && !requireWellFormed && attr.namespaceURI === null) { - result += " " + attr.localName + "=\"" + + var result = ""; + var localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined; + try { + /** + * 3. Loop: For each attribute attr in element's attributes, in the order + * they are specified in the element's attribute list: + */ + for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) { + var attr = _c.value; + // Optimize common case + if (!ignoreNamespaceDefinitionAttribute && !requireWellFormed && attr.namespaceURI === null) { + result += " " + attr.localName + "=\"" + + this._serializeAttributeValue(attr.value, requireWellFormed) + "\""; + continue; + } + /** + * 3.1. If the require well-formed flag is set (its value is true), and the + * localname set contains a tuple whose values match those of a new tuple + * consisting of attr's namespaceURI attribute and localName attribute, + * then throw an exception; the serialization of this attr would fail to + * produce a well-formed element serialization. + */ + if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) { + throw new Error("Element contains duplicate attributes (well-formed required)."); + } + /** + * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and + * localName attribute, and add it to the localname set. + * 3.3. Let attribute namespace be the value of attr's namespaceURI value. + * 3.4. Let candidate prefix be null. + */ + if (requireWellFormed && localNameSet) + localNameSet.set(attr.namespaceURI, attr.localName); + var attributeNamespace = attr.namespaceURI; + var candidatePrefix = null; + /** 3.5. If attribute namespace is not null, then run these sub-steps: */ + if (attributeNamespace !== null) { + /** + * 3.5.1. Let candidate prefix be the result of retrieving a preferred + * prefix string from map given namespace attribute namespace with + * preferred prefix being attr's prefix value. + */ + candidatePrefix = map.get(attr.prefix, attributeNamespace); + /** + * 3.5.2. If the value of attribute namespace is the XMLNS namespace, + * then run these steps: + */ + if (attributeNamespace === infra_1.namespace.XMLNS) { + /** + * 3.5.2.1. If any of the following are true, then stop running these + * steps and goto Loop to visit the next attribute: + * - the attr's value is the XML namespace; + * _Note:_ The XML namespace cannot be redeclared and survive + * round-tripping (unless it defines the prefix "xml"). To avoid this + * problem, this algorithm always prefixes elements in the XML + * namespace with "xml" and drops any related definitions as seen + * in the above condition. + * - the attr's prefix is null and the ignore namespace definition + * attribute flag is true (the Element's default namespace attribute + * should be skipped); + * - the attr's prefix is not null and either + * * the attr's localName is not a key contained in the local + * prefixes map, or + * * the attr's localName is present in the local prefixes map but + * the value of the key does not match attr's value + * and furthermore that the attr's localName (as the prefix to find) + * is found in the namespace prefix map given the namespace consisting + * of the attr's value (the current namespace prefix definition was + * exactly defined previously--on an ancestor element not the current + * element whose attributes are being processed). + */ + if (attr.value === infra_1.namespace.XML || + (attr.prefix === null && ignoreNamespaceDefinitionAttribute) || + (attr.prefix !== null && (!(attr.localName in localPrefixesMap) || + localPrefixesMap[attr.localName] !== attr.value) && + map.has(attr.localName, attr.value))) + continue; + /** + * 3.5.2.2. If the require well-formed flag is set (its value is true), + * and the value of attr's value attribute matches the XMLNS + * namespace, then throw an exception; the serialization of this + * attribute would produce invalid XML because the XMLNS namespace + * is reserved and cannot be applied as an element's namespace via + * XML parsing. + * + * _Note:_ DOM APIs do allow creation of elements in the XMLNS + * namespace but with strict qualifications. + */ + if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) { + throw new Error("XMLNS namespace is reserved (well-formed required)."); + } + /** + * 3.5.2.3. If the require well-formed flag is set (its value is true), + * and the value of attr's value attribute is the empty string, then + * throw an exception; namespace prefix declarations cannot be used + * to undeclare a namespace (use a default namespace declaration + * instead). + */ + if (requireWellFormed && attr.value === '') { + throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required)."); + } + /** + * 3.5.2.4. the attr's prefix matches the string "xmlns", then let + * candidate prefix be the string "xmlns". + */ + if (attr.prefix === 'xmlns') + candidatePrefix = 'xmlns'; + /** + * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace. + * Run these steps: + * + * _Note:_ The (candidatePrefix === null) check is not in the spec. + * We deviate from the spec here. Otherwise a prefix is generated for + * all attributes with namespaces. + */ + } + else if (candidatePrefix === null) { + if (attr.prefix !== null && + (!map.hasPrefix(attr.prefix) || + map.has(attr.prefix, attributeNamespace))) { + /** + * Check if we can use the attribute's own prefix. + * We deviate from the spec here. + * TODO: This is not an efficient way of searching for prefixes. + * Follow developments to the spec. + */ + candidatePrefix = attr.prefix; + } + else { + /** + * 3.5.3.1. Let candidate prefix be the result of generating a prefix + * providing map, attribute namespace, and prefix index as input. + */ + candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex); + } + /** + * 3.5.3.2. Append the following to result, in the order listed: + * 3.5.3.2.1. " " (U+0020 SPACE); + * 3.5.3.2.2. The string "xmlns:"; + * 3.5.3.2.3. The value of candidate prefix; + * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); + * 3.5.3.2.5. The result of serializing an attribute value given + * attribute namespace and the require well-formed flag as input; + * 3.5.3.2.6. """ (U+0022 QUOTATION MARK). + */ + result += " xmlns:" + candidatePrefix + "=\"" + + this._serializeAttributeValue(attributeNamespace, requireWellFormed) + "\""; + } + } + /** + * 3.6. Append a " " (U+0020 SPACE) to result. + * 3.7. If candidate prefix is not null, then append to result the + * concatenation of candidate prefix with ":" (U+003A COLON). + */ + result += " "; + if (candidatePrefix !== null) { + result += candidatePrefix + ':'; + } + /** + * 3.8. If the require well-formed flag is set (its value is true), and + * this attr's localName attribute contains the character + * ":" (U+003A COLON) or does not match the XML Name production or + * equals "xmlns" and attribute namespace is null, then throw an + * exception; the serialization of this attr would not be a + * well-formed attribute. + */ + if (requireWellFormed && (attr.localName.indexOf(":") !== -1 || + !algorithm_1.xml_isName(attr.localName) || + (attr.localName === "xmlns" && attributeNamespace === null))) { + throw new Error("Attribute local name contains invalid characters (well-formed required)."); + } + /** + * 3.9. Append the following strings to result, in the order listed: + * 3.9.1. The value of attr's localName; + * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); + * 3.9.3. The result of serializing an attribute value given attr's value + * attribute and the require well-formed flag as input; + * 3.9.4. """ (U+0022 QUOTATION MARK). + */ + result += attr.localName + "=\"" + this._serializeAttributeValue(attr.value, requireWellFormed) + "\""; - continue; } - /** - * 3.1. If the require well-formed flag is set (its value is true), and the - * localname set contains a tuple whose values match those of a new tuple - * consisting of attr's namespaceURI attribute and localName attribute, - * then throw an exception; the serialization of this attr would fail to - * produce a well-formed element serialization. - */ - if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) { - throw new Error("Element contains duplicate attributes (well-formed required)."); + } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); } - /** - * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and - * localName attribute, and add it to the localname set. - * 3.3. Let attribute namespace be the value of attr's namespaceURI value. - * 3.4. Let candidate prefix be null. - */ - if (requireWellFormed && localNameSet) - localNameSet.set(attr.namespaceURI, attr.localName); - let attributeNamespace = attr.namespaceURI; - let candidatePrefix = null; - /** 3.5. If attribute namespace is not null, then run these sub-steps: */ - if (attributeNamespace !== null) { - /** - * 3.5.1. Let candidate prefix be the result of retrieving a preferred - * prefix string from map given namespace attribute namespace with - * preferred prefix being attr's prefix value. - */ - candidatePrefix = map.get(attr.prefix, attributeNamespace); - /** - * 3.5.2. If the value of attribute namespace is the XMLNS namespace, - * then run these steps: - */ - if (attributeNamespace === infra_1.namespace.XMLNS) { - /** - * 3.5.2.1. If any of the following are true, then stop running these - * steps and goto Loop to visit the next attribute: - * - the attr's value is the XML namespace; - * _Note:_ The XML namespace cannot be redeclared and survive - * round-tripping (unless it defines the prefix "xml"). To avoid this - * problem, this algorithm always prefixes elements in the XML - * namespace with "xml" and drops any related definitions as seen - * in the above condition. - * - the attr's prefix is null and the ignore namespace definition - * attribute flag is true (the Element's default namespace attribute - * should be skipped); - * - the attr's prefix is not null and either - * * the attr's localName is not a key contained in the local - * prefixes map, or - * * the attr's localName is present in the local prefixes map but - * the value of the key does not match attr's value - * and furthermore that the attr's localName (as the prefix to find) - * is found in the namespace prefix map given the namespace consisting - * of the attr's value (the current namespace prefix definition was - * exactly defined previously--on an ancestor element not the current - * element whose attributes are being processed). - */ - if (attr.value === infra_1.namespace.XML || - (attr.prefix === null && ignoreNamespaceDefinitionAttribute) || - (attr.prefix !== null && (!(attr.localName in localPrefixesMap) || - localPrefixesMap[attr.localName] !== attr.value) && - map.has(attr.localName, attr.value))) - continue; - /** - * 3.5.2.2. If the require well-formed flag is set (its value is true), - * and the value of attr's value attribute matches the XMLNS - * namespace, then throw an exception; the serialization of this - * attribute would produce invalid XML because the XMLNS namespace - * is reserved and cannot be applied as an element's namespace via - * XML parsing. - * - * _Note:_ DOM APIs do allow creation of elements in the XMLNS - * namespace but with strict qualifications. - */ - if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) { - throw new Error("XMLNS namespace is reserved (well-formed required)."); - } - /** - * 3.5.2.3. If the require well-formed flag is set (its value is true), - * and the value of attr's value attribute is the empty string, then - * throw an exception; namespace prefix declarations cannot be used - * to undeclare a namespace (use a default namespace declaration - * instead). - */ - if (requireWellFormed && attr.value === '') { - throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required)."); - } - /** - * 3.5.2.4. the attr's prefix matches the string "xmlns", then let - * candidate prefix be the string "xmlns". - */ - if (attr.prefix === 'xmlns') - candidatePrefix = 'xmlns'; - /** - * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace. - * Run these steps: - * - * _Note:_ The (candidatePrefix === null) check is not in the spec. - * We deviate from the spec here. Otherwise a prefix is generated for - * all attributes with namespaces. - */ - } - else if (candidatePrefix === null) { - if (attr.prefix !== null && - (!map.hasPrefix(attr.prefix) || - map.has(attr.prefix, attributeNamespace))) { - /** - * Check if we can use the attribute's own prefix. - * We deviate from the spec here. - * TODO: This is not an efficient way of searching for prefixes. - * Follow developments to the spec. - */ - candidatePrefix = attr.prefix; - } - else { - /** - * 3.5.3.1. Let candidate prefix be the result of generating a prefix - * providing map, attribute namespace, and prefix index as input. - */ - candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex); - } - /** - * 3.5.3.2. Append the following to result, in the order listed: - * 3.5.3.2.1. " " (U+0020 SPACE); - * 3.5.3.2.2. The string "xmlns:"; - * 3.5.3.2.3. The value of candidate prefix; - * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); - * 3.5.3.2.5. The result of serializing an attribute value given - * attribute namespace and the require well-formed flag as input; - * 3.5.3.2.6. """ (U+0022 QUOTATION MARK). - */ - result += " xmlns:" + candidatePrefix + "=\"" + - this._serializeAttributeValue(attributeNamespace, requireWellFormed) + "\""; - } - } - /** - * 3.6. Append a " " (U+0020 SPACE) to result. - * 3.7. If candidate prefix is not null, then append to result the - * concatenation of candidate prefix with ":" (U+003A COLON). - */ - result += " "; - if (candidatePrefix !== null) { - result += candidatePrefix + ':'; - } - /** - * 3.8. If the require well-formed flag is set (its value is true), and - * this attr's localName attribute contains the character - * ":" (U+003A COLON) or does not match the XML Name production or - * equals "xmlns" and attribute namespace is null, then throw an - * exception; the serialization of this attr would not be a - * well-formed attribute. - */ - if (requireWellFormed && (attr.localName.indexOf(":") !== -1 || - !algorithm_1.xml_isName(attr.localName) || - (attr.localName === "xmlns" && attributeNamespace === null))) { - throw new Error("Attribute local name contains invalid characters (well-formed required)."); - } - /** - * 3.9. Append the following strings to result, in the order listed: - * 3.9.1. The value of attr's localName; - * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); - * 3.9.3. The result of serializing an attribute value given attr's value - * attribute and the require well-formed flag as input; - * 3.9.4. """ (U+0022 QUOTATION MARK). - */ - result += attr.localName + "=\"" + - this._serializeAttributeValue(attr.value, requireWellFormed) + "\""; + finally { if (e_4) throw e_4.error; } } /** * 4. Return the value of result. */ return result; - } + }; /** * Records namespace information for the given element and returns the * default namespace attribute value. @@ -6352,98 +6951,109 @@ class XMLSerializerImpl { * @param map - namespace prefix map * @param localPrefixesMap - local prefixes map */ - _recordNamespaceInformation(node, map, localPrefixesMap) { + XMLSerializerImpl.prototype._recordNamespaceInformation = function (node, map, localPrefixesMap) { + var e_5, _a; /** * 1. Let default namespace attr value be null. */ - let defaultNamespaceAttrValue = null; - /** - * 2. Main: For each attribute attr in element's attributes, in the order - * they are specified in the element's attribute list: - */ - for (const attr of node.attributes) { + var defaultNamespaceAttrValue = null; + try { /** - * _Note:_ The following conditional steps find namespace prefixes. Only - * attributes in the XMLNS namespace are considered (e.g., attributes made - * to look like namespace declarations via - * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not - * included). + * 2. Main: For each attribute attr in element's attributes, in the order + * they are specified in the element's attribute list: */ - /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */ - let attributeNamespace = attr.namespaceURI; - /** 2.2. Let attribute prefix be the value of attr's prefix. */ - let attributePrefix = attr.prefix; - /** 2.3. If the attribute namespace is the XMLNS namespace, then: */ - if (attributeNamespace === infra_1.namespace.XMLNS) { + for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) { + var attr = _c.value; /** - * 2.3.1. If attribute prefix is null, then attr is a default namespace - * declaration. Set the default namespace attr value to attr's value and - * stop running these steps, returning to Main to visit the next - * attribute. + * _Note:_ The following conditional steps find namespace prefixes. Only + * attributes in the XMLNS namespace are considered (e.g., attributes made + * to look like namespace declarations via + * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not + * included). */ - if (attributePrefix === null) { - defaultNamespaceAttrValue = attr.value; - continue; + /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */ + var attributeNamespace = attr.namespaceURI; + /** 2.2. Let attribute prefix be the value of attr's prefix. */ + var attributePrefix = attr.prefix; + /** 2.3. If the attribute namespace is the XMLNS namespace, then: */ + if (attributeNamespace === infra_1.namespace.XMLNS) { /** - * 2.3.2. Otherwise, the attribute prefix is not null and attr is a - * namespace prefix definition. Run the following steps: - */ - } - else { - /** 2.3.2.1. Let prefix definition be the value of attr's localName. */ - let prefixDefinition = attr.localName; - /** 2.3.2.2. Let namespace definition be the value of attr's value. */ - let namespaceDefinition = attr.value; - /** - * 2.3.2.3. If namespace definition is the XML namespace, then stop - * running these steps, and return to Main to visit the next + * 2.3.1. If attribute prefix is null, then attr is a default namespace + * declaration. Set the default namespace attr value to attr's value and + * stop running these steps, returning to Main to visit the next * attribute. - * - * _Note:_ XML namespace definitions in prefixes are completely - * ignored (in order to avoid unnecessary work when there might be - * prefix conflicts). XML namespaced elements are always handled - * uniformly by prefixing (and overriding if necessary) the element's - * localname with the reserved "xml" prefix. */ - if (namespaceDefinition === infra_1.namespace.XML) { + if (attributePrefix === null) { + defaultNamespaceAttrValue = attr.value; continue; + /** + * 2.3.2. Otherwise, the attribute prefix is not null and attr is a + * namespace prefix definition. Run the following steps: + */ } - /** - * 2.3.2.4. If namespace definition is the empty string (the - * declarative form of having no namespace), then let namespace - * definition be null instead. - */ - if (namespaceDefinition === '') { - namespaceDefinition = null; + else { + /** 2.3.2.1. Let prefix definition be the value of attr's localName. */ + var prefixDefinition = attr.localName; + /** 2.3.2.2. Let namespace definition be the value of attr's value. */ + var namespaceDefinition = attr.value; + /** + * 2.3.2.3. If namespace definition is the XML namespace, then stop + * running these steps, and return to Main to visit the next + * attribute. + * + * _Note:_ XML namespace definitions in prefixes are completely + * ignored (in order to avoid unnecessary work when there might be + * prefix conflicts). XML namespaced elements are always handled + * uniformly by prefixing (and overriding if necessary) the element's + * localname with the reserved "xml" prefix. + */ + if (namespaceDefinition === infra_1.namespace.XML) { + continue; + } + /** + * 2.3.2.4. If namespace definition is the empty string (the + * declarative form of having no namespace), then let namespace + * definition be null instead. + */ + if (namespaceDefinition === '') { + namespaceDefinition = null; + } + /** + * 2.3.2.5. If prefix definition is found in map given the namespace + * namespace definition, then stop running these steps, and return to + * Main to visit the next attribute. + * + * _Note:_ This step avoids adding duplicate prefix definitions for + * the same namespace in the map. This has the side-effect of avoiding + * later serialization of duplicate namespace prefix declarations in + * any descendant nodes. + */ + if (map.has(prefixDefinition, namespaceDefinition)) { + continue; + } + /** + * 2.3.2.6. Add the prefix prefix definition to map given namespace + * namespace definition. + */ + map.set(prefixDefinition, namespaceDefinition); + /** + * 2.3.2.7. Add the value of prefix definition as a new key to the + * local prefixes map, with the namespace definition as the key's + * value replacing the value of null with the empty string if + * applicable. + */ + localPrefixesMap[prefixDefinition] = namespaceDefinition || ''; } - /** - * 2.3.2.5. If prefix definition is found in map given the namespace - * namespace definition, then stop running these steps, and return to - * Main to visit the next attribute. - * - * _Note:_ This step avoids adding duplicate prefix definitions for - * the same namespace in the map. This has the side-effect of avoiding - * later serialization of duplicate namespace prefix declarations in - * any descendant nodes. - */ - if (map.has(prefixDefinition, namespaceDefinition)) { - continue; - } - /** - * 2.3.2.6. Add the prefix prefix definition to map given namespace - * namespace definition. - */ - map.set(prefixDefinition, namespaceDefinition); - /** - * 2.3.2.7. Add the value of prefix definition as a new key to the - * local prefixes map, with the namespace definition as the key's - * value replacing the value of null with the empty string if - * applicable. - */ - localPrefixesMap[prefixDefinition] = namespaceDefinition || ''; } } } + catch (e_5_1) { e_5 = { error: e_5_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_5) throw e_5.error; } + } /** * 3. Return the value of default namespace attr value. * @@ -6451,7 +7061,7 @@ class XMLSerializerImpl { * converted to null. */ return defaultNamespaceAttrValue; - } + }; /** * Generates a new prefix for the given namespace. * @@ -6459,7 +7069,7 @@ class XMLSerializerImpl { * @param prefixMap - namespace prefix map * @param prefixIndex - generated namespace prefix index */ - _generatePrefix(newNamespace, prefixMap, prefixIndex) { + XMLSerializerImpl.prototype._generatePrefix = function (newNamespace, prefixMap, prefixIndex) { /** * 1. Let generated prefix be the concatenation of the string "ns" and the * current numerical value of prefix index. @@ -6467,18 +7077,18 @@ class XMLSerializerImpl { * 3. Add to map the generated prefix given the new namespace namespace. * 4. Return the value of generated prefix. */ - let generatedPrefix = "ns" + prefixIndex.value; + var generatedPrefix = "ns" + prefixIndex.value; prefixIndex.value++; prefixMap.set(generatedPrefix, newNamespace); return generatedPrefix; - } + }; /** * Produces an XML serialization of an attribute value. * * @param value - attribute value * @param requireWellFormed - whether to check conformance */ - _serializeAttributeValue(value, requireWellFormed) { + XMLSerializerImpl.prototype._serializeAttributeValue = function (value, requireWellFormed) { /** * From: https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value * @@ -6507,9 +7117,9 @@ class XMLSerializerImpl { * grammar requirement in the XML specification's AttValue production by * also replacing ">" characters. */ - let result = ""; - for (let i = 0; i < value.length; i++) { - const c = value[i]; + var result = ""; + for (var i = 0; i < value.length; i++) { + var c = value[i]; if (c === "\"") result += """; else if (c === "&") @@ -6522,14 +7132,15 @@ class XMLSerializerImpl { result += c; } return result; - } + }; /** * Produces an XML serialization of an element node. * * @param node - node to serialize * @param requireWellFormed - whether to check conformance */ - _serializeElement(node, requireWellFormed) { + XMLSerializerImpl.prototype._serializeElement = function (node, requireWellFormed) { + var e_6, _a; /** * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node * @@ -6572,7 +7183,7 @@ class XMLSerializerImpl { * 9. Let inherited ns be a copy of namespace. * 10. Let ns be the value of node's namespaceURI attribute. */ - let skipEndTag = false; + var skipEndTag = false; /** 11. If inherited ns is equal to ns, then: */ /** * 11.1. If local default namespace is not null, then set ignore @@ -6582,9 +7193,9 @@ class XMLSerializerImpl { * 11.3. Otherwise, append to qualified name the value of node's * localName. The node's prefix if it exists, is dropped. */ - const qualifiedName = node.localName; + var qualifiedName = node.localName; /** 11.4. Append the value of qualified name to markup. */ - let markup = "<" + qualifiedName; + var markup = "<" + qualifiedName; /** * 13. Append to markup the result of the XML serialization of node's * attributes given map, prefix index, local prefixes map, ignore namespace @@ -6617,23 +7228,33 @@ class XMLSerializerImpl { */ if (skipEndTag) return markup; - /** - * 18. If ns is the HTML namespace, and the node's localName matches the - * string "template", then this is a template element. Append to markup the - * result of XML serializing a DocumentFragment node given the template - * element's template contents (a DocumentFragment), providing inherited - * ns, map, prefix index, and the require well-formed flag. - * - * _Note:_ This allows template content to round-trip, given the rules for - * parsing XHTML documents. - * - * 19. Otherwise, append to markup the result of running the XML - * serialization algorithm on each of node's children, in tree order, - * providing inherited ns, map, prefix index, and the require well-formed - * flag. - */ - for (const childNode of node._children) { - markup += this._serializeNode(childNode, requireWellFormed); + try { + /** + * 18. If ns is the HTML namespace, and the node's localName matches the + * string "template", then this is a template element. Append to markup the + * result of XML serializing a DocumentFragment node given the template + * element's template contents (a DocumentFragment), providing inherited + * ns, map, prefix index, and the require well-formed flag. + * + * _Note:_ This allows template content to round-trip, given the rules for + * parsing XHTML documents. + * + * 19. Otherwise, append to markup the result of running the XML + * serialization algorithm on each of node's children, in tree order, + * providing inherited ns, map, prefix index, and the require well-formed + * flag. + */ + for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + markup += this._serializeNode(childNode, requireWellFormed); + } + } + catch (e_6_1) { e_6 = { error: e_6_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_6) throw e_6.error; } } /** * 20. Append the following to markup, in the order listed: @@ -6646,14 +7267,15 @@ class XMLSerializerImpl { * 21. Return the value of markup. */ return markup; - } + }; /** * Produces an XML serialization of a document node. * * @param node - node to serialize * @param requireWellFormed - whether to check conformance */ - _serializeDocument(node, requireWellFormed) { + XMLSerializerImpl.prototype._serializeDocument = function (node, requireWellFormed) { + var e_7, _a; /** * If the require well-formed flag is set (its value is true), and this node * has no documentElement (the documentElement attribute's value is null), @@ -6677,19 +7299,30 @@ class XMLSerializerImpl { * * 3. Return the value of serialized document. */ - let serializedDocument = ""; - for (const childNode of node._children) { - serializedDocument += this._serializeNode(childNode, requireWellFormed); + var serializedDocument = ""; + try { + for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + serializedDocument += this._serializeNode(childNode, requireWellFormed); + } + } + catch (e_7_1) { e_7 = { error: e_7_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_7) throw e_7.error; } } return serializedDocument; - } + }; /** * Produces an XML serialization of a document fragment node. * * @param node - node to serialize * @param requireWellFormed - whether to check conformance */ - _serializeDocumentFragment(node, requireWellFormed) { + XMLSerializerImpl.prototype._serializeDocumentFragment = function (node, requireWellFormed) { + var e_8, _a; /** * 1. Let markup the empty string. * 2. For each child child of node, in tree order, run the XML serialization @@ -6697,19 +7330,30 @@ class XMLSerializerImpl { * index, and flag require well-formed. Concatenate the result to markup. * 3. Return the value of markup. */ - let markup = ""; - for (const childNode of node._children) { - markup += this._serializeNode(childNode, requireWellFormed); + var markup = ""; + try { + for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + markup += this._serializeNode(childNode, requireWellFormed); + } + } + catch (e_8_1) { e_8 = { error: e_8_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_8) throw e_8.error; } } return markup; - } + }; /** * Produces an XML serialization of the attributes of an element node. * * @param node - node to serialize * @param requireWellFormed - whether to check conformance */ - _serializeAttributes(node, requireWellFormed) { + XMLSerializerImpl.prototype._serializeAttributes = function (node, requireWellFormed) { + var e_9, _a; /** * 1. Let result be the empty string. * 2. Let localname set be a new empty namespace localname set. This @@ -6720,75 +7364,123 @@ class XMLSerializerImpl { * This can occur when two otherwise identical attributes on the same * element differ only by their prefix values. */ - let result = ""; - const localNameSet = requireWellFormed ? {} : undefined; - /** - * 3. Loop: For each attribute attr in element's attributes, in the order - * they are specified in the element's attribute list: - */ - for (const attr of node.attributes) { + var result = ""; + var localNameSet = requireWellFormed ? {} : undefined; + try { /** - * 3.1. If the require well-formed flag is set (its value is true), and the - * localname set contains a tuple whose values match those of a new tuple - * consisting of attr's namespaceURI attribute and localName attribute, - * then throw an exception; the serialization of this attr would fail to - * produce a well-formed element serialization. + * 3. Loop: For each attribute attr in element's attributes, in the order + * they are specified in the element's attribute list: */ - if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) { - throw new Error("Element contains duplicate attributes (well-formed required)."); + for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) { + var attr = _c.value; + /** + * 3.1. If the require well-formed flag is set (its value is true), and the + * localname set contains a tuple whose values match those of a new tuple + * consisting of attr's namespaceURI attribute and localName attribute, + * then throw an exception; the serialization of this attr would fail to + * produce a well-formed element serialization. + */ + if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) { + throw new Error("Element contains duplicate attributes (well-formed required)."); + } + /** + * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and + * localName attribute, and add it to the localname set. + * 3.3. Let attribute namespace be the value of attr's namespaceURI value. + * 3.4. Let candidate prefix be null. + */ + if (requireWellFormed && localNameSet) + localNameSet[attr.localName] = true; + /** 3.5. If attribute namespace is not null, then run these sub-steps: */ + /** + * 3.6. Append a " " (U+0020 SPACE) to result. + * 3.7. If candidate prefix is not null, then append to result the + * concatenation of candidate prefix with ":" (U+003A COLON). + */ + /** + * 3.8. If the require well-formed flag is set (its value is true), and + * this attr's localName attribute contains the character + * ":" (U+003A COLON) or does not match the XML Name production or + * equals "xmlns" and attribute namespace is null, then throw an + * exception; the serialization of this attr would not be a + * well-formed attribute. + */ + if (requireWellFormed && (attr.localName.indexOf(":") !== -1 || + !algorithm_1.xml_isName(attr.localName))) { + throw new Error("Attribute local name contains invalid characters (well-formed required)."); + } + /** + * 3.9. Append the following strings to result, in the order listed: + * 3.9.1. The value of attr's localName; + * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); + * 3.9.3. The result of serializing an attribute value given attr's value + * attribute and the require well-formed flag as input; + * 3.9.4. """ (U+0022 QUOTATION MARK). + */ + result += " " + attr.localName + "=\"" + + this._serializeAttributeValue(attr.value, requireWellFormed) + "\""; } - /** - * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and - * localName attribute, and add it to the localname set. - * 3.3. Let attribute namespace be the value of attr's namespaceURI value. - * 3.4. Let candidate prefix be null. - */ - if (requireWellFormed && localNameSet) - localNameSet[attr.localName] = true; - /** 3.5. If attribute namespace is not null, then run these sub-steps: */ - /** - * 3.6. Append a " " (U+0020 SPACE) to result. - * 3.7. If candidate prefix is not null, then append to result the - * concatenation of candidate prefix with ":" (U+003A COLON). - */ - /** - * 3.8. If the require well-formed flag is set (its value is true), and - * this attr's localName attribute contains the character - * ":" (U+003A COLON) or does not match the XML Name production or - * equals "xmlns" and attribute namespace is null, then throw an - * exception; the serialization of this attr would not be a - * well-formed attribute. - */ - if (requireWellFormed && (attr.localName.indexOf(":") !== -1 || - !algorithm_1.xml_isName(attr.localName))) { - throw new Error("Attribute local name contains invalid characters (well-formed required)."); + } + catch (e_9_1) { e_9 = { error: e_9_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); } - /** - * 3.9. Append the following strings to result, in the order listed: - * 3.9.1. The value of attr's localName; - * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); - * 3.9.3. The result of serializing an attribute value given attr's value - * attribute and the require well-formed flag as input; - * 3.9.4. """ (U+0022 QUOTATION MARK). - */ - result += " " + attr.localName + "=\"" + - this._serializeAttributeValue(attr.value, requireWellFormed) + "\""; + finally { if (e_9) throw e_9.error; } } /** * 4. Return the value of result. */ return result; - } -} + }; + XMLSerializerImpl._VoidElementNames = new Set(['area', 'base', 'basefont', + 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen', + 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']); + return XMLSerializerImpl; +}()); exports.XMLSerializerImpl = XMLSerializerImpl; -XMLSerializerImpl._VoidElementNames = new Set(['area', 'base', 'basefont', - 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen', - 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']); //# sourceMappingURL=XMLSerializerImpl.js.map /***/ }), +/* 99 */, +/* 100 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 102: +"use strict"; + + +var Type = __webpack_require__(945); + +var _hasOwnProperty = Object.prototype.hasOwnProperty; + +function resolveYamlSet(data) { + if (data === null) return true; + + var key, object = data; + + for (key in object) { + if (_hasOwnProperty.call(object, key)) { + if (object[key] !== null) return false; + } + } + + return true; +} + +function constructYamlSet(data) { + return data !== null ? data : {}; +} + +module.exports = new Type('tag:yaml.org,2002:set', { + kind: 'mapping', + resolve: resolveYamlSet, + construct: constructYamlSet +}); + + +/***/ }), +/* 101 */, +/* 102 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; @@ -6823,14 +7515,27 @@ exports.issueCommand = issueCommand; //# sourceMappingURL=file-command.js.map /***/ }), - -/***/ 106: +/* 103 */, +/* 104 */, +/* 105 */, +/* 106 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(337); +var util_1 = __webpack_require__(592); /** * Flattens the given options argument. * @@ -6862,9 +7567,9 @@ function eventTarget_flattenMore(options) { * once to options’s once. * 4. Return capture, passive, and once. */ - const capture = eventTarget_flatten(options); - let once = false; - let passive = false; + var capture = eventTarget_flatten(options); + var once = false; + var passive = false; if (!util_1.isBoolean(options)) { once = options.once || false; passive = options.passive || false; @@ -6898,8 +7603,8 @@ function eventTarget_addEventListener(eventTarget, listener) { * is listener’s capture, then append listener to eventTarget’s event listener * list. */ - for (let i = 0; i < eventTarget._eventListenerList.length; i++) { - const entry = eventTarget._eventListenerList[i]; + for (var i = 0; i < eventTarget._eventListenerList.length; i++) { + var entry = eventTarget._eventListenerList[i]; if (entry.type === listener.type && entry.callback.handleEvent === listener.callback.handleEvent && entry.capture === listener.capture) { return; @@ -6941,8 +7646,19 @@ function eventTarget_removeAllEventListeners(eventTarget) { * for each listener of eventTarget’s event listener list, remove an event * listener with eventTarget and listener. */ - for (const e of eventTarget._eventListenerList) { - e.removed = true; + var e_1, _a; + try { + for (var _b = __values(eventTarget._eventListenerList), _c = _b.next(); !_c.done; _c = _b.next()) { + var e = _c.value; + e.removed = true; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } } eventTarget._eventListenerList.length = 0; } @@ -6950,1035 +7666,138 @@ exports.eventTarget_removeAllEventListeners = eventTarget_removeAllEventListener //# sourceMappingURL=EventTargetAlgorithm.js.map /***/ }), - -/***/ 108: +/* 107 */, +/* 108 */, +/* 109 */, +/* 110 */, +/* 111 */, +/* 112 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const interfaces_1 = __webpack_require__(970); -const util_1 = __webpack_require__(918); -const CustomEventImpl_1 = __webpack_require__(164); -const EventImpl_1 = __webpack_require__(427); -const DOMException_1 = __webpack_require__(35); -const TreeAlgorithm_1 = __webpack_require__(873); -const ShadowTreeAlgorithm_1 = __webpack_require__(180); -const DOMAlgorithm_1 = __webpack_require__(304); +var ObjectReader_1 = __webpack_require__(50); +var BaseReader_1 = __webpack_require__(305); /** - * Sets the canceled flag of an event. - * - * @param event - an event + * Parses XML nodes from a JSON string. */ -function event_setTheCanceledFlag(event) { - if (event._cancelable && !event._inPassiveListenerFlag) { - event._canceledFlag = true; +var JSONReader = /** @class */ (function (_super) { + __extends(JSONReader, _super); + function JSONReader() { + return _super !== null && _super.apply(this, arguments) || this; } -} -exports.event_setTheCanceledFlag = event_setTheCanceledFlag; -/** - * Initializes the value of an event. - * - * @param event - an event to initialize - * @param type - the type of event - * @param bubbles - whether the event propagates in reverse - * @param cancelable - whether the event can be cancelled - */ -function event_initialize(event, type, bubbles, cancelable) { - event._initializedFlag = true; - event._stopPropagationFlag = false; - event._stopImmediatePropagationFlag = false; - event._canceledFlag = false; - event._isTrusted = false; - event._target = null; - event._type = type; - event._bubbles = bubbles; - event._cancelable = cancelable; -} -exports.event_initialize = event_initialize; -/** - * Creates a new event. - * - * @param eventInterface - event interface - * @param realm - realm - */ -function event_createAnEvent(eventInterface, realm = undefined) { /** - * 1. If realm is not given, then set it to null. - * 2. Let dictionary be the result of converting the JavaScript value - * undefined to the dictionary type accepted by eventInterface’s - * constructor. (This dictionary type will either be EventInit or a - * dictionary that inherits from it.) - * 3. Let event be the result of running the inner event creation steps with - * eventInterface, realm, the time of the occurrence that the event is - * signaling, and dictionary. - * 4. Initialize event’s isTrusted attribute to true. - * 5. Return event. - */ - if (realm === undefined) - realm = null; - const dictionary = {}; - const event = event_innerEventCreationSteps(eventInterface, realm, new Date(), dictionary); - event._isTrusted = true; - return event; -} -exports.event_createAnEvent = event_createAnEvent; -/** - * Performs event creation steps. - * - * @param eventInterface - event interface - * @param realm - realm - * @param time - time of occurrance - * @param dictionary - event attributes - * - */ -function event_innerEventCreationSteps(eventInterface, realm, time, dictionary) { - /** - * 1. Let event be the result of creating a new object using eventInterface. - * TODO: Implement realms - * If realm is non-null, then use that Realm; otherwise, use the default - * behavior defined in Web IDL. - */ - const event = new eventInterface(""); - /** - * 2. Set event’s initialized flag. - * 3. Initialize event’s timeStamp attribute to a DOMHighResTimeStamp - * representing the high resolution time from the time origin to time. - * 4. For each member → value in dictionary, if event has an attribute - * whose identifier is member, then initialize that attribute to value. - * 5. Run the event constructing steps with event. - * 6. Return event. - */ - event._initializedFlag = true; - event._timeStamp = time.getTime(); - Object.assign(event, dictionary); - if (dom_1.dom.features.steps) { - DOMAlgorithm_1.dom_runEventConstructingSteps(event); - } - return event; -} -exports.event_innerEventCreationSteps = event_innerEventCreationSteps; -/** - * Dispatches an event to an event target. - * - * @param event - the event to dispatch - * @param target - event target - * @param legacyTargetOverrideFlag - legacy target override flag - * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns - * whether the event listener's callback threw an exception - */ -function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyOutputDidListenersThrowFlag = { value: false }) { - let clearTargets = false; - /** - * 1. Set event's dispatch flag. - */ - event._dispatchFlag = true; - /** - * 2. Let targetOverride be target, if legacy target override flag is not - * given, and target's associated Document otherwise. + * Parses the given document representation. * - * _Note:_ legacy target override flag is only used by HTML and only when - * target is a Window object. + * @param node - node receive parsed XML nodes + * @param str - JSON string to parse */ - let targetOverride = target; - if (legacyTargetOverrideFlag) { - const doc = target._associatedDocument; - if (util_1.Guard.isDocumentNode(doc)) { - targetOverride = doc; - } - } - /** - * 3. Let activationTarget be null. - * 4. Let relatedTarget be the result of retargeting event's relatedTarget - * against target. - * 5. If target is not relatedTarget or target is event's relatedTarget, - * then: - */ - let activationTarget = null; - let relatedTarget = TreeAlgorithm_1.tree_retarget(event._relatedTarget, target); - if (target !== relatedTarget || target === event._relatedTarget) { - /** - * 5.1. Let touchTargets be a new list. - * 5.2. For each touchTarget of event's touch target list, append the - * result of retargeting touchTarget against target to touchTargets. - * 5.3. Append to an event path with event, target, targetOverride, - * relatedTarget, touchTargets, and false. - * 5.4. Let isActivationEvent be true, if event is a MouseEvent object - * and event's type attribute is "click", and false otherwise. - * 5.5. If isActivationEvent is true and target has activation behavior, - * then set activationTarget to target. - * 5.6. Let slotable be target, if target is a slotable and is assigned, - * and null otherwise. - * 5.7. Let slot-in-closed-tree be false. - * 5.8. Let parent be the result of invoking target's get the parent with - * event. - */ - let touchTargets = []; - for (const touchTarget of event._touchTargetList) { - touchTargets.push(TreeAlgorithm_1.tree_retarget(touchTarget, target)); - } - event_appendToAnEventPath(event, target, targetOverride, relatedTarget, touchTargets, false); - const isActivationEvent = (util_1.Guard.isMouseEvent(event) && event._type === "click"); - if (isActivationEvent && target._activationBehavior !== undefined) { - activationTarget = target; - } - let slotable = (util_1.Guard.isSlotable(target) && ShadowTreeAlgorithm_1.shadowTree_isAssigned(target)) ? - target : null; - let slotInClosedTree = false; - let parent = target._getTheParent(event); - /** - * 5.9. While parent is non-null: - */ - while (parent !== null && util_1.Guard.isNode(parent)) { - /** - * 5.9.1 If slotable is non-null: - * 5.9.1.1. Assert: parent is a slot. - * 5.9.1.2. Set slotable to null. - * 5.9.1.3. If parent's root is a shadow root whose mode is "closed", - * then set slot-in-closed-tree to true. - */ - if (slotable !== null) { - if (!util_1.Guard.isSlot(parent)) { - throw new Error("Parent node of a slotable should be a slot."); - } - slotable = null; - const root = TreeAlgorithm_1.tree_rootNode(parent, true); - if (util_1.Guard.isShadowRoot(root) && root._mode === "closed") { - slotInClosedTree = true; - } - } - /** - * 5.9.2 If parent is a slotable and is assigned, then set slotable to - * parent. - * 5.9.3. Let relatedTarget be the result of retargeting event's - * relatedTarget against parent. - * 5.9.4. Let touchTargets be a new list. - * 5.9.4. For each touchTarget of event's touch target list, append the - * result of retargeting touchTarget against parent to touchTargets. - */ - if (util_1.Guard.isSlotable(parent) && ShadowTreeAlgorithm_1.shadowTree_isAssigned(parent)) { - slotable = parent; - } - relatedTarget = TreeAlgorithm_1.tree_retarget(event._relatedTarget, parent); - touchTargets = []; - for (const touchTarget of event._touchTargetList) { - touchTargets.push(TreeAlgorithm_1.tree_retarget(touchTarget, parent)); - } - /** - * 5.9.6. If parent is a Window object, or parent is a node and target's - * root is a shadow-including inclusive ancestor of parent, then: - */ - if (util_1.Guard.isWindow(parent) || (util_1.Guard.isNode(parent) && util_1.Guard.isNode(target) && - TreeAlgorithm_1.tree_isAncestorOf(TreeAlgorithm_1.tree_rootNode(target, true), parent, true, true))) { - /** - * 5.9.6.1. If isActivationEvent is true, event's bubbles attribute - * is true, activationTarget is null, and parent has activation - * behavior, then set activationTarget to parent. - * 5.9.6.2. Append to an event path with event, parent, null, - * relatedTarget, touchTargets, and slot-in-closed-tree. - */ - if (isActivationEvent && event._bubbles && activationTarget === null && - parent._activationBehavior) { - activationTarget = parent; - } - event_appendToAnEventPath(event, parent, null, relatedTarget, touchTargets, slotInClosedTree); - } - else if (parent === relatedTarget) { - /** - * 5.9.7. Otherwise, if parent is relatedTarget, - * then set parent to null. - */ - parent = null; - } - else { - /** - * 5.9.8. Otherwise, set target to parent and then: - * 5.9.8.1. If isActivationEvent is true, activationTarget is null, - * and target has activation behavior, then set activationTarget - * to target. - * 5.9.8.2. Append to an event path with event, parent, target, - * relatedTarget, touchTargets, and slot-in-closed-tree. - */ - target = parent; - if (isActivationEvent && activationTarget === null && - target._activationBehavior) { - activationTarget = target; - } - event_appendToAnEventPath(event, parent, target, relatedTarget, touchTargets, slotInClosedTree); - } - /** - * 5.9.9. If parent is non-null, then set parent to the result of - * invoking parent's get the parent with event. - * 5.9.10. Set slot-in-closed-tree to false. - */ - if (parent !== null) { - parent = parent._getTheParent(event); - } - slotInClosedTree = false; - } - /** - * 5.10. Let clearTargetsStruct be the last struct in event's path whose - * shadow-adjusted target is non-null. - */ - let clearTargetsStruct = null; - const path = event._path; - for (let i = path.length - 1; i >= 0; i--) { - const struct = path[i]; - if (struct.shadowAdjustedTarget !== null) { - clearTargetsStruct = struct; - break; - } - } - /** - * 5.11. Let clearTargets be true if clearTargetsStruct's shadow-adjusted - * target, clearTargetsStruct's relatedTarget, or an EventTarget object - * in clearTargetsStruct's touch target list is a node and its root is - * a shadow root, and false otherwise. - */ - if (clearTargetsStruct !== null) { - if (util_1.Guard.isNode(clearTargetsStruct.shadowAdjustedTarget) && - util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(clearTargetsStruct.shadowAdjustedTarget, true))) { - clearTargets = true; - } - else if (util_1.Guard.isNode(clearTargetsStruct.relatedTarget) && - util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(clearTargetsStruct.relatedTarget, true))) { - clearTargets = true; - } - else { - for (let j = 0; j < clearTargetsStruct.touchTargetList.length; j++) { - const struct = clearTargetsStruct.touchTargetList[j]; - if (util_1.Guard.isNode(struct) && - util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(struct, true))) { - clearTargets = true; - break; - } - } - } - } - /** - * 5.12. If activationTarget is non-null and activationTarget has - * legacy-pre-activation behavior, then run activationTarget's - * legacy-pre-activation behavior. - */ - if (activationTarget !== null && - activationTarget._legacyPreActivationBehavior !== undefined) { - activationTarget._legacyPreActivationBehavior(event); - } - /** - * 5.13. For each struct in event's path, in reverse order: - */ - for (let i = path.length - 1; i >= 0; i--) { - const struct = path[i]; - /** - * 5.13.1. If struct's shadow-adjusted target is non-null, then set - * event's eventPhase attribute to AT_TARGET. - * 5.13.2. Otherwise, set event's eventPhase attribute to - * CAPTURING_PHASE. - * 5.13.3. Invoke with struct, event, "capturing", and - * legacyOutputDidListenersThrowFlag if given. - */ - if (struct.shadowAdjustedTarget !== null) { - event._eventPhase = interfaces_1.EventPhase.AtTarget; - } - else { - event._eventPhase = interfaces_1.EventPhase.Capturing; - } - event_invoke(struct, event, "capturing", legacyOutputDidListenersThrowFlag); - } - /** - * 5.14. For each struct in event's path - */ - for (let i = 0; i < path.length; i++) { - const struct = path[i]; - /** - * 5.14.1. If struct's shadow-adjusted target is non-null, then set - * event's eventPhase attribute to AT_TARGET. - * 5.14.2. Otherwise: - * 5.14.2.1. If event's bubbles attribute is false, then continue. - * 5.14.2.2. Set event's eventPhase attribute to BUBBLING_PHASE. - * 5.14.3. Invoke with struct, event, "bubbling", and - * legacyOutputDidListenersThrowFlag if given. - */ - if (struct.shadowAdjustedTarget !== null) { - event._eventPhase = interfaces_1.EventPhase.AtTarget; - } - else { - if (!event._bubbles) - continue; - event._eventPhase = interfaces_1.EventPhase.Bubbling; - } - event_invoke(struct, event, "bubbling", legacyOutputDidListenersThrowFlag); - } - } - /** - * 6. Set event's eventPhase attribute to NONE. - * 7. Set event's currentTarget attribute to null. - * 8. Set event's path to the empty list. - * 9. Unset event's dispatch flag, stop propagation flag, and stop - * immediate propagation flag. - */ - event._eventPhase = interfaces_1.EventPhase.None; - event._currentTarget = null; - event._path = []; - event._dispatchFlag = false; - event._stopPropagationFlag = false; - event._stopImmediatePropagationFlag = false; - /** - * 10. If clearTargets, then: - * 10.1. Set event's target to null. - * 10.2. Set event's relatedTarget to null. - * 10.3. Set event's touch target list to the empty list. - */ - if (clearTargets) { - event._target = null; - event._relatedTarget = null; - event._touchTargetList = []; - } - /** - * 11. If activationTarget is non-null, then: - * 11.1. If event's canceled flag is unset, then run activationTarget's - * activation behavior with event. - * 11.2. Otherwise, if activationTarget has legacy-canceled-activation - * behavior, then run activationTarget's legacy-canceled-activation - * behavior. - */ - if (activationTarget !== null) { - if (!event._canceledFlag && activationTarget._activationBehavior !== undefined) { - activationTarget._activationBehavior(event); - } - else if (activationTarget._legacyCanceledActivationBehavior !== undefined) { - activationTarget._legacyCanceledActivationBehavior(event); - } - } - /** - * 12. Return false if event's canceled flag is set, and true otherwise. - */ - return !event._canceledFlag; -} -exports.event_dispatch = event_dispatch; -/** - * Appends a new struct to an event's path. - * - * @param event - an event - * @param invocationTarget - the target of the invocation - * @param shadowAdjustedTarget - shadow-root adjusted event target - * @param relatedTarget - related event target - * @param touchTargets - a list of touch targets - * @param slotInClosedTree - if the target's parent is a closed shadow root - */ -function event_appendToAnEventPath(event, invocationTarget, shadowAdjustedTarget, relatedTarget, touchTargets, slotInClosedTree) { - /** - * 1. Let invocationTargetInShadowTree be false. - * 2. If invocationTarget is a node and its root is a shadow root, then - * set invocationTargetInShadowTree to true. - */ - let invocationTargetInShadowTree = false; - if (util_1.Guard.isNode(invocationTarget) && - util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(invocationTarget))) { - invocationTargetInShadowTree = true; - } - /** - * 3. Let root-of-closed-tree be false. - * 4. If invocationTarget is a shadow root whose mode is "closed", then - * set root-of-closed-tree to true. - */ - let rootOfClosedTree = false; - if (util_1.Guard.isShadowRoot(invocationTarget) && - invocationTarget._mode === "closed") { - rootOfClosedTree = true; - } - /** - * 5. Append a new struct to event's path whose invocation target is - * invocationTarget, invocation-target-in-shadow-tree is - * invocationTargetInShadowTree, shadow-adjusted target is - * shadowAdjustedTarget, relatedTarget is relatedTarget, - * touch target list is touchTargets, root-of-closed-tree is - * root-of-closed-tree, and slot-in-closed-tree is slot-in-closed-tree. - */ - event._path.push({ - invocationTarget: invocationTarget, - invocationTargetInShadowTree: invocationTargetInShadowTree, - shadowAdjustedTarget: shadowAdjustedTarget, - relatedTarget: relatedTarget, - touchTargetList: touchTargets, - rootOfClosedTree: rootOfClosedTree, - slotInClosedTree: slotInClosedTree - }); -} -exports.event_appendToAnEventPath = event_appendToAnEventPath; -/** - * Invokes an event. - * - * @param struct - a struct defining event's path - * @param event - the event to invoke - * @param phase - event phase - * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns - * whether the event listener's callback threw an exception - */ -function event_invoke(struct, event, phase, legacyOutputDidListenersThrowFlag = { value: false }) { - /** - * 1. Set event's target to the shadow-adjusted target of the last struct - * in event's path, that is either struct or preceding struct, whose - * shadow-adjusted target is non-null. - */ - const path = event._path; - let index = -1; - for (let i = 0; i < path.length; i++) { - if (path[i] === struct) { - index = i; - break; - } - } - if (index !== -1) { - let item = path[index]; - if (item.shadowAdjustedTarget !== null) { - event._target = item.shadowAdjustedTarget; - } - else if (index > 0) { - item = path[index - 1]; - if (item.shadowAdjustedTarget !== null) { - event._target = item.shadowAdjustedTarget; - } - } - } - /** - * 2. Set event's relatedTarget to struct's relatedTarget. - * 3. Set event's touch target list to struct's touch target list. - * 4. If event's stop propagation flag is set, then return. - * 5. Initialize event's currentTarget attribute to struct's invocation - * target. - * 6. Let listeners be a clone of event's currentTarget attribute value's - * event listener list. - * - * _Note:_ This avoids event listeners added after this point from being - * run. Note that removal still has an effect due to the removed field. - */ - event._relatedTarget = struct.relatedTarget; - event._touchTargetList = struct.touchTargetList; - if (event._stopPropagationFlag) - return; - event._currentTarget = struct.invocationTarget; - const currentTarget = event._currentTarget; - const targetListeners = currentTarget._eventListenerList; - let listeners = new Array(...targetListeners); - /** - * 7. Let found be the result of running inner invoke with event, listeners, - * phase, and legacyOutputDidListenersThrowFlag if given. - */ - const found = event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag); - /** - * 8. If found is false and event's isTrusted attribute is true, then: - */ - if (!found && event._isTrusted) { - /** - * 8.1. Let originalEventType be event's type attribute value. - * 8.2. If event's type attribute value is a match for any of the strings - * in the first column in the following table, set event's type attribute - * value to the string in the second column on the same row as the matching - * string, and return otherwise. - * - * Event type | Legacy event type - * ------------------------------------------------- - * "animationend" | "webkitAnimationEnd" - * "animationiteration" | "webkitAnimationIteration" - * "animationstart" | "webkitAnimationStart" - * "transitionend" | "webkitTransitionEnd" - */ - const originalEventType = event._type; - if (originalEventType === "animationend") { - event._type = "webkitAnimationEnd"; - } - else if (originalEventType === "animationiteration") { - event._type = "webkitAnimationIteration"; - } - else if (originalEventType === "animationstart") { - event._type = "webkitAnimationStart"; - } - else if (originalEventType === "transitionend") { - event._type = "webkitTransitionEnd"; - } - /** - * 8.3. Inner invoke with event, listeners, phase, and - * legacyOutputDidListenersThrowFlag if given. - * 8.4. Set event's type attribute value to originalEventType. - */ - event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag); - event._type = originalEventType; - } -} -exports.event_invoke = event_invoke; -/** - * Invokes an event. - * - * @param event - the event to invoke - * @param listeners - event listeners - * @param phase - event phase - * @param struct - a struct defining event's path - * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns - * whether the event listener's callback threw an exception - */ -function event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag = { value: false }) { - /** - * 1. Let found be false. - * 2. For each listener in listeners, whose removed is false: - */ - let found = false; - for (let i = 0; i < listeners.length; i++) { - const listener = listeners[i]; - if (!listener.removed) { - /** - * 2.1. If event's type attribute value is not listener's type, then - * continue. - * 2.2. Set found to true. - * 2.3. If phase is "capturing" and listener's capture is false, then - * continue. - * 2.4. If phase is "bubbling" and listener's capture is true, then - * continue. - */ - if (event._type !== listener.type) - continue; - found = true; - if (phase === "capturing" && !listener.capture) - continue; - if (phase === "bubbling" && listener.capture) - continue; - /** - * 2.5. If listener's once is true, then remove listener from event's - * currentTarget attribute value's event listener list. - */ - if (listener.once && event._currentTarget !== null) { - const impl = event._currentTarget; - let index = -1; - for (let i = 0; i < impl._eventListenerList.length; i++) { - if (impl._eventListenerList[i] === listener) { - index = i; - break; - } - } - if (index !== -1) { - impl._eventListenerList.splice(index, 1); - } - } - /** - * TODO: Implement realms - * - * 2.6. Let global be listener callback's associated Realm's global - * object. - */ - const globalObject = undefined; - /** - * 2.7. Let currentEvent be undefined. - * 2.8. If global is a Window object, then: - * 2.8.1. Set currentEvent to global's current event. - * 2.8.2. If struct's invocation-target-in-shadow-tree is false, then - * set global's current event to event. - */ - let currentEvent = undefined; - if (util_1.Guard.isWindow(globalObject)) { - currentEvent = globalObject._currentEvent; - if (struct.invocationTargetInShadowTree === false) { - globalObject._currentEvent = event; - } - } - /** - * 2.9. If listener's passive is true, then set event's in passive - * listener flag. - * 2.10. Call a user object's operation with listener's callback, - * "handleEvent", « event », and event's currentTarget attribute value. - */ - if (listener.passive) - event._inPassiveListenerFlag = true; - try { - listener.callback.handleEvent.call(event._currentTarget, event); - } - catch (err) { - /** - * If this throws an exception, then: - * 2.10.1. Report the exception. - * 2.10.2. Set legacyOutputDidListenersThrowFlag if given. - * - * _Note:_ The legacyOutputDidListenersThrowFlag is only used by - * Indexed Database API. - * TODO: Report the exception - * See: https://html.spec.whatwg.org/multipage/webappapis.html#runtime-script-errors-in-documents - */ - legacyOutputDidListenersThrowFlag.value = true; - } - /** - * 2.11. Unset event's in passive listener flag. - */ - if (listener.passive) - event._inPassiveListenerFlag = false; - /** - * 2.12. If global is a Window object, then set global's current event - * to currentEvent. - */ - if (util_1.Guard.isWindow(globalObject)) { - globalObject._currentEvent = currentEvent; - } - /** - * 2.13. If event's stop immediate propagation flag is set, then return - * found. - */ - if (event._stopImmediatePropagationFlag) - return found; - } - } - /** - * 3. Return found. - */ - return found; -} -exports.event_innerInvoke = event_innerInvoke; -/** - * Fires an event at target. - * @param e - event name - * @param target - event target - * @param eventConstructor - an event constructor, with a description of how - * IDL attributes are to be initialized - * @param idlAttributes - a dictionary describing how IDL attributes are - * to be initialized - * @param legacyTargetOverrideFlag - legacy target override flag - */ -function event_fireAnEvent(e, target, eventConstructor, idlAttributes, legacyTargetOverrideFlag) { - /** - * 1. If eventConstructor is not given, then let eventConstructor be Event. - */ - if (eventConstructor === undefined) { - eventConstructor = EventImpl_1.EventImpl; - } - /** - * 2. Let event be the result of creating an event given eventConstructor, - * in the relevant Realm of target. - */ - const event = event_createAnEvent(eventConstructor); - /** - * 3. Initialize event’s type attribute to e. - */ - event._type = e; - /** - * 4. Initialize any other IDL attributes of event as described in the - * invocation of this algorithm. - * _Note:_ This also allows for the isTrusted attribute to be set to false. - */ - if (idlAttributes) { - for (const key in idlAttributes) { - const idlObj = event; - idlObj[key] = idlAttributes[key]; - } - } - /** - * 5. Return the result of dispatching event at target, with legacy target - * override flag set if set. - */ - return event_dispatch(event, target, legacyTargetOverrideFlag); -} -exports.event_fireAnEvent = event_fireAnEvent; -/** - * Creates an event. - * - * @param eventInterface - the name of the event interface - */ -function event_createLegacyEvent(eventInterface) { - /** - * 1. Let constructor be null. - */ - let constructor = null; - /** - * TODO: Implement in HTML DOM - * 2. If interface is an ASCII case-insensitive match for any of the strings - * in the first column in the following table, then set constructor to the - * interface in the second column on the same row as the matching string: - * - * String | Interface - * -------|---------- - * "beforeunloadevent" | BeforeUnloadEvent - * "compositionevent" | CompositionEvent - * "customevent" | CustomEvent - * "devicemotionevent" | DeviceMotionEvent - * "deviceorientationevent" | DeviceOrientationEvent - * "dragevent" | DragEvent - * "event" | Event - * "events" | Event - * "focusevent" | FocusEvent - * "hashchangeevent" | HashChangeEvent - * "htmlevents" | Event - * "keyboardevent" | KeyboardEvent - * "messageevent" | MessageEvent - * "mouseevent" | MouseEvent - * "mouseevents" | - * "storageevent" | StorageEvent - * "svgevents" | Event - * "textevent" | CompositionEvent - * "touchevent" | TouchEvent - * "uievent" | UIEvent - * "uievents" | UIEvent - */ - switch (eventInterface.toLowerCase()) { - case "beforeunloadevent": - break; - case "compositionevent": - break; - case "customevent": - constructor = CustomEventImpl_1.CustomEventImpl; - break; - case "devicemotionevent": - break; - case "deviceorientationevent": - break; - case "dragevent": - break; - case "event": - case "events": - constructor = EventImpl_1.EventImpl; - break; - case "focusevent": - break; - case "hashchangeevent": - break; - case "htmlevents": - break; - case "keyboardevent": - break; - case "messageevent": - break; - case "mouseevent": - break; - case "mouseevents": - break; - case "storageevent": - break; - case "svgevents": - break; - case "textevent": - break; - case "touchevent": - break; - case "uievent": - break; - case "uievents": - break; - } - /** - * 3. If constructor is null, then throw a "NotSupportedError" DOMException. - */ - if (constructor === null) { - throw new DOMException_1.NotSupportedError(`Event constructor not found for interface ${eventInterface}.`); - } - /** - * 4. If the interface indicated by constructor is not exposed on the - * relevant global object of the context object, then throw a - * "NotSupportedError" DOMException. - * _Note:_ Typically user agents disable support for touch events in some - * configurations, in which case this clause would be triggered for the - * interface TouchEvent. - */ - // TODO: Implement realms - /** - * 5. Let event be the result of creating an event given constructor. - * 6. Initialize event’s type attribute to the empty string. - * 7. Initialize event’s timeStamp attribute to a DOMHighResTimeStamp - * representing the high resolution time from the time origin to now. - * 8. Initialize event’s isTrusted attribute to false. - * 9. Unset event’s initialized flag. - */ - const event = new constructor(""); - event._type = ""; - event._timeStamp = new Date().getTime(); - event._isTrusted = false; - event._initializedFlag = false; - /** - * 10. Return event. - */ - return event; -} -exports.event_createLegacyEvent = event_createLegacyEvent; -/** - * Getter of an event handler IDL attribute. - * - * @param eventTarget - event target - * @param name - event name - */ -function event_getterEventHandlerIDLAttribute(thisObj, name) { - /** - * 1. Let eventTarget be the result of determining the target of an event - * handler given this object and name. - * 2. If eventTarget is null, then return null. - * 3. Return the result of getting the current value of the event handler - * given eventTarget and name. - */ - const eventTarget = event_determineTheTargetOfAnEventHandler(thisObj, name); - if (eventTarget === null) - return null; - return event_getTheCurrentValueOfAnEventHandler(eventTarget, name); -} -exports.event_getterEventHandlerIDLAttribute = event_getterEventHandlerIDLAttribute; -/** - * Setter of an event handler IDL attribute. - * - * @param eventTarget - event target - * @param name - event name - * @param value - event handler - */ -function event_setterEventHandlerIDLAttribute(thisObj, name, value) { - /** - * 1. Let eventTarget be the result of determining the target of an event - * handler given this object and name. - * 2. If eventTarget is null, then return. - * 3. If the given value is null, then deactivate an event handler given - * eventTarget and name. - * 4. Otherwise: - * 4.1. Let handlerMap be eventTarget's event handler map. - * 4.2. Let eventHandler be handlerMap[name]. - * 4.3. Set eventHandler's value to the given value. - * 4.4. Activate an event handler given eventTarget and name. - */ - const eventTarget = event_determineTheTargetOfAnEventHandler(thisObj, name); - if (eventTarget === null) - return; - if (value === null) { - event_deactivateAnEventHandler(eventTarget, name); - } - else { - const handlerMap = eventTarget._eventHandlerMap; - const eventHandler = handlerMap["onabort"]; - if (eventHandler !== undefined) { - eventHandler.value = value; - } - event_activateAnEventHandler(eventTarget, name); - } -} -exports.event_setterEventHandlerIDLAttribute = event_setterEventHandlerIDLAttribute; -/** - * Determines the target of an event handler. - * - * @param eventTarget - event target - * @param name - event name - */ -function event_determineTheTargetOfAnEventHandler(eventTarget, name) { - // TODO: Implement in HTML DOM - return null; -} -exports.event_determineTheTargetOfAnEventHandler = event_determineTheTargetOfAnEventHandler; -/** - * Gets the current value of an event handler. - * - * @param eventTarget - event target - * @param name - event name - */ -function event_getTheCurrentValueOfAnEventHandler(eventTarget, name) { - // TODO: Implement in HTML DOM - return null; -} -exports.event_getTheCurrentValueOfAnEventHandler = event_getTheCurrentValueOfAnEventHandler; -/** - * Activates an event handler. - * - * @param eventTarget - event target - * @param name - event name - */ -function event_activateAnEventHandler(eventTarget, name) { - // TODO: Implement in HTML DOM -} -exports.event_activateAnEventHandler = event_activateAnEventHandler; -/** - * Deactivates an event handler. - * - * @param eventTarget - event target - * @param name - event name - */ -function event_deactivateAnEventHandler(eventTarget, name) { - // TODO: Implement in HTML DOM -} -exports.event_deactivateAnEventHandler = event_deactivateAnEventHandler; -//# sourceMappingURL=EventAlgorithm.js.map + JSONReader.prototype._parse = function (node, str) { + return new ObjectReader_1.ObjectReader(this._builderOptions).parse(node, JSON.parse(str)); + }; + return JSONReader; +}(BaseReader_1.BaseReader)); +exports.JSONReader = JSONReader; +//# sourceMappingURL=JSONReader.js.map /***/ }), - -/***/ 113: +/* 113 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(337); +var util_1 = __webpack_require__(592); // Import implementation classes -const AbortControllerImpl_1 = __webpack_require__(990); +var AbortControllerImpl_1 = __webpack_require__(990); exports.AbortController = AbortControllerImpl_1.AbortControllerImpl; -const AbortSignalImpl_1 = __webpack_require__(784); +var AbortSignalImpl_1 = __webpack_require__(784); exports.AbortSignal = AbortSignalImpl_1.AbortSignalImpl; -const AbstractRangeImpl_1 = __webpack_require__(537); +var AbstractRangeImpl_1 = __webpack_require__(413); exports.AbstractRange = AbstractRangeImpl_1.AbstractRangeImpl; -const AttrImpl_1 = __webpack_require__(866); +var AttrImpl_1 = __webpack_require__(866); exports.Attr = AttrImpl_1.AttrImpl; -const CDATASectionImpl_1 = __webpack_require__(920); +var CDATASectionImpl_1 = __webpack_require__(920); exports.CDATASection = CDATASectionImpl_1.CDATASectionImpl; -const CharacterDataImpl_1 = __webpack_require__(43); +var CharacterDataImpl_1 = __webpack_require__(43); exports.CharacterData = CharacterDataImpl_1.CharacterDataImpl; -const ChildNodeImpl_1 = __webpack_require__(983); -const CommentImpl_1 = __webpack_require__(760); +var ChildNodeImpl_1 = __webpack_require__(983); +var CommentImpl_1 = __webpack_require__(760); exports.Comment = CommentImpl_1.CommentImpl; -const CustomEventImpl_1 = __webpack_require__(164); +var CustomEventImpl_1 = __webpack_require__(164); exports.CustomEvent = CustomEventImpl_1.CustomEventImpl; -const DocumentFragmentImpl_1 = __webpack_require__(796); +var DocumentFragmentImpl_1 = __webpack_require__(796); exports.DocumentFragment = DocumentFragmentImpl_1.DocumentFragmentImpl; -const DocumentImpl_1 = __webpack_require__(488); +var DocumentImpl_1 = __webpack_require__(488); exports.Document = DocumentImpl_1.DocumentImpl; -const DocumentOrShadowRootImpl_1 = __webpack_require__(247); -const DocumentTypeImpl_1 = __webpack_require__(558); +var DocumentOrShadowRootImpl_1 = __webpack_require__(247); +var DocumentTypeImpl_1 = __webpack_require__(558); exports.DocumentType = DocumentTypeImpl_1.DocumentTypeImpl; -const DOMImpl_1 = __webpack_require__(648); +var DOMImpl_1 = __webpack_require__(648); exports.dom = DOMImpl_1.dom; -const DOMImplementationImpl_1 = __webpack_require__(290); +var DOMImplementationImpl_1 = __webpack_require__(174); exports.DOMImplementation = DOMImplementationImpl_1.DOMImplementationImpl; -const DOMTokenListImpl_1 = __webpack_require__(742); +var DOMTokenListImpl_1 = __webpack_require__(425); exports.DOMTokenList = DOMTokenListImpl_1.DOMTokenListImpl; -const ElementImpl_1 = __webpack_require__(695); +var ElementImpl_1 = __webpack_require__(695); exports.Element = ElementImpl_1.ElementImpl; -const EventImpl_1 = __webpack_require__(427); +var EventImpl_1 = __webpack_require__(427); exports.Event = EventImpl_1.EventImpl; -const EventTargetImpl_1 = __webpack_require__(597); +var EventTargetImpl_1 = __webpack_require__(597); exports.EventTarget = EventTargetImpl_1.EventTargetImpl; -const HTMLCollectionImpl_1 = __webpack_require__(204); +var HTMLCollectionImpl_1 = __webpack_require__(204); exports.HTMLCollection = HTMLCollectionImpl_1.HTMLCollectionImpl; -const MutationObserverImpl_1 = __webpack_require__(175); +var MutationObserverImpl_1 = __webpack_require__(175); exports.MutationObserver = MutationObserverImpl_1.MutationObserverImpl; -const MutationRecordImpl_1 = __webpack_require__(730); +var MutationRecordImpl_1 = __webpack_require__(730); exports.MutationRecord = MutationRecordImpl_1.MutationRecordImpl; -const NamedNodeMapImpl_1 = __webpack_require__(88); +var NamedNodeMapImpl_1 = __webpack_require__(88); exports.NamedNodeMap = NamedNodeMapImpl_1.NamedNodeMapImpl; -const NodeFilterImpl_1 = __webpack_require__(774); +var NodeFilterImpl_1 = __webpack_require__(774); exports.NodeFilter = NodeFilterImpl_1.NodeFilterImpl; -const NodeImpl_1 = __webpack_require__(935); +var NodeImpl_1 = __webpack_require__(935); exports.Node = NodeImpl_1.NodeImpl; -const NodeIteratorImpl_1 = __webpack_require__(800); +var NodeIteratorImpl_1 = __webpack_require__(800); exports.NodeIterator = NodeIteratorImpl_1.NodeIteratorImpl; -const NodeListImpl_1 = __webpack_require__(636); +var NodeListImpl_1 = __webpack_require__(636); exports.NodeList = NodeListImpl_1.NodeListImpl; -const NodeListStaticImpl_1 = __webpack_require__(266); +var NodeListStaticImpl_1 = __webpack_require__(266); exports.NodeListStatic = NodeListStaticImpl_1.NodeListStaticImpl; -const NonDocumentTypeChildNodeImpl_1 = __webpack_require__(18); -const NonElementParentNodeImpl_1 = __webpack_require__(574); -const ParentNodeImpl_1 = __webpack_require__(934); -const ProcessingInstructionImpl_1 = __webpack_require__(619); +var NonDocumentTypeChildNodeImpl_1 = __webpack_require__(18); +var NonElementParentNodeImpl_1 = __webpack_require__(574); +var ParentNodeImpl_1 = __webpack_require__(934); +var ProcessingInstructionImpl_1 = __webpack_require__(619); exports.ProcessingInstruction = ProcessingInstructionImpl_1.ProcessingInstructionImpl; -const RangeImpl_1 = __webpack_require__(90); +var RangeImpl_1 = __webpack_require__(90); exports.Range = RangeImpl_1.RangeImpl; -const ShadowRootImpl_1 = __webpack_require__(581); +var ShadowRootImpl_1 = __webpack_require__(581); exports.ShadowRoot = ShadowRootImpl_1.ShadowRootImpl; -const SlotableImpl_1 = __webpack_require__(476); -const StaticRangeImpl_1 = __webpack_require__(688); +var SlotableImpl_1 = __webpack_require__(429); +var StaticRangeImpl_1 = __webpack_require__(688); exports.StaticRange = StaticRangeImpl_1.StaticRangeImpl; -const TextImpl_1 = __webpack_require__(820); +var TextImpl_1 = __webpack_require__(820); exports.Text = TextImpl_1.TextImpl; -const TraverserImpl_1 = __webpack_require__(487); +var TraverserImpl_1 = __webpack_require__(487); exports.Traverser = TraverserImpl_1.TraverserImpl; -const TreeWalkerImpl_1 = __webpack_require__(646); +var TreeWalkerImpl_1 = __webpack_require__(646); exports.TreeWalker = TreeWalkerImpl_1.TreeWalkerImpl; -const WindowImpl_1 = __webpack_require__(932); +var WindowImpl_1 = __webpack_require__(932); exports.Window = WindowImpl_1.WindowImpl; -const XMLDocumentImpl_1 = __webpack_require__(661); +var XMLDocumentImpl_1 = __webpack_require__(661); exports.XMLDocument = XMLDocumentImpl_1.XMLDocumentImpl; // Apply mixins // ChildNode @@ -8004,15 +7823,555 @@ util_1.applyMixin(ElementImpl_1.ElementImpl, SlotableImpl_1.SlotableImpl); //# sourceMappingURL=index.js.map /***/ }), +/* 114 */, +/* 115 */, +/* 116 */, +/* 117 */, +/* 118 */, +/* 119 */, +/* 120 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 129: +const compareBuild = __webpack_require__(16) +const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose)) +module.exports = sort + + +/***/ }), +/* 121 */, +/* 122 */, +/* 123 */, +/* 124 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +// hoisted class for cyclic dependency +class Range { + constructor (range, options) { + options = parseOptions(options) + + if (range instanceof Range) { + if ( + range.loose === !!options.loose && + range.includePrerelease === !!options.includePrerelease + ) { + return range + } else { + return new Range(range.raw, options) + } + } + + if (range instanceof Comparator) { + // just put it in the set and return + this.raw = range.value + this.set = [[range]] + this.format() + return this + } + + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + + // First, split based on boolean or || + this.raw = range + this.set = range + .split(/\s*\|\|\s*/) + // map the range to a 2d array of comparators + .map(range => this.parseRange(range.trim())) + // throw out any comparator lists that are empty + // this generally means that it was not a valid range, which is allowed + // in loose mode, but will still throw if the WHOLE range is invalid. + .filter(c => c.length) + + if (!this.set.length) { + throw new TypeError(`Invalid SemVer Range: ${range}`) + } + + // if we have any that are not the null set, throw out null sets. + if (this.set.length > 1) { + // keep the first one, in case they're all null sets + const first = this.set[0] + this.set = this.set.filter(c => !isNullSet(c[0])) + if (this.set.length === 0) + this.set = [first] + else if (this.set.length > 1) { + // if we have any that are *, then the range is just * + for (const c of this.set) { + if (c.length === 1 && isAny(c[0])) { + this.set = [c] + break + } + } + } + } + + this.format() + } + + format () { + this.range = this.set + .map((comps) => { + return comps.join(' ').trim() + }) + .join('||') + .trim() + return this.range + } + + toString () { + return this.range + } + + parseRange (range) { + range = range.trim() + + // memoize range parsing for performance. + // this is a very hot path, and fully deterministic. + const memoOpts = Object.keys(this.options).join(',') + const memoKey = `parseRange:${memoOpts}:${range}` + const cached = cache.get(memoKey) + if (cached) + return cached + + const loose = this.options.loose + // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` + const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE] + range = range.replace(hr, hyphenReplace(this.options.includePrerelease)) + debug('hyphen replace', range) + // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` + range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace) + debug('comparator trim', range, re[t.COMPARATORTRIM]) + + // `~ 1.2.3` => `~1.2.3` + range = range.replace(re[t.TILDETRIM], tildeTrimReplace) + + // `^ 1.2.3` => `^1.2.3` + range = range.replace(re[t.CARETTRIM], caretTrimReplace) + + // normalize spaces + range = range.split(/\s+/).join(' ') + + // At this point, the range is completely trimmed and + // ready to be split into comparators. + + const compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] + const rangeList = range + .split(' ') + .map(comp => parseComparator(comp, this.options)) + .join(' ') + .split(/\s+/) + // >=0.0.0 is equivalent to * + .map(comp => replaceGTE0(comp, this.options)) + // in loose mode, throw out any that are not valid comparators + .filter(this.options.loose ? comp => !!comp.match(compRe) : () => true) + .map(comp => new Comparator(comp, this.options)) + + // if any comparators are the null set, then replace with JUST null set + // if more than one comparator, remove any * comparators + // also, don't include the same comparator more than once + const l = rangeList.length + const rangeMap = new Map() + for (const comp of rangeList) { + if (isNullSet(comp)) + return [comp] + rangeMap.set(comp.value, comp) + } + if (rangeMap.size > 1 && rangeMap.has('')) + rangeMap.delete('') + + const result = [...rangeMap.values()] + cache.set(memoKey, result) + return result + } + + intersects (range, options) { + if (!(range instanceof Range)) { + throw new TypeError('a Range is required') + } + + return this.set.some((thisComparators) => { + return ( + isSatisfiable(thisComparators, options) && + range.set.some((rangeComparators) => { + return ( + isSatisfiable(rangeComparators, options) && + thisComparators.every((thisComparator) => { + return rangeComparators.every((rangeComparator) => { + return thisComparator.intersects(rangeComparator, options) + }) + }) + ) + }) + ) + }) + } + + // if ANY of the sets match ALL of its comparators, then pass + test (version) { + if (!version) { + return false + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + for (let i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true + } + } + return false + } +} +module.exports = Range + +const LRU = __webpack_require__(702) +const cache = new LRU({ max: 1000 }) + +const parseOptions = __webpack_require__(143) +const Comparator = __webpack_require__(536) +const debug = __webpack_require__(548) +const SemVer = __webpack_require__(65) +const { + re, + t, + comparatorTrimReplace, + tildeTrimReplace, + caretTrimReplace +} = __webpack_require__(976) + +const isNullSet = c => c.value === '<0.0.0-0' +const isAny = c => c.value === '' + +// take a set of comparators and determine whether there +// exists a version which can satisfy it +const isSatisfiable = (comparators, options) => { + let result = true + const remainingComparators = comparators.slice() + let testComparator = remainingComparators.pop() + + while (result && remainingComparators.length) { + result = remainingComparators.every((otherComparator) => { + return testComparator.intersects(otherComparator, options) + }) + + testComparator = remainingComparators.pop() + } + + return result +} + +// comprised of xranges, tildes, stars, and gtlt's at this point. +// already replaced the hyphen ranges +// turn into a set of JUST comparators. +const parseComparator = (comp, options) => { + debug('comp', comp, options) + comp = replaceCarets(comp, options) + debug('caret', comp) + comp = replaceTildes(comp, options) + debug('tildes', comp) + comp = replaceXRanges(comp, options) + debug('xrange', comp) + comp = replaceStars(comp, options) + debug('stars', comp) + return comp +} + +const isX = id => !id || id.toLowerCase() === 'x' || id === '*' + +// ~, ~> --> * (any, kinda silly) +// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0 +// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0 +// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0 +// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0 +// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0 +const replaceTildes = (comp, options) => + comp.trim().split(/\s+/).map((comp) => { + return replaceTilde(comp, options) + }).join(' ') + +const replaceTilde = (comp, options) => { + const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE] + return comp.replace(r, (_, M, m, p, pr) => { + debug('tilde', comp, _, M, m, p, pr) + let ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = `>=${M}.0.0 <${+M + 1}.0.0-0` + } else if (isX(p)) { + // ~1.2 == >=1.2.0 <1.3.0-0 + ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0` + } else if (pr) { + debug('replaceTilde pr', pr) + ret = `>=${M}.${m}.${p}-${pr + } <${M}.${+m + 1}.0-0` + } else { + // ~1.2.3 == >=1.2.3 <1.3.0-0 + ret = `>=${M}.${m}.${p + } <${M}.${+m + 1}.0-0` + } + + debug('tilde return', ret) + return ret + }) +} + +// ^ --> * (any, kinda silly) +// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0 +// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0 +// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0 +// ^1.2.3 --> >=1.2.3 <2.0.0-0 +// ^1.2.0 --> >=1.2.0 <2.0.0-0 +const replaceCarets = (comp, options) => + comp.trim().split(/\s+/).map((comp) => { + return replaceCaret(comp, options) + }).join(' ') + +const replaceCaret = (comp, options) => { + debug('caret', comp, options) + const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET] + const z = options.includePrerelease ? '-0' : '' + return comp.replace(r, (_, M, m, p, pr) => { + debug('caret', comp, _, M, m, p, pr) + let ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0` + } else if (isX(p)) { + if (M === '0') { + ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0` + } else { + ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0` + } + } else if (pr) { + debug('replaceCaret pr', pr) + if (M === '0') { + if (m === '0') { + ret = `>=${M}.${m}.${p}-${pr + } <${M}.${m}.${+p + 1}-0` + } else { + ret = `>=${M}.${m}.${p}-${pr + } <${M}.${+m + 1}.0-0` + } + } else { + ret = `>=${M}.${m}.${p}-${pr + } <${+M + 1}.0.0-0` + } + } else { + debug('no pr') + if (M === '0') { + if (m === '0') { + ret = `>=${M}.${m}.${p + }${z} <${M}.${m}.${+p + 1}-0` + } else { + ret = `>=${M}.${m}.${p + }${z} <${M}.${+m + 1}.0-0` + } + } else { + ret = `>=${M}.${m}.${p + } <${+M + 1}.0.0-0` + } + } + + debug('caret return', ret) + return ret + }) +} + +const replaceXRanges = (comp, options) => { + debug('replaceXRanges', comp, options) + return comp.split(/\s+/).map((comp) => { + return replaceXRange(comp, options) + }).join(' ') +} + +const replaceXRange = (comp, options) => { + comp = comp.trim() + const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE] + return comp.replace(r, (ret, gtlt, M, m, p, pr) => { + debug('xRange', comp, ret, gtlt, M, m, p, pr) + const xM = isX(M) + const xm = xM || isX(m) + const xp = xm || isX(p) + const anyX = xp + + if (gtlt === '=' && anyX) { + gtlt = '' + } + + // if we're including prereleases in the match, then we need + // to fix this to -0, the lowest possible prerelease value + pr = options.includePrerelease ? '-0' : '' + + if (xM) { + if (gtlt === '>' || gtlt === '<') { + // nothing is allowed + ret = '<0.0.0-0' + } else { + // nothing is forbidden + ret = '*' + } + } else if (gtlt && anyX) { + // we know patch is an x, because we have any x at all. + // replace X with 0 + if (xm) { + m = 0 + } + p = 0 + + if (gtlt === '>') { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + gtlt = '>=' + if (xm) { + M = +M + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === '<=') { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<' + if (xm) { + M = +M + 1 + } else { + m = +m + 1 + } + } + + if (gtlt === '<') + pr = '-0' + + ret = `${gtlt + M}.${m}.${p}${pr}` + } else if (xm) { + ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0` + } else if (xp) { + ret = `>=${M}.${m}.0${pr + } <${M}.${+m + 1}.0-0` + } + + debug('xRange return', ret) + + return ret + }) +} + +// Because * is AND-ed with everything else in the comparator, +// and '' means "any version", just remove the *s entirely. +const replaceStars = (comp, options) => { + debug('replaceStars', comp, options) + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace(re[t.STAR], '') +} + +const replaceGTE0 = (comp, options) => { + debug('replaceGTE0', comp, options) + return comp.trim() + .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '') +} + +// This function is passed to string.replace(re[t.HYPHENRANGE]) +// M, m, patch, prerelease, build +// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 +// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do +// 1.2 - 3.4 => >=1.2.0 <3.5.0-0 +const hyphenReplace = incPr => ($0, + from, fM, fm, fp, fpr, fb, + to, tM, tm, tp, tpr, tb) => { + if (isX(fM)) { + from = '' + } else if (isX(fm)) { + from = `>=${fM}.0.0${incPr ? '-0' : ''}` + } else if (isX(fp)) { + from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}` + } else if (fpr) { + from = `>=${from}` + } else { + from = `>=${from}${incPr ? '-0' : ''}` + } + + if (isX(tM)) { + to = '' + } else if (isX(tm)) { + to = `<${+tM + 1}.0.0-0` + } else if (isX(tp)) { + to = `<${tM}.${+tm + 1}.0-0` + } else if (tpr) { + to = `<=${tM}.${tm}.${tp}-${tpr}` + } else if (incPr) { + to = `<${tM}.${tm}.${+tp + 1}-0` + } else { + to = `<=${to}` + } + + return (`${from} ${to}`).trim() +} + +const testSet = (set, version, options) => { + for (let i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false + } + } + + if (version.prerelease.length && !options.includePrerelease) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for (let i = 0; i < set.length; i++) { + debug(set[i].semver) + if (set[i].semver === Comparator.ANY) { + continue + } + + if (set[i].semver.prerelease.length > 0) { + const allowed = set[i].semver + if (allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch) { + return true + } + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false + } + + return true +} + + +/***/ }), +/* 125 */, +/* 126 */, +/* 127 */, +/* 128 */, +/* 129 */ /***/ (function(module) { module.exports = require("child_process"); /***/ }), - -/***/ 134: +/* 130 */, +/* 131 */, +/* 132 */, +/* 133 */, +/* 134 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -8040,32 +8399,633 @@ exports.pop = pop; //# sourceMappingURL=Stack.js.map /***/ }), +/* 135 */, +/* 136 */, +/* 137 */, +/* 138 */, +/* 139 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { -/***/ 139: -/***/ (function(module, __unusedexports, __webpack_require__) { +"use strict"; -// Unique ID creation requires a high quality random # generator. In node.js -// this is pretty straight-forward - we use the crypto API. - -var crypto = __webpack_require__(417); - -module.exports = function nodeRNG() { - return crypto.randomBytes(16); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); }; - +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const core = __importStar(__webpack_require__(470)); +const io = __importStar(__webpack_require__(1)); +const fs = __importStar(__webpack_require__(747)); +const mm = __importStar(__webpack_require__(31)); +const os = __importStar(__webpack_require__(87)); +const path = __importStar(__webpack_require__(622)); +const httpm = __importStar(__webpack_require__(539)); +const semver = __importStar(__webpack_require__(550)); +const stream = __importStar(__webpack_require__(794)); +const util = __importStar(__webpack_require__(669)); +const v4_1 = __importDefault(__webpack_require__(494)); +const exec_1 = __webpack_require__(986); +const assert_1 = __webpack_require__(357); +const retry_helper_1 = __webpack_require__(979); +class HTTPError extends Error { + constructor(httpStatusCode) { + super(`Unexpected HTTP response: ${httpStatusCode}`); + this.httpStatusCode = httpStatusCode; + Object.setPrototypeOf(this, new.target.prototype); + } +} +exports.HTTPError = HTTPError; +const IS_WINDOWS = process.platform === 'win32'; +const IS_MAC = process.platform === 'darwin'; +const userAgent = 'actions/tool-cache'; +/** + * Download a tool from an url and stream it into a file + * + * @param url url of tool to download + * @param dest path to download tool + * @param auth authorization header + * @returns path to downloaded tool + */ +function downloadTool(url, dest, auth) { + return __awaiter(this, void 0, void 0, function* () { + dest = dest || path.join(_getTempDirectory(), v4_1.default()); + yield io.mkdirP(path.dirname(dest)); + core.debug(`Downloading ${url}`); + core.debug(`Destination ${dest}`); + const maxAttempts = 3; + const minSeconds = _getGlobal('TEST_DOWNLOAD_TOOL_RETRY_MIN_SECONDS', 10); + const maxSeconds = _getGlobal('TEST_DOWNLOAD_TOOL_RETRY_MAX_SECONDS', 20); + const retryHelper = new retry_helper_1.RetryHelper(maxAttempts, minSeconds, maxSeconds); + return yield retryHelper.execute(() => __awaiter(this, void 0, void 0, function* () { + return yield downloadToolAttempt(url, dest || '', auth); + }), (err) => { + if (err instanceof HTTPError && err.httpStatusCode) { + // Don't retry anything less than 500, except 408 Request Timeout and 429 Too Many Requests + if (err.httpStatusCode < 500 && + err.httpStatusCode !== 408 && + err.httpStatusCode !== 429) { + return false; + } + } + // Otherwise retry + return true; + }); + }); +} +exports.downloadTool = downloadTool; +function downloadToolAttempt(url, dest, auth) { + return __awaiter(this, void 0, void 0, function* () { + if (fs.existsSync(dest)) { + throw new Error(`Destination file path ${dest} already exists`); + } + // Get the response headers + const http = new httpm.HttpClient(userAgent, [], { + allowRetries: false + }); + let headers; + if (auth) { + core.debug('set auth'); + headers = { + authorization: auth + }; + } + const response = yield http.get(url, headers); + if (response.message.statusCode !== 200) { + const err = new HTTPError(response.message.statusCode); + core.debug(`Failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`); + throw err; + } + // Download the response body + const pipeline = util.promisify(stream.pipeline); + const responseMessageFactory = _getGlobal('TEST_DOWNLOAD_TOOL_RESPONSE_MESSAGE_FACTORY', () => response.message); + const readStream = responseMessageFactory(); + let succeeded = false; + try { + yield pipeline(readStream, fs.createWriteStream(dest)); + core.debug('download complete'); + succeeded = true; + return dest; + } + finally { + // Error, delete dest before retry + if (!succeeded) { + core.debug('download failed'); + try { + yield io.rmRF(dest); + } + catch (err) { + core.debug(`Failed to delete '${dest}'. ${err.message}`); + } + } + } + }); +} +/** + * Extract a .7z file + * + * @param file path to the .7z file + * @param dest destination directory. Optional. + * @param _7zPath path to 7zr.exe. Optional, for long path support. Most .7z archives do not have this + * problem. If your .7z archive contains very long paths, you can pass the path to 7zr.exe which will + * gracefully handle long paths. By default 7zdec.exe is used because it is a very small program and is + * bundled with the tool lib. However it does not support long paths. 7zr.exe is the reduced command line + * interface, it is smaller than the full command line interface, and it does support long paths. At the + * time of this writing, it is freely available from the LZMA SDK that is available on the 7zip website. + * Be sure to check the current license agreement. If 7zr.exe is bundled with your action, then the path + * to 7zr.exe can be pass to this function. + * @returns path to the destination directory + */ +function extract7z(file, dest, _7zPath) { + return __awaiter(this, void 0, void 0, function* () { + assert_1.ok(IS_WINDOWS, 'extract7z() not supported on current OS'); + assert_1.ok(file, 'parameter "file" is required'); + dest = yield _createExtractFolder(dest); + const originalCwd = process.cwd(); + process.chdir(dest); + if (_7zPath) { + try { + const logLevel = core.isDebug() ? '-bb1' : '-bb0'; + const args = [ + 'x', + logLevel, + '-bd', + '-sccUTF-8', + file + ]; + const options = { + silent: true + }; + yield exec_1.exec(`"${_7zPath}"`, args, options); + } + finally { + process.chdir(originalCwd); + } + } + else { + const escapedScript = path + .join(__dirname, '..', 'scripts', 'Invoke-7zdec.ps1') + .replace(/'/g, "''") + .replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines + const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, ''); + const escapedTarget = dest.replace(/'/g, "''").replace(/"|\n|\r/g, ''); + const command = `& '${escapedScript}' -Source '${escapedFile}' -Target '${escapedTarget}'`; + const args = [ + '-NoLogo', + '-Sta', + '-NoProfile', + '-NonInteractive', + '-ExecutionPolicy', + 'Unrestricted', + '-Command', + command + ]; + const options = { + silent: true + }; + try { + const powershellPath = yield io.which('powershell', true); + yield exec_1.exec(`"${powershellPath}"`, args, options); + } + finally { + process.chdir(originalCwd); + } + } + return dest; + }); +} +exports.extract7z = extract7z; +/** + * Extract a compressed tar archive + * + * @param file path to the tar + * @param dest destination directory. Optional. + * @param flags flags for the tar command to use for extraction. Defaults to 'xz' (extracting gzipped tars). Optional. + * @returns path to the destination directory + */ +function extractTar(file, dest, flags = 'xz') { + return __awaiter(this, void 0, void 0, function* () { + if (!file) { + throw new Error("parameter 'file' is required"); + } + // Create dest + dest = yield _createExtractFolder(dest); + // Determine whether GNU tar + core.debug('Checking tar --version'); + let versionOutput = ''; + yield exec_1.exec('tar --version', [], { + ignoreReturnCode: true, + silent: true, + listeners: { + stdout: (data) => (versionOutput += data.toString()), + stderr: (data) => (versionOutput += data.toString()) + } + }); + core.debug(versionOutput.trim()); + const isGnuTar = versionOutput.toUpperCase().includes('GNU TAR'); + // Initialize args + let args; + if (flags instanceof Array) { + args = flags; + } + else { + args = [flags]; + } + if (core.isDebug() && !flags.includes('v')) { + args.push('-v'); + } + let destArg = dest; + let fileArg = file; + if (IS_WINDOWS && isGnuTar) { + args.push('--force-local'); + destArg = dest.replace(/\\/g, '/'); + // Technically only the dest needs to have `/` but for aesthetic consistency + // convert slashes in the file arg too. + fileArg = file.replace(/\\/g, '/'); + } + if (isGnuTar) { + // Suppress warnings when using GNU tar to extract archives created by BSD tar + args.push('--warning=no-unknown-keyword'); + } + args.push('-C', destArg, '-f', fileArg); + yield exec_1.exec(`tar`, args); + return dest; + }); +} +exports.extractTar = extractTar; +/** + * Extract a xar compatible archive + * + * @param file path to the archive + * @param dest destination directory. Optional. + * @param flags flags for the xar. Optional. + * @returns path to the destination directory + */ +function extractXar(file, dest, flags = []) { + return __awaiter(this, void 0, void 0, function* () { + assert_1.ok(IS_MAC, 'extractXar() not supported on current OS'); + assert_1.ok(file, 'parameter "file" is required'); + dest = yield _createExtractFolder(dest); + let args; + if (flags instanceof Array) { + args = flags; + } + else { + args = [flags]; + } + args.push('-x', '-C', dest, '-f', file); + if (core.isDebug()) { + args.push('-v'); + } + const xarPath = yield io.which('xar', true); + yield exec_1.exec(`"${xarPath}"`, _unique(args)); + return dest; + }); +} +exports.extractXar = extractXar; +/** + * Extract a zip + * + * @param file path to the zip + * @param dest destination directory. Optional. + * @returns path to the destination directory + */ +function extractZip(file, dest) { + return __awaiter(this, void 0, void 0, function* () { + if (!file) { + throw new Error("parameter 'file' is required"); + } + dest = yield _createExtractFolder(dest); + if (IS_WINDOWS) { + yield extractZipWin(file, dest); + } + else { + yield extractZipNix(file, dest); + } + return dest; + }); +} +exports.extractZip = extractZip; +function extractZipWin(file, dest) { + return __awaiter(this, void 0, void 0, function* () { + // build the powershell command + const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines + const escapedDest = dest.replace(/'/g, "''").replace(/"|\n|\r/g, ''); + const command = `$ErrorActionPreference = 'Stop' ; try { Add-Type -AssemblyName System.IO.Compression.FileSystem } catch { } ; [System.IO.Compression.ZipFile]::ExtractToDirectory('${escapedFile}', '${escapedDest}')`; + // run powershell + const powershellPath = yield io.which('powershell', true); + const args = [ + '-NoLogo', + '-Sta', + '-NoProfile', + '-NonInteractive', + '-ExecutionPolicy', + 'Unrestricted', + '-Command', + command + ]; + yield exec_1.exec(`"${powershellPath}"`, args); + }); +} +function extractZipNix(file, dest) { + return __awaiter(this, void 0, void 0, function* () { + const unzipPath = yield io.which('unzip', true); + const args = [file]; + if (!core.isDebug()) { + args.unshift('-q'); + } + yield exec_1.exec(`"${unzipPath}"`, args, { cwd: dest }); + }); +} +/** + * Caches a directory and installs it into the tool cacheDir + * + * @param sourceDir the directory to cache into tools + * @param tool tool name + * @param version version of the tool. semver format + * @param arch architecture of the tool. Optional. Defaults to machine architecture + */ +function cacheDir(sourceDir, tool, version, arch) { + return __awaiter(this, void 0, void 0, function* () { + version = semver.clean(version) || version; + arch = arch || os.arch(); + core.debug(`Caching tool ${tool} ${version} ${arch}`); + core.debug(`source dir: ${sourceDir}`); + if (!fs.statSync(sourceDir).isDirectory()) { + throw new Error('sourceDir is not a directory'); + } + // Create the tool dir + const destPath = yield _createToolPath(tool, version, arch); + // copy each child item. do not move. move can fail on Windows + // due to anti-virus software having an open handle on a file. + for (const itemName of fs.readdirSync(sourceDir)) { + const s = path.join(sourceDir, itemName); + yield io.cp(s, destPath, { recursive: true }); + } + // write .complete + _completeToolPath(tool, version, arch); + return destPath; + }); +} +exports.cacheDir = cacheDir; +/** + * Caches a downloaded file (GUID) and installs it + * into the tool cache with a given targetName + * + * @param sourceFile the file to cache into tools. Typically a result of downloadTool which is a guid. + * @param targetFile the name of the file name in the tools directory + * @param tool tool name + * @param version version of the tool. semver format + * @param arch architecture of the tool. Optional. Defaults to machine architecture + */ +function cacheFile(sourceFile, targetFile, tool, version, arch) { + return __awaiter(this, void 0, void 0, function* () { + version = semver.clean(version) || version; + arch = arch || os.arch(); + core.debug(`Caching tool ${tool} ${version} ${arch}`); + core.debug(`source file: ${sourceFile}`); + if (!fs.statSync(sourceFile).isFile()) { + throw new Error('sourceFile is not a file'); + } + // create the tool dir + const destFolder = yield _createToolPath(tool, version, arch); + // copy instead of move. move can fail on Windows due to + // anti-virus software having an open handle on a file. + const destPath = path.join(destFolder, targetFile); + core.debug(`destination file ${destPath}`); + yield io.cp(sourceFile, destPath); + // write .complete + _completeToolPath(tool, version, arch); + return destFolder; + }); +} +exports.cacheFile = cacheFile; +/** + * Finds the path to a tool version in the local installed tool cache + * + * @param toolName name of the tool + * @param versionSpec version of the tool + * @param arch optional arch. defaults to arch of computer + */ +function find(toolName, versionSpec, arch) { + if (!toolName) { + throw new Error('toolName parameter is required'); + } + if (!versionSpec) { + throw new Error('versionSpec parameter is required'); + } + arch = arch || os.arch(); + // attempt to resolve an explicit version + if (!_isExplicitVersion(versionSpec)) { + const localVersions = findAllVersions(toolName, arch); + const match = _evaluateVersions(localVersions, versionSpec); + versionSpec = match; + } + // check for the explicit version in the cache + let toolPath = ''; + if (versionSpec) { + versionSpec = semver.clean(versionSpec) || ''; + const cachePath = path.join(_getCacheDirectory(), toolName, versionSpec, arch); + core.debug(`checking cache: ${cachePath}`); + if (fs.existsSync(cachePath) && fs.existsSync(`${cachePath}.complete`)) { + core.debug(`Found tool in cache ${toolName} ${versionSpec} ${arch}`); + toolPath = cachePath; + } + else { + core.debug('not found'); + } + } + return toolPath; +} +exports.find = find; +/** + * Finds the paths to all versions of a tool that are installed in the local tool cache + * + * @param toolName name of the tool + * @param arch optional arch. defaults to arch of computer + */ +function findAllVersions(toolName, arch) { + const versions = []; + arch = arch || os.arch(); + const toolPath = path.join(_getCacheDirectory(), toolName); + if (fs.existsSync(toolPath)) { + const children = fs.readdirSync(toolPath); + for (const child of children) { + if (_isExplicitVersion(child)) { + const fullPath = path.join(toolPath, child, arch || ''); + if (fs.existsSync(fullPath) && fs.existsSync(`${fullPath}.complete`)) { + versions.push(child); + } + } + } + } + return versions; +} +exports.findAllVersions = findAllVersions; +function getManifestFromRepo(owner, repo, auth, branch = 'master') { + return __awaiter(this, void 0, void 0, function* () { + let releases = []; + const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}`; + const http = new httpm.HttpClient('tool-cache'); + const headers = {}; + if (auth) { + core.debug('set auth'); + headers.authorization = auth; + } + const response = yield http.getJson(treeUrl, headers); + if (!response.result) { + return releases; + } + let manifestUrl = ''; + for (const item of response.result.tree) { + if (item.path === 'versions-manifest.json') { + manifestUrl = item.url; + break; + } + } + headers['accept'] = 'application/vnd.github.VERSION.raw'; + let versionsRaw = yield (yield http.get(manifestUrl, headers)).readBody(); + if (versionsRaw) { + // shouldn't be needed but protects against invalid json saved with BOM + versionsRaw = versionsRaw.replace(/^\uFEFF/, ''); + try { + releases = JSON.parse(versionsRaw); + } + catch (_a) { + core.debug('Invalid json'); + } + } + return releases; + }); +} +exports.getManifestFromRepo = getManifestFromRepo; +function findFromManifest(versionSpec, stable, manifest, archFilter = os.arch()) { + return __awaiter(this, void 0, void 0, function* () { + // wrap the internal impl + const match = yield mm._findMatch(versionSpec, stable, manifest, archFilter); + return match; + }); +} +exports.findFromManifest = findFromManifest; +function _createExtractFolder(dest) { + return __awaiter(this, void 0, void 0, function* () { + if (!dest) { + // create a temp dir + dest = path.join(_getTempDirectory(), v4_1.default()); + } + yield io.mkdirP(dest); + return dest; + }); +} +function _createToolPath(tool, version, arch) { + return __awaiter(this, void 0, void 0, function* () { + const folderPath = path.join(_getCacheDirectory(), tool, semver.clean(version) || version, arch || ''); + core.debug(`destination ${folderPath}`); + const markerPath = `${folderPath}.complete`; + yield io.rmRF(folderPath); + yield io.rmRF(markerPath); + yield io.mkdirP(folderPath); + return folderPath; + }); +} +function _completeToolPath(tool, version, arch) { + const folderPath = path.join(_getCacheDirectory(), tool, semver.clean(version) || version, arch || ''); + const markerPath = `${folderPath}.complete`; + fs.writeFileSync(markerPath, ''); + core.debug('finished caching tool'); +} +function _isExplicitVersion(versionSpec) { + const c = semver.clean(versionSpec) || ''; + core.debug(`isExplicit: ${c}`); + const valid = semver.valid(c) != null; + core.debug(`explicit? ${valid}`); + return valid; +} +function _evaluateVersions(versions, versionSpec) { + let version = ''; + core.debug(`evaluating ${versions.length} versions`); + versions = versions.sort((a, b) => { + if (semver.gt(a, b)) { + return 1; + } + return -1; + }); + for (let i = versions.length - 1; i >= 0; i--) { + const potential = versions[i]; + const satisfied = semver.satisfies(potential, versionSpec); + if (satisfied) { + version = potential; + break; + } + } + if (version) { + core.debug(`matched: ${version}`); + } + else { + core.debug('match not found'); + } + return version; +} +/** + * Gets RUNNER_TOOL_CACHE + */ +function _getCacheDirectory() { + const cacheDirectory = process.env['RUNNER_TOOL_CACHE'] || ''; + assert_1.ok(cacheDirectory, 'Expected RUNNER_TOOL_CACHE to be defined'); + return cacheDirectory; +} +/** + * Gets RUNNER_TEMP + */ +function _getTempDirectory() { + const tempDirectory = process.env['RUNNER_TEMP'] || ''; + assert_1.ok(tempDirectory, 'Expected RUNNER_TEMP to be defined'); + return tempDirectory; +} +/** + * Gets a global variable + */ +function _getGlobal(key, defaultValue) { + /* eslint-disable @typescript-eslint/no-explicit-any */ + const value = global[key]; + /* eslint-enable @typescript-eslint/no-explicit-any */ + return value !== undefined ? value : defaultValue; +} +/** + * Returns an array of unique values. + * @param values Values to make unique. + */ +function _unique(values) { + return Array.from(new Set(values)); +} +//# sourceMappingURL=tool-cache.js.map /***/ }), - -/***/ 141: +/* 140 */, +/* 141 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; var net = __webpack_require__(631); -var tls = __webpack_require__(16); +var tls = __webpack_require__(818); var http = __webpack_require__(605); -var https = __webpack_require__(211); +var https = __webpack_require__(34); var events = __webpack_require__(614); var assert = __webpack_require__(357); var util = __webpack_require__(669); @@ -8327,14 +9287,165 @@ exports.debug = debug; // for test /***/ }), +/* 142 */, +/* 143 */ +/***/ (function(module) { -/***/ 146: +// parse out just the options we care about so we always get a consistent +// obj with keys in a consistent order. +const opts = ['includePrerelease', 'loose', 'rtl'] +const parseOptions = options => + !options ? {} + : typeof options !== 'object' ? { loose: true } + : opts.filter(k => options[k]).reduce((options, k) => { + options[k] = true + return options + }, {}) +module.exports = parseOptions + + +/***/ }), +/* 144 */ /***/ (function(__unusedmodule, exports, __webpack_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.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 }); -const infra_1 = __webpack_require__(23); +exports.LocalDistribution = void 0; +const tc = __importStar(__webpack_require__(139)); +const core = __importStar(__webpack_require__(470)); +const fs_1 = __importDefault(__webpack_require__(747)); +const path_1 = __importDefault(__webpack_require__(622)); +const base_installer_1 = __webpack_require__(83); +const util_1 = __webpack_require__(322); +const constants_1 = __webpack_require__(211); +class LocalDistribution extends base_installer_1.JavaBase { + constructor(installerOptions, jdkFile) { + super('jdkfile', installerOptions); + this.jdkFile = jdkFile; + } + setupJava() { + return __awaiter(this, void 0, void 0, function* () { + let foundJava = this.findInToolcache(); + if (foundJava) { + core.info(`Resolved Java ${foundJava.version} from tool-cache`); + } + else { + core.info(`Java ${this.version} was not found in tool-cache. Trying to unpack JDK file...`); + if (!this.jdkFile) { + throw new Error("'jdkFile' is not specified"); + } + const jdkFilePath = path_1.default.resolve(this.jdkFile); + const stats = fs_1.default.statSync(jdkFilePath); + if (!stats.isFile()) { + throw new Error(`JDK file was not found in path '${jdkFilePath}'`); + } + core.info(`Extracting Java from '${jdkFilePath}'`); + const extractedJavaPath = yield util_1.extractJdkFile(jdkFilePath); + const archiveName = fs_1.default.readdirSync(extractedJavaPath)[0]; + const archivePath = path_1.default.join(extractedJavaPath, archiveName); + const javaVersion = this.version; + let javaPath = yield tc.cacheDir(archivePath, this.toolcacheFolderName, this.getToolcacheVersionName(javaVersion), this.architecture); + // for different Java distributions, postfix can exist or not so need to check both cases + if (process.platform === 'darwin' && + fs_1.default.existsSync(path_1.default.join(javaPath, constants_1.MACOS_JAVA_CONTENT_POSTFIX))) { + javaPath = path_1.default.join(javaPath, constants_1.MACOS_JAVA_CONTENT_POSTFIX); + } + foundJava = { + version: javaVersion, + path: javaPath + }; + } + core.info(`Setting Java ${foundJava.version} as default`); + this.setJavaDefault(foundJava.version, foundJava.path); + return foundJava; + }); + } + findPackageForDownload(version) { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('This method should not be implemented in local file provider'); + }); + } + downloadTool(javaRelease) { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('This method should not be implemented in local file provider'); + }); + } +} +exports.LocalDistribution = LocalDistribution; + + +/***/ }), +/* 145 */, +/* 146 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var infra_1 = __webpack_require__(23); /** * Converts a whitespace separated string into an array of tokens. * @@ -8347,7 +9458,7 @@ function orderedSet_parse(value) { * 3. For each token in inputTokens, append token to tokens. * 4. Return tokens. */ - const inputTokens = infra_1.string.splitAStringOnASCIIWhitespace(value); + var inputTokens = infra_1.string.splitAStringOnASCIIWhitespace(value); return new Set(inputTokens); } exports.orderedSet_parse = orderedSet_parse; @@ -8361,7 +9472,7 @@ function orderedSet_serialize(tokens) { * The ordered set serializer takes a set and returns the concatenation of * set using U+0020 SPACE. */ - return [...tokens].join(' '); + return __spread(tokens).join(' '); } exports.orderedSet_serialize = orderedSet_serialize; /** @@ -8382,24 +9493,45 @@ exports.orderedSet_sanitize = orderedSet_sanitize; * @param caseSensitive - whether matches are case-sensitive */ function orderedSet_contains(set1, set2, caseSensitive) { - for (const val2 of set2) { - let found = false; - for (const val1 of set1) { - if (caseSensitive) { - if (val1 === val2) { - found = true; - break; + var e_1, _a, e_2, _b; + try { + for (var set2_1 = __values(set2), set2_1_1 = set2_1.next(); !set2_1_1.done; set2_1_1 = set2_1.next()) { + var val2 = set2_1_1.value; + var found = false; + try { + for (var set1_1 = (e_2 = void 0, __values(set1)), set1_1_1 = set1_1.next(); !set1_1_1.done; set1_1_1 = set1_1.next()) { + var val1 = set1_1_1.value; + if (caseSensitive) { + if (val1 === val2) { + found = true; + break; + } + } + else { + if (val1.toUpperCase() === val2.toUpperCase()) { + found = true; + break; + } + } } } - else { - if (val1.toUpperCase() === val2.toUpperCase()) { - found = true; - break; + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (set1_1_1 && !set1_1_1.done && (_b = set1_1.return)) _b.call(set1_1); } + finally { if (e_2) throw e_2.error; } } + if (!found) + return false; } - if (!found) - return false; + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (set2_1_1 && !set2_1_1.done && (_a = set2_1.return)) _a.call(set2_1); + } + finally { if (e_1) throw e_1.error; } } return true; } @@ -8407,19 +9539,49 @@ exports.orderedSet_contains = orderedSet_contains; //# sourceMappingURL=OrderedSetAlgorithm.js.map /***/ }), - -/***/ 151: +/* 147 */, +/* 148 */, +/* 149 */, +/* 150 */, +/* 151 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const util_1 = __webpack_require__(918); -const infra_1 = __webpack_require__(23); -const CreateAlgorithm_1 = __webpack_require__(86); -const TreeAlgorithm_1 = __webpack_require__(873); -const EventAlgorithm_1 = __webpack_require__(108); +var DOMImpl_1 = __webpack_require__(648); +var util_1 = __webpack_require__(918); +var infra_1 = __webpack_require__(23); +var CreateAlgorithm_1 = __webpack_require__(86); +var TreeAlgorithm_1 = __webpack_require__(873); +var EventAlgorithm_1 = __webpack_require__(826); /** * Queues a mutation observer microtask to the surrounding agent’s mutation * observers. @@ -8431,45 +9593,43 @@ function observer_queueAMutationObserverMicrotask() { * 2. Set the surrounding agent’s mutation observer microtask queued to true. * 3. Queue a microtask to notify mutation observers. */ - const window = dom_1.dom.window; + var window = DOMImpl_1.dom.window; if (window._mutationObserverMicrotaskQueued) return; window._mutationObserverMicrotaskQueued = true; - Promise.resolve().then(() => { observer_notifyMutationObservers(); }); + Promise.resolve().then(function () { observer_notifyMutationObservers(); }); } exports.observer_queueAMutationObserverMicrotask = observer_queueAMutationObserverMicrotask; /** * Notifies the surrounding agent’s mutation observers. */ function observer_notifyMutationObservers() { + var e_1, _a, e_2, _b; /** * 1. Set the surrounding agent’s mutation observer microtask queued to false. * 2. Let notifySet be a clone of the surrounding agent’s mutation observers. * 3. Let signalSet be a clone of the surrounding agent’s signal slots. * 4. Empty the surrounding agent’s signal slots. */ - const window = dom_1.dom.window; + var window = DOMImpl_1.dom.window; window._mutationObserverMicrotaskQueued = false; - const notifySet = infra_1.set.clone(window._mutationObservers); - const signalSet = infra_1.set.clone(window._signalSlots); + var notifySet = infra_1.set.clone(window._mutationObservers); + var signalSet = infra_1.set.clone(window._signalSlots); infra_1.set.empty(window._signalSlots); - /** - * 5. For each mo of notifySet: - */ - for (const mo of notifySet) { + var _loop_1 = function (mo) { /** * 5.1. Let records be a clone of mo’s record queue. * 5.2. Empty mo’s record queue. */ - const records = infra_1.list.clone(mo._recordQueue); + var records = infra_1.list.clone(mo._recordQueue); infra_1.list.empty(mo._recordQueue); /** * 5.3. For each node of mo’s node list, remove all transient registered * observers whose observer is mo from node’s registered observer list. */ - for (let i = 0; i < mo._nodeList.length; i++) { - const node = mo._nodeList[i]; - infra_1.list.remove(node._registeredObserverList, (observer) => { + for (var i = 0; i < mo._nodeList.length; i++) { + var node = mo._nodeList[i]; + infra_1.list.remove(node._registeredObserverList, function (observer) { return util_1.Guard.isTransientRegisteredObserver(observer) && observer.observer === mo; }); } @@ -8485,14 +9645,40 @@ function observer_notifyMutationObservers() { // TODO: Report the exception } } + }; + try { + /** + * 5. For each mo of notifySet: + */ + for (var notifySet_1 = __values(notifySet), notifySet_1_1 = notifySet_1.next(); !notifySet_1_1.done; notifySet_1_1 = notifySet_1.next()) { + var mo = notifySet_1_1.value; + _loop_1(mo); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (notifySet_1_1 && !notifySet_1_1.done && (_a = notifySet_1.return)) _a.call(notifySet_1); + } + finally { if (e_1) throw e_1.error; } } /** * 6. For each slot of signalSet, fire an event named slotchange, with its * bubbles attribute set to true, at slot. */ - if (dom_1.dom.features.slots) { - for (const slot of signalSet) { - EventAlgorithm_1.event_fireAnEvent("slotchange", slot, undefined, { bubbles: true }); + if (DOMImpl_1.dom.features.slots) { + try { + for (var signalSet_1 = __values(signalSet), signalSet_1_1 = signalSet_1.next(); !signalSet_1_1.done; signalSet_1_1 = signalSet_1.next()) { + var slot = signalSet_1_1.value; + EventAlgorithm_1.event_fireAnEvent("slotchange", slot, undefined, { bubbles: true }); + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (signalSet_1_1 && !signalSet_1_1.done && (_b = signalSet_1.return)) _b.call(signalSet_1); + } + finally { if (e_2) throw e_2.error; } } } } @@ -8511,17 +9697,18 @@ exports.observer_notifyMutationObservers = observer_notifyMutationObservers; * @param nextSibling - next sibling of target before mutation */ function observer_queueMutationRecord(type, target, name, namespace, oldValue, addedNodes, removedNodes, previousSibling, nextSibling) { + var e_3, _a; /** * 1. Let interestedObservers be an empty map. * 2. Let nodes be the inclusive ancestors of target. * 3. For each node in nodes, and then for each registered of node’s * registered observer list: */ - const interestedObservers = new Map(); - let node = TreeAlgorithm_1.tree_getFirstAncestorNode(target, true); + var interestedObservers = new Map(); + var node = TreeAlgorithm_1.tree_getFirstAncestorNode(target, true); while (node !== null) { - for (let i = 0; i < node._registeredObserverList.length; i++) { - const registered = node._registeredObserverList[i]; + for (var i = 0; i < node._registeredObserverList.length; i++) { + var registered = node._registeredObserverList[i]; /** * 3.1. Let options be registered’s options. * 3.2. If none of the following are true @@ -8533,13 +9720,13 @@ function observer_queueMutationRecord(type, target, name, namespace, oldValue, a * - type is "characterData" and options’s characterData is not true * - type is "childList" and options’s childList is false */ - const options = registered.options; + var options = registered.options; if (node !== target && !options.subtree) continue; if (type === "attributes" && !options.attributes) continue; if (type === "attributes" && options.attributeFilter && - (!options.attributeFilter.includes(name || '') || namespace !== null)) + (!options.attributeFilter.indexOf(name || '') || namespace !== null)) continue; if (type === "characterData" && !options.characterData) continue; @@ -8555,7 +9742,7 @@ function observer_queueMutationRecord(type, target, name, namespace, oldValue, a * characterDataOldValue is true, then set interestedObservers[mo] * to oldValue. */ - const mo = registered.observer; + var mo = registered.observer; if (!interestedObservers.has(mo)) { interestedObservers.set(mo, null); } @@ -8566,22 +9753,32 @@ function observer_queueMutationRecord(type, target, name, namespace, oldValue, a } node = TreeAlgorithm_1.tree_getNextAncestorNode(target, node, true); } - /** - * 4. For each observer → mappedOldValue of interestedObservers: - */ - for (const [observer, mappedOldValue] of interestedObservers) { + try { /** - * 4.1. Let record be a new MutationRecord object with its type set to - * type, target set to target, attributeName set to name, - * attributeNamespace set to namespace, oldValue set to mappedOldValue, - * addedNodes set to addedNodes, removedNodes set to removedNodes, - * previousSibling set to previousSibling, and nextSibling set to - * nextSibling. - * 4.2. Enqueue record to observer’s record queue. + * 4. For each observer → mappedOldValue of interestedObservers: */ - const record = CreateAlgorithm_1.create_mutationRecord(type, target, CreateAlgorithm_1.create_nodeListStatic(target, addedNodes), CreateAlgorithm_1.create_nodeListStatic(target, removedNodes), previousSibling, nextSibling, name, namespace, mappedOldValue); - const queue = observer._recordQueue; - queue.push(record); + for (var interestedObservers_1 = __values(interestedObservers), interestedObservers_1_1 = interestedObservers_1.next(); !interestedObservers_1_1.done; interestedObservers_1_1 = interestedObservers_1.next()) { + var _b = __read(interestedObservers_1_1.value, 2), observer = _b[0], mappedOldValue = _b[1]; + /** + * 4.1. Let record be a new MutationRecord object with its type set to + * type, target set to target, attributeName set to name, + * attributeNamespace set to namespace, oldValue set to mappedOldValue, + * addedNodes set to addedNodes, removedNodes set to removedNodes, + * previousSibling set to previousSibling, and nextSibling set to + * nextSibling. + * 4.2. Enqueue record to observer’s record queue. + */ + var record = CreateAlgorithm_1.create_mutationRecord(type, target, CreateAlgorithm_1.create_nodeListStatic(target, addedNodes), CreateAlgorithm_1.create_nodeListStatic(target, removedNodes), previousSibling, nextSibling, name, namespace, mappedOldValue); + var queue = observer._recordQueue; + queue.push(record); + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (interestedObservers_1_1 && !interestedObservers_1_1.done && (_a = interestedObservers_1.return)) _a.call(interestedObservers_1); + } + finally { if (e_3) throw e_3.error; } } /** * 5. Queue a mutation observer microtask. @@ -8628,41 +9825,55 @@ exports.observer_queueAttributeMutationRecord = observer_queueAttributeMutationR //# sourceMappingURL=MutationObserverAlgorithm.js.map /***/ }), - -/***/ 154: +/* 152 */, +/* 153 */, +/* 154 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const util_1 = __webpack_require__(918); -const DOMException_1 = __webpack_require__(35); -const CreateAlgorithm_1 = __webpack_require__(86); -const TreeAlgorithm_1 = __webpack_require__(873); -const CharacterDataAlgorithm_1 = __webpack_require__(27); -const MutationAlgorithm_1 = __webpack_require__(479); +var DOMImpl_1 = __webpack_require__(648); +var util_1 = __webpack_require__(918); +var DOMException_1 = __webpack_require__(35); +var CreateAlgorithm_1 = __webpack_require__(86); +var TreeAlgorithm_1 = __webpack_require__(873); +var CharacterDataAlgorithm_1 = __webpack_require__(27); +var MutationAlgorithm_1 = __webpack_require__(479); /** * Returns node with its adjacent text and cdata node siblings. * * @param node - a node * @param self - whether to include node itself */ -function text_contiguousTextNodes(node, self = false) { +function text_contiguousTextNodes(node, self) { + var _a; + if (self === void 0) { self = false; } /** * The contiguous Text nodes of a node node are node, node’s previous * sibling Text node, if any, and its contiguous Text nodes, and node’s next * sibling Text node, if any, and its contiguous Text nodes, avoiding any * duplicates. */ - return { - [Symbol.iterator]() { - let currentNode = node; + return _a = {}, + _a[Symbol.iterator] = function () { + var currentNode = node; while (currentNode && util_1.Guard.isTextNode(currentNode._previousSibling)) { currentNode = currentNode._previousSibling; } return { - next() { + next: function () { if (currentNode && (!self && currentNode === node)) { if (util_1.Guard.isTextNode(currentNode._nextSibling)) { currentNode = currentNode._nextSibling; @@ -8675,7 +9886,7 @@ function text_contiguousTextNodes(node, self = false) { return { done: true, value: null }; } else { - const result = { done: false, value: currentNode }; + var result = { done: false, value: currentNode }; if (util_1.Guard.isTextNode(currentNode._nextSibling)) { currentNode = currentNode._nextSibling; } @@ -8686,8 +9897,8 @@ function text_contiguousTextNodes(node, self = false) { } } }; - } - }; + }, + _a; } exports.text_contiguousTextNodes = text_contiguousTextNodes; /** @@ -8696,21 +9907,23 @@ exports.text_contiguousTextNodes = text_contiguousTextNodes; * @param node - a node * @param self - whether to include node itself */ -function text_contiguousExclusiveTextNodes(node, self = false) { +function text_contiguousExclusiveTextNodes(node, self) { + var _a; + if (self === void 0) { self = false; } /** * The contiguous exclusive Text nodes of a node node are node, node’s * previous sibling exclusive Text node, if any, and its contiguous * exclusive Text nodes, and node’s next sibling exclusive Text node, * if any, and its contiguous exclusive Text nodes, avoiding any duplicates. */ - return { - [Symbol.iterator]() { - let currentNode = node; + return _a = {}, + _a[Symbol.iterator] = function () { + var currentNode = node; while (currentNode && util_1.Guard.isExclusiveTextNode(currentNode._previousSibling)) { currentNode = currentNode._previousSibling; } return { - next() { + next: function () { if (currentNode && (!self && currentNode === node)) { if (util_1.Guard.isExclusiveTextNode(currentNode._nextSibling)) { currentNode = currentNode._nextSibling; @@ -8723,7 +9936,7 @@ function text_contiguousExclusiveTextNodes(node, self = false) { return { done: true, value: null }; } else { - const result = { done: false, value: currentNode }; + var result = { done: false, value: currentNode }; if (util_1.Guard.isExclusiveTextNode(currentNode._nextSibling)) { currentNode = currentNode._nextSibling; } @@ -8734,8 +9947,8 @@ function text_contiguousExclusiveTextNodes(node, self = false) { } } }; - } - }; + }, + _a; } exports.text_contiguousExclusiveTextNodes = text_contiguousExclusiveTextNodes; /** @@ -8749,11 +9962,11 @@ function text_descendantTextContent(node) { * The descendant text content of a node node is the concatenation of the * data of all the Text node descendants of node, in tree order. */ - let contents = ''; - let text = TreeAlgorithm_1.tree_getFirstDescendantNode(node, false, false, (e) => util_1.Guard.isTextNode(e)); + var contents = ''; + var text = TreeAlgorithm_1.tree_getFirstDescendantNode(node, false, false, function (e) { return util_1.Guard.isTextNode(e); }); while (text !== null) { contents += text._data; - text = TreeAlgorithm_1.tree_getNextDescendantNode(node, text, false, false, (e) => util_1.Guard.isTextNode(e)); + text = TreeAlgorithm_1.tree_getNextDescendantNode(node, text, false, false, function (e) { return util_1.Guard.isTextNode(e); }); } return contents; } @@ -8766,12 +9979,13 @@ exports.text_descendantTextContent = text_descendantTextContent; * @param offset - the offset at which to split the nodes. */ function text_split(node, offset) { + var e_1, _a; /** * 1. Let length be node’s length. * 2. If offset is greater than length, then throw an "IndexSizeError" * DOMException. */ - const length = node._data.length; + var length = node._data.length; if (offset > length) { throw new DOMException_1.IndexSizeError(); } @@ -8784,43 +9998,53 @@ function text_split(node, offset) { * 6. Let parent be node’s parent. * 7. If parent is not null, then: */ - const count = length - offset; - const newData = CharacterDataAlgorithm_1.characterData_substringData(node, offset, count); - const newNode = CreateAlgorithm_1.create_text(node._nodeDocument, newData); - const parent = node._parent; + var count = length - offset; + var newData = CharacterDataAlgorithm_1.characterData_substringData(node, offset, count); + var newNode = CreateAlgorithm_1.create_text(node._nodeDocument, newData); + var parent = node._parent; if (parent !== null) { /** * 7.1. Insert new node into parent before node’s next sibling. */ MutationAlgorithm_1.mutation_insert(newNode, parent, node._nextSibling); - /** - * 7.2. For each live range whose start node is node and start offset is - * greater than offset, set its start node to new node and decrease its - * start offset by offset. - * 7.3. For each live range whose end node is node and end offset is greater - * than offset, set its end node to new node and decrease its end offset - * by offset. - * 7.4. For each live range whose start node is parent and start offset is - * equal to the index of node plus 1, increase its start offset by 1. - * 7.5. For each live range whose end node is parent and end offset is equal - * to the index of node plus 1, increase its end offset by 1. - */ - for (const range of dom_1.dom.rangeList) { - if (range._start[0] === node && range._start[1] > offset) { - range._start[0] = newNode; - range._start[1] -= offset; + try { + /** + * 7.2. For each live range whose start node is node and start offset is + * greater than offset, set its start node to new node and decrease its + * start offset by offset. + * 7.3. For each live range whose end node is node and end offset is greater + * than offset, set its end node to new node and decrease its end offset + * by offset. + * 7.4. For each live range whose start node is parent and start offset is + * equal to the index of node plus 1, increase its start offset by 1. + * 7.5. For each live range whose end node is parent and end offset is equal + * to the index of node plus 1, increase its end offset by 1. + */ + for (var _b = __values(DOMImpl_1.dom.rangeList), _c = _b.next(); !_c.done; _c = _b.next()) { + var range = _c.value; + if (range._start[0] === node && range._start[1] > offset) { + range._start[0] = newNode; + range._start[1] -= offset; + } + if (range._end[0] === node && range._end[1] > offset) { + range._end[0] = newNode; + range._end[1] -= offset; + } + var index = TreeAlgorithm_1.tree_index(node); + if (range._start[0] === parent && range._start[1] === index + 1) { + range._start[1]++; + } + if (range._end[0] === parent && range._end[1] === index + 1) { + range._end[1]++; + } } - if (range._end[0] === node && range._end[1] > offset) { - range._end[0] = newNode; - range._end[1] -= offset; - } - const index = TreeAlgorithm_1.tree_index(node); - if (range._start[0] === parent && range._start[1] === index + 1) { - range._start[1]++; - } - if (range._end[0] === parent && range._end[1] === index + 1) { - range._end[1]++; + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); } + finally { if (e_1) throw e_1.error; } } } /** @@ -8835,14 +10059,20 @@ exports.text_split = text_split; //# sourceMappingURL=TextAlgorithm.js.map /***/ }), - -/***/ 162: +/* 155 */, +/* 156 */, +/* 157 */, +/* 158 */, +/* 159 */, +/* 160 */, +/* 161 */, +/* 162 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const ElementAlgorithm_1 = __webpack_require__(33); +var ElementAlgorithm_1 = __webpack_require__(33); /** * Changes the value of an existing attribute. * @@ -8865,8 +10095,7 @@ exports.attr_setAnExistingAttributeValue = attr_setAnExistingAttributeValue; //# sourceMappingURL=AttrAlgorithm.js.map /***/ }), - -/***/ 163: +/* 163 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; @@ -8885,7 +10114,7 @@ __export(__webpack_require__(493)); __export(__webpack_require__(304)); __export(__webpack_require__(54)); __export(__webpack_require__(33)); -__export(__webpack_require__(108)); +__export(__webpack_require__(826)); __export(__webpack_require__(106)); __export(__webpack_require__(479)); __export(__webpack_require__(151)); @@ -8906,31 +10135,52 @@ __export(__webpack_require__(442)); //# sourceMappingURL=index.js.map /***/ }), - -/***/ 164: +/* 164 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const EventImpl_1 = __webpack_require__(427); -const algorithm_1 = __webpack_require__(163); +var EventImpl_1 = __webpack_require__(427); +var algorithm_1 = __webpack_require__(163); /** * Represents and event that carries custom data. */ -class CustomEventImpl extends EventImpl_1.EventImpl { +var CustomEventImpl = /** @class */ (function (_super) { + __extends(CustomEventImpl, _super); /** * Initializes a new instance of `CustomEvent`. */ - constructor(type, eventInit) { - super(type, eventInit); - this._detail = null; - this._detail = (eventInit && eventInit.detail) || null; + function CustomEventImpl(type, eventInit) { + var _this = _super.call(this, type, eventInit) || this; + _this._detail = null; + _this._detail = (eventInit && eventInit.detail) || null; + return _this; } + Object.defineProperty(CustomEventImpl.prototype, "detail", { + /** @inheritdoc */ + get: function () { return this._detail; }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get detail() { return this._detail; } - /** @inheritdoc */ - initCustomEvent(type, bubbles = false, cancelable = false, detail = null) { + CustomEventImpl.prototype.initCustomEvent = function (type, bubbles, cancelable, detail) { + if (bubbles === void 0) { bubbles = false; } + if (cancelable === void 0) { cancelable = false; } + if (detail === void 0) { detail = null; } /** * 1. If the context object’s dispatch flag is set, then return. */ @@ -8944,14 +10194,29 @@ class CustomEventImpl extends EventImpl_1.EventImpl { * 3. Set the context object’s detail attribute to detail. */ this._detail = detail; - } -} + }; + return CustomEventImpl; +}(EventImpl_1.EventImpl)); exports.CustomEventImpl = CustomEventImpl; //# sourceMappingURL=CustomEventImpl.js.map /***/ }), +/* 165 */, +/* 166 */, +/* 167 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 172: +const compare = __webpack_require__(874) +const gte = (a, b, loose) => compare(a, b, loose) >= 0 +module.exports = gte + + +/***/ }), +/* 168 */, +/* 169 */, +/* 170 */, +/* 171 */, +/* 172 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -8975,235 +10240,193 @@ var TokenType; //# sourceMappingURL=interfaces.js.map /***/ }), - -/***/ 174: +/* 173 */, +/* 174 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(42); +var DOMImpl_1 = __webpack_require__(648); +var infra_1 = __webpack_require__(23); +var algorithm_1 = __webpack_require__(163); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** - * Adds the given item to the end of the list. - * - * @param list - a list - * @param item - an item + * Represents an object providing methods which are not dependent on + * any particular document. */ -function append(list, item) { - list.push(item); -} -exports.append = append; -/** - * Extends a list by appending all items from another list. - * - * @param listA - a list to extend - * @param listB - a list containing items to append to `listA` - */ -function extend(listA, listB) { - listA.push(...listB); -} -exports.extend = extend; -/** - * Inserts the given item to the start of the list. - * - * @param list - a list - * @param item - an item - */ -function prepend(list, item) { - list.unshift(item); -} -exports.prepend = prepend; -/** - * Replaces the given item or all items matching condition with a new item. - * - * @param list - a list - * @param conditionOrItem - an item to replace or a condition matching items - * to replace - * @param item - an item - */ -function replace(list, conditionOrItem, newItem) { - let i = 0; - for (const oldItem of list) { - if (util_1.isFunction(conditionOrItem)) { - if (!!conditionOrItem.call(null, oldItem)) { - list[i] = newItem; - } - } - else if (oldItem === conditionOrItem) { - list[i] = newItem; - return; - } - i++; +var DOMImplementationImpl = /** @class */ (function () { + /** + * Initializes a new instance of `DOMImplementation`. + * + * @param document - the associated document + */ + function DOMImplementationImpl(document) { + this._associatedDocument = document || DOMImpl_1.dom.window.document; } -} -exports.replace = replace; -/** - * Inserts the given item before the given index. - * - * @param list - a list - * @param item - an item - */ -function insert(list, item, index) { - list.splice(index, 0, item); -} -exports.insert = insert; -/** - * Removes the given item or all items matching condition. - * - * @param list - a list - * @param conditionOrItem - an item to remove or a condition matching items - * to remove - */ -function remove(list, conditionOrItem) { - let i = list.length; - while (i--) { - const oldItem = list[i]; - if (util_1.isFunction(conditionOrItem)) { - if (!!conditionOrItem.call(null, oldItem)) { - list.splice(i, 1); - } + /** @inheritdoc */ + DOMImplementationImpl.prototype.createDocumentType = function (qualifiedName, publicId, systemId) { + /** + * 1. Validate qualifiedName. + * 2. Return a new doctype, with qualifiedName as its name, publicId as its + * public ID, and systemId as its system ID, and with its node document set + * to the associated document of the context object. + */ + algorithm_1.namespace_validate(qualifiedName); + return algorithm_1.create_documentType(this._associatedDocument, qualifiedName, publicId, systemId); + }; + /** @inheritdoc */ + DOMImplementationImpl.prototype.createDocument = function (namespace, qualifiedName, doctype) { + if (doctype === void 0) { doctype = null; } + /** + * 1. Let document be a new XMLDocument. + */ + var document = algorithm_1.create_xmlDocument(); + /** + * 2. Let element be null. + * 3. If qualifiedName is not the empty string, then set element to + * the result of running the internal createElementNS steps, given document, + * namespace, qualifiedName, and an empty dictionary. + */ + var element = null; + if (qualifiedName) { + element = algorithm_1.document_internalCreateElementNS(document, namespace, qualifiedName); } - else if (oldItem === conditionOrItem) { - list.splice(i, 1); - return; + /** + * 4. If doctype is non-null, append doctype to document. + * 5. If element is non-null, append element to document. + */ + if (doctype) + document.appendChild(doctype); + if (element) + document.appendChild(element); + /** + * 6. document’s origin is context object’s associated document’s origin. + */ + document._origin = this._associatedDocument._origin; + /** + * 7. document’s content type is determined by namespace: + * - HTML namespace + * application/xhtml+xml + * - SVG namespace + * image/svg+xml + * - Any other namespace + * application/xml + */ + if (namespace === infra_1.namespace.HTML) + document._contentType = "application/xhtml+xml"; + else if (namespace === infra_1.namespace.SVG) + document._contentType = "image/svg+xml"; + else + document._contentType = "application/xml"; + /** + * 8. Return document. + */ + return document; + }; + /** @inheritdoc */ + DOMImplementationImpl.prototype.createHTMLDocument = function (title) { + /** + * 1. Let doc be a new document that is an HTML document. + * 2. Set doc’s content type to "text/html". + */ + var doc = algorithm_1.create_document(); + doc._type = "html"; + doc._contentType = "text/html"; + /** + * 3. Append a new doctype, with "html" as its name and with its node + * document set to doc, to doc. + */ + doc.appendChild(algorithm_1.create_documentType(doc, "html", "", "")); + /** + * 4. Append the result of creating an element given doc, html, and the + * HTML namespace, to doc. + */ + var htmlElement = algorithm_1.element_createAnElement(doc, "html", infra_1.namespace.HTML); + doc.appendChild(htmlElement); + /** + * 5. Append the result of creating an element given doc, head, and the + * HTML namespace, to the html element created earlier. + */ + var headElement = algorithm_1.element_createAnElement(doc, "head", infra_1.namespace.HTML); + htmlElement.appendChild(headElement); + /** + * 6. If title is given: + * 6.1. Append the result of creating an element given doc, title, and + * the HTML namespace, to the head element created earlier. + * 6.2. Append a new Text node, with its data set to title (which could + * be the empty string) and its node document set to doc, to the title + * element created earlier. + */ + if (title !== undefined) { + var titleElement = algorithm_1.element_createAnElement(doc, "title", infra_1.namespace.HTML); + headElement.appendChild(titleElement); + var textElement = algorithm_1.create_text(doc, title); + titleElement.appendChild(textElement); } - } -} -exports.remove = remove; -/** - * Removes all items from the list. - */ -function empty(list) { - list.length = 0; -} -exports.empty = empty; -/** - * Determines if the list contains the given item or any items matching - * condition. - * - * @param list - a list - * @param conditionOrItem - an item to a condition to match - */ -function contains(list, conditionOrItem) { - for (const oldItem of list) { - if (util_1.isFunction(conditionOrItem)) { - if (!!conditionOrItem.call(null, oldItem)) { - return true; - } - } - else if (oldItem === conditionOrItem) { - return true; - } - } - return false; -} -exports.contains = contains; -/** - * Returns the count of items in the list matching the given condition. - * - * @param list - a list - * @param condition - an optional condition to match - */ -function size(list, condition) { - if (condition === undefined) { - return list.length; - } - else { - let count = 0; - for (const item of list) { - if (!!condition.call(null, item)) { - count++; - } - } - return count; - } -} -exports.size = size; -/** - * Determines if the list is empty. - * - * @param list - a list - */ -function isEmpty(list) { - return list.length === 0; -} -exports.isEmpty = isEmpty; -/** - * Returns an iterator for the items of the list. - * - * @param list - a list - * @param condition - an optional condition to match - */ -function* forEach(list, condition) { - if (condition === undefined) { - yield* list; - } - else { - for (const item of list) { - if (!!condition.call(null, item)) { - yield item; - } - } - } -} -exports.forEach = forEach; -/** - * Creates and returns a shallow clone of list. - * - * @param list - a list - */ -function clone(list) { - return new Array(...list); -} -exports.clone = clone; -/** - * Returns a new list containing items from the list sorted in ascending - * order. - * - * @param list - a list - * @param lessThanAlgo - a function that returns `true` if its first argument - * is less than its second argument, and `false` otherwise. - */ -function sortInAscendingOrder(list, lessThanAlgo) { - return list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1); -} -exports.sortInAscendingOrder = sortInAscendingOrder; -/** - * Returns a new list containing items from the list sorted in descending - * order. - * - * @param list - a list - * @param lessThanAlgo - a function that returns `true` if its first argument - * is less than its second argument, and `false` otherwise. - */ -function sortInDescendingOrder(list, lessThanAlgo) { - return list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1); -} -exports.sortInDescendingOrder = sortInDescendingOrder; -//# sourceMappingURL=List.js.map + /** + * 7. Append the result of creating an element given doc, body, and the + * HTML namespace, to the html element created earlier. + */ + var bodyElement = algorithm_1.element_createAnElement(doc, "body", infra_1.namespace.HTML); + htmlElement.appendChild(bodyElement); + /** + * 8. doc’s origin is context object’s associated document’s origin. + */ + doc._origin = this._associatedDocument._origin; + /** + * 9. Return doc. + */ + return doc; + }; + /** @inheritdoc */ + DOMImplementationImpl.prototype.hasFeature = function () { return true; }; + /** + * Creates a new `DOMImplementation`. + * + * @param document - owner document + */ + DOMImplementationImpl._create = function (document) { + return new DOMImplementationImpl(document); + }; + return DOMImplementationImpl; +}()); +exports.DOMImplementationImpl = DOMImplementationImpl; +WebIDLAlgorithm_1.idl_defineConst(DOMImplementationImpl.prototype, "_ID", "@oozcitak/dom"); +//# sourceMappingURL=DOMImplementationImpl.js.map /***/ }), - -/***/ 175: +/* 175 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const _1 = __webpack_require__(113); -const util_1 = __webpack_require__(918); -const infra_1 = __webpack_require__(23); +var DOMImpl_1 = __webpack_require__(648); +var util_1 = __webpack_require__(918); +var infra_1 = __webpack_require__(23); /** * Represents an object that can be used to observe mutations to the tree of * nodes. */ -class MutationObserverImpl { +var MutationObserverImpl = /** @class */ (function () { /** * Initializes a new instance of `MutationObserver`. * * @param callback - the callback function */ - constructor(callback) { + function MutationObserverImpl(callback) { this._nodeList = []; this._recordQueue = []; /** @@ -9212,11 +10435,12 @@ class MutationObserverImpl { * 3. Return mo. */ this._callback = callback; - const window = _1.dom.window; + var window = DOMImpl_1.dom.window; infra_1.set.append(window._mutationObservers, this); } /** @inheritdoc */ - observe(target, options) { + MutationObserverImpl.prototype.observe = function (target, options) { + var e_1, _a; options = options || { childList: false, subtree: false @@ -9259,24 +10483,51 @@ class MutationObserverImpl { * 7. For each registered of target’s registered observer list, if * registered’s observer is the context object: */ - let isRegistered = false; - const coptions = options; - for (const registered of target._registeredObserverList) { - if (registered.observer === this) { + var isRegistered = false; + var coptions = options; + var _loop_1 = function (registered) { + var e_2, _a; + if (registered.observer === this_1) { isRegistered = true; - /** - * 7.1. For each node of the context object’s node list, remove all - * transient registered observers whose source is registered from node’s - * registered observer list. - */ - for (const node of this._nodeList) { - infra_1.list.remove(node._registeredObserverList, (ob) => util_1.Guard.isTransientRegisteredObserver(ob) && ob.source === registered); + try { + /** + * 7.1. For each node of the context object’s node list, remove all + * transient registered observers whose source is registered from node’s + * registered observer list. + */ + for (var _b = (e_2 = void 0, __values(this_1._nodeList)), _c = _b.next(); !_c.done; _c = _b.next()) { + var node = _c.value; + infra_1.list.remove(node._registeredObserverList, function (ob) { + return util_1.Guard.isTransientRegisteredObserver(ob) && ob.source === registered; + }); + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_2) throw e_2.error; } } /** * 7.2. Set registered’s options to options. */ registered.options = coptions; } + }; + var this_1 = this; + try { + for (var _b = __values(target._registeredObserverList), _c = _b.next(); !_c.done; _c = _b.next()) { + var registered = _c.value; + _loop_1(registered); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } } /** * 8. Otherwise: @@ -9288,50 +10539,99 @@ class MutationObserverImpl { target._registeredObserverList.push({ observer: this, options: options }); this._nodeList.push(target); } - } + }; /** @inheritdoc */ - disconnect() { - /** - * 1. For each node of the context object’s node list, remove any - * registered observer from node’s registered observer list for which the - * context object is the observer. - */ - for (const node of this._nodeList) { - infra_1.list.remove((node)._registeredObserverList, (ob) => ob.observer === this); + MutationObserverImpl.prototype.disconnect = function () { + var e_3, _a; + var _this = this; + try { + /** + * 1. For each node of the context object’s node list, remove any + * registered observer from node’s registered observer list for which the + * context object is the observer. + */ + for (var _b = __values(this._nodeList), _c = _b.next(); !_c.done; _c = _b.next()) { + var node = _c.value; + infra_1.list.remove((node)._registeredObserverList, function (ob) { + return ob.observer === _this; + }); + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_3) throw e_3.error; } } /** * 2. Empty the context object’s record queue. */ this._recordQueue = []; - } + }; /** @inheritdoc */ - takeRecords() { + MutationObserverImpl.prototype.takeRecords = function () { /** * 1. Let records be a clone of the context object’s record queue. * 2. Empty the context object’s record queue. * 3. Return records. */ - const records = this._recordQueue; + var records = this._recordQueue; this._recordQueue = []; return records; - } -} + }; + return MutationObserverImpl; +}()); exports.MutationObserverImpl = MutationObserverImpl; //# sourceMappingURL=MutationObserverImpl.js.map /***/ }), - -/***/ 180: +/* 176 */, +/* 177 */, +/* 178 */, +/* 179 */, +/* 180 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const util_1 = __webpack_require__(918); -const util_2 = __webpack_require__(337); -const TreeAlgorithm_1 = __webpack_require__(873); -const MutationObserverAlgorithm_1 = __webpack_require__(151); +var DOMImpl_1 = __webpack_require__(648); +var util_1 = __webpack_require__(918); +var util_2 = __webpack_require__(592); +var TreeAlgorithm_1 = __webpack_require__(873); +var MutationObserverAlgorithm_1 = __webpack_require__(151); /** * Signals a slot change to the given slot. * @@ -9342,7 +10642,7 @@ function shadowTree_signalASlotChange(slot) { * 1. Append slot to slot’s relevant agent’s signal slots. * 2. Queue a mutation observer microtask. */ - const window = dom_1.dom.window; + var window = DOMImpl_1.dom.window; window._signalSlots.add(slot); MutationObserverAlgorithm_1.observer_queueAMutationObserverMicrotask(); } @@ -9378,7 +10678,8 @@ exports.shadowTree_isAssigned = shadowTree_isAssigned; * @param slotable - a slotable * @param openFlag - `true` to search open shadow tree's only */ -function shadowTree_findASlot(slotable, openFlag = false) { +function shadowTree_findASlot(slotable, openFlag) { + if (openFlag === void 0) { openFlag = false; } /** * 1. If slotable’s parent is null, then return null. * 2. Let shadow be slotable’s parent’s shadow root. @@ -9388,20 +10689,20 @@ function shadowTree_findASlot(slotable, openFlag = false) { * 5. Return the first slot in tree order in shadow’s descendants whose name * is slotable’s name, if any, and null otherwise. */ - const node = util_1.Cast.asNode(slotable); - const parent = node._parent; + var node = util_1.Cast.asNode(slotable); + var parent = node._parent; if (parent === null) return null; - const shadow = parent._shadowRoot || null; + var shadow = parent._shadowRoot || null; if (shadow === null) return null; if (openFlag && shadow._mode !== "open") return null; - let child = TreeAlgorithm_1.tree_getFirstDescendantNode(shadow, false, true, (e) => util_1.Guard.isSlot(e)); + var child = TreeAlgorithm_1.tree_getFirstDescendantNode(shadow, false, true, function (e) { return util_1.Guard.isSlot(e); }); while (child !== null) { if (child._name === slotable._name) return child; - child = TreeAlgorithm_1.tree_getNextDescendantNode(shadow, child, false, true, (e) => util_1.Guard.isSlot(e)); + child = TreeAlgorithm_1.tree_getNextDescendantNode(shadow, child, false, true, function (e) { return util_1.Guard.isSlot(e); }); } return null; } @@ -9412,31 +10713,42 @@ exports.shadowTree_findASlot = shadowTree_findASlot; * @param slot - a slot */ function shadowTree_findSlotables(slot) { + var e_1, _a; /** * 1. Let result be an empty list. * 2. If slot’s root is not a shadow root, then return result. */ - const result = []; - const root = TreeAlgorithm_1.tree_rootNode(slot); + var result = []; + var root = TreeAlgorithm_1.tree_rootNode(slot); if (!util_1.Guard.isShadowRoot(root)) return result; /** * 3. Let host be slot’s root’s host. * 4. For each slotable child of host, slotable, in tree order: */ - const host = root._host; - for (const slotable of host._children) { - if (util_1.Guard.isSlotable(slotable)) { - /** - * 4.1. Let foundSlot be the result of finding a slot given slotable. - * 4.2. If foundSlot is slot, then append slotable to result. - */ - const foundSlot = shadowTree_findASlot(slotable); - if (foundSlot === slot) { - result.push(slotable); + var host = root._host; + try { + for (var _b = __values(host._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var slotable = _c.value; + if (util_1.Guard.isSlotable(slotable)) { + /** + * 4.1. Let foundSlot be the result of finding a slot given slotable. + * 4.2. If foundSlot is slot, then append slotable to result. + */ + var foundSlot = shadowTree_findASlot(slotable); + if (foundSlot === slot) { + result.push(slotable); + } } } } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } /** * 5. Return result. */ @@ -9449,12 +10761,13 @@ exports.shadowTree_findSlotables = shadowTree_findSlotables; * @param slot - a slot */ function shadowTree_findFlattenedSlotables(slot) { + var e_2, _a, e_3, _b; /** * 1. Let result be an empty list. * 2. If slot’s root is not a shadow root, then return result. */ - const result = []; - const root = TreeAlgorithm_1.tree_rootNode(slot); + var result = []; + var root = TreeAlgorithm_1.tree_rootNode(slot); if (!util_1.Guard.isShadowRoot(root)) return result; /** @@ -9462,35 +10775,55 @@ function shadowTree_findFlattenedSlotables(slot) { * 4. If slotables is the empty list, then append each slotable child of * slot, in tree order, to slotables. */ - const slotables = shadowTree_findSlotables(slot); + var slotables = shadowTree_findSlotables(slot); if (util_2.isEmpty(slotables)) { - for (const slotable of slot._children) { - if (util_1.Guard.isSlotable(slotable)) { - slotables.push(slotable); + try { + for (var _c = __values(slot._children), _d = _c.next(); !_d.done; _d = _c.next()) { + var slotable = _d.value; + if (util_1.Guard.isSlotable(slotable)) { + slotables.push(slotable); + } + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_d && !_d.done && (_a = _c.return)) _a.call(_c); + } + finally { if (e_2) throw e_2.error; } + } + } + try { + /** + * 5. For each node in slotables: + */ + for (var slotables_1 = __values(slotables), slotables_1_1 = slotables_1.next(); !slotables_1_1.done; slotables_1_1 = slotables_1.next()) { + var node = slotables_1_1.value; + /** + * 5.1. If node is a slot whose root is a shadow root, then: + */ + if (util_1.Guard.isSlot(node) && util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(node))) { + /** + * 5.1.1. Let temporaryResult be the result of finding flattened slotables given node. + * 5.1.2. Append each slotable in temporaryResult, in order, to result. + */ + var temporaryResult = shadowTree_findFlattenedSlotables(node); + result.push.apply(result, __spread(temporaryResult)); + } + else { + /** + * 5.2. Otherwise, append node to result. + */ + result.push(node); } } } - /** - * 5. For each node in slotables: - */ - for (const node of slotables) { - /** - * 5.1. If node is a slot whose root is a shadow root, then: - */ - if (util_1.Guard.isSlot(node) && util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(node))) { - /** - * 5.1.1. Let temporaryResult be the result of finding flattened slotables given node. - * 5.1.2. Append each slotable in temporaryResult, in order, to result. - */ - const temporaryResult = shadowTree_findFlattenedSlotables(node); - result.push(...temporaryResult); - } - else { - /** - * 5.2. Otherwise, append node to result. - */ - result.push(node); + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (slotables_1_1 && !slotables_1_1.done && (_b = slotables_1.return)) _b.call(slotables_1); } + finally { if (e_3) throw e_3.error; } } /** * 6. Return result. @@ -9504,15 +10837,16 @@ exports.shadowTree_findFlattenedSlotables = shadowTree_findFlattenedSlotables; * @param slot - a slot */ function shadowTree_assignSlotables(slot) { + var e_4, _a; /** * 1. Let slotables be the result of finding slotables for slot. * 2. If slotables and slot’s assigned nodes are not identical, then run * signal a slot change for slot. */ - const slotables = shadowTree_findSlotables(slot); + var slotables = shadowTree_findSlotables(slot); if (slotables.length === slot._assignedNodes.length) { - let nodesIdentical = true; - for (let i = 0; i < slotables.length; i++) { + var nodesIdentical = true; + for (var i = 0; i < slotables.length; i++) { if (slotables[i] !== slot._assignedNodes[i]) { nodesIdentical = false; break; @@ -9527,8 +10861,18 @@ function shadowTree_assignSlotables(slot) { * 4. For each slotable in slotables, set slotable’s assigned slot to slot. */ slot._assignedNodes = slotables; - for (const slotable of slotables) { - slotable._assignedSlot = slot; + try { + for (var slotables_2 = __values(slotables), slotables_2_1 = slotables_2.next(); !slotables_2_1.done; slotables_2_1 = slotables_2.next()) { + var slotable = slotables_2_1.value; + slotable._assignedSlot = slot; + } + } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (slotables_2_1 && !slotables_2_1.done && (_a = slotables_2.return)) _a.call(slotables_2); + } + finally { if (e_4) throw e_4.error; } } } exports.shadowTree_assignSlotables = shadowTree_assignSlotables; @@ -9542,10 +10886,10 @@ function shadowTree_assignSlotablesForATree(root) { * To assign slotables for a tree, given a node root, run assign slotables * for each slot slot in root’s inclusive descendants, in tree order. */ - let descendant = TreeAlgorithm_1.tree_getFirstDescendantNode(root, true, false, (e) => util_1.Guard.isSlot(e)); + var descendant = TreeAlgorithm_1.tree_getFirstDescendantNode(root, true, false, function (e) { return util_1.Guard.isSlot(e); }); while (descendant !== null) { shadowTree_assignSlotables(descendant); - descendant = TreeAlgorithm_1.tree_getNextDescendantNode(root, descendant, true, false, (e) => util_1.Guard.isSlot(e)); + descendant = TreeAlgorithm_1.tree_getNextDescendantNode(root, descendant, true, false, function (e) { return util_1.Guard.isSlot(e); }); } } exports.shadowTree_assignSlotablesForATree = shadowTree_assignSlotablesForATree; @@ -9559,7 +10903,7 @@ function shadowTree_assignASlot(slotable) { * 1. Let slot be the result of finding a slot with slotable. * 2. If slot is non-null, then run assign slotables for slot. */ - const slot = shadowTree_findASlot(slotable); + var slot = shadowTree_findASlot(slotable); if (slot !== null) { shadowTree_assignSlotables(slot); } @@ -9568,59 +10912,79 @@ exports.shadowTree_assignASlot = shadowTree_assignASlot; //# sourceMappingURL=ShadowTreeAlgorithm.js.map /***/ }), +/* 181 */ +/***/ (function(module) { -/***/ 183: -/***/ (function(__unusedmodule, exports) { +// Note: this is the semver.org version of the spec that it implements +// Not necessarily the package version of this code. +const SEMVER_SPEC_VERSION = '2.0.0' -"use strict"; +const MAX_LENGTH = 256 +const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || + /* istanbul ignore next */ 9007199254740991 -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Pushes the given item to the stack. - * - * @param list - a list - * @param item - an item - */ -function push(list, item) { - list.push(item); +// Max safe segment length for coercion. +const MAX_SAFE_COMPONENT_LENGTH = 16 + +module.exports = { + SEMVER_SPEC_VERSION, + MAX_LENGTH, + MAX_SAFE_INTEGER, + MAX_SAFE_COMPONENT_LENGTH } -exports.push = push; -/** - * Pops and returns an item from the stack. - * - * @param list - a list - */ -function pop(list) { - return list.pop() || null; -} -exports.pop = pop; -//# sourceMappingURL=Stack.js.map + /***/ }), - -/***/ 190: +/* 182 */, +/* 183 */, +/* 184 */, +/* 185 */, +/* 186 */, +/* 187 */, +/* 188 */, +/* 189 */, +/* 190 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const BaseCBWriter_1 = __webpack_require__(512); +var BaseCBWriter_1 = __webpack_require__(512); /** * Serializes XML nodes. */ -class XMLCBWriter extends BaseCBWriter_1.BaseCBWriter { +var XMLCBWriter = /** @class */ (function (_super) { + __extends(XMLCBWriter, _super); /** - * Initializes a new instance of `BaseCBWriter`. + * Initializes a new instance of `XMLCBWriter`. * * @param builderOptions - XML builder options */ - constructor(builderOptions) { - super(builderOptions); - this._lineLength = 0; + function XMLCBWriter(builderOptions) { + var _this = _super.call(this, builderOptions) || this; + _this._lineLength = 0; + return _this; } /** @inheritdoc */ - declaration(version, encoding, standalone) { - let markup = this._beginLine() + ""; return markup; - } + }; /** @inheritdoc */ - docType(name, publicId, systemId) { - let markup = this._beginLine(); + XMLCBWriter.prototype.docType = function (name, publicId, systemId) { + var markup = this._beginLine(); if (publicId && systemId) { markup += ""; } @@ -9647,35 +11011,35 @@ class XMLCBWriter extends BaseCBWriter_1.BaseCBWriter { markup += ""; } return markup; - } + }; /** @inheritdoc */ - comment(data) { + XMLCBWriter.prototype.comment = function (data) { return this._beginLine() + ""; - } + }; /** @inheritdoc */ - text(data) { + XMLCBWriter.prototype.text = function (data) { return this._beginLine() + data; - } + }; /** @inheritdoc */ - instruction(target, data) { + XMLCBWriter.prototype.instruction = function (target, data) { if (data) { return this._beginLine() + ""; } else { return this._beginLine() + ""; } - } + }; /** @inheritdoc */ - cdata(data) { + XMLCBWriter.prototype.cdata = function (data) { return this._beginLine() + ""; - } + }; /** @inheritdoc */ - openTagBegin(name) { + XMLCBWriter.prototype.openTagBegin = function (name) { this._lineLength += 1 + name.length; return this._beginLine() + "<" + name; - } + }; /** @inheritdoc */ - openTagEnd(name, selfClosing, voidElement) { + XMLCBWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) { if (voidElement) { return " />"; } @@ -9693,14 +11057,14 @@ class XMLCBWriter extends BaseCBWriter_1.BaseCBWriter { else { return ">"; } - } + }; /** @inheritdoc */ - closeTag(name) { + XMLCBWriter.prototype.closeTag = function (name) { return this._beginLine() + ""; - } + }; /** @inheritdoc */ - attribute(name, value) { - let str = name + "=\"" + value + "\""; + XMLCBWriter.prototype.attribute = function (name, value) { + var str = name + "=\"" + value + "\""; if (this._writerOptions.prettyPrint && this._writerOptions.width > 0 && this._lineLength + 1 + str.length > this._writerOptions.width) { str = this._beginLine() + this._indent(1) + str; @@ -9711,18 +11075,18 @@ class XMLCBWriter extends BaseCBWriter_1.BaseCBWriter { this._lineLength += 1 + str.length; return " " + str; } - } + }; /** @inheritdoc */ - beginElement(name) { } + XMLCBWriter.prototype.beginElement = function (name) { }; /** @inheritdoc */ - endElement(name) { } + XMLCBWriter.prototype.endElement = function (name) { }; /** * Produces characters to be prepended to a line of string in pretty-print * mode. */ - _beginLine() { + XMLCBWriter.prototype._beginLine = function () { if (this._writerOptions.prettyPrint) { - const str = (this.hasData ? this._writerOptions.newline : "") + + var str = (this.hasData ? this._writerOptions.newline : "") + this._indent(this._writerOptions.offset + this.level); this._lineLength = str.length; return str; @@ -9730,86 +11094,106 @@ class XMLCBWriter extends BaseCBWriter_1.BaseCBWriter { else { return ""; } - } + }; /** * Produces an indentation string. * * @param level - depth of the tree */ - _indent(level) { + XMLCBWriter.prototype._indent = function (level) { if (level <= 0) { return ""; } else { return this._writerOptions.indent.repeat(level); } - } -} + }; + return XMLCBWriter; +}(BaseCBWriter_1.BaseCBWriter)); exports.XMLCBWriter = XMLCBWriter; //# sourceMappingURL=XMLCBWriter.js.map /***/ }), - -/***/ 204: +/* 191 */, +/* 192 */, +/* 193 */, +/* 194 */, +/* 195 */, +/* 196 */, +/* 197 */, +/* 198 */, +/* 199 */, +/* 200 */, +/* 201 */, +/* 202 */, +/* 203 */, +/* 204 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const infra_1 = __webpack_require__(23); -const algorithm_1 = __webpack_require__(163); -const util_1 = __webpack_require__(918); -const util_2 = __webpack_require__(337); +var infra_1 = __webpack_require__(23); +var algorithm_1 = __webpack_require__(163); +var util_1 = __webpack_require__(918); +var util_2 = __webpack_require__(592); /** * Represents a collection of elements. */ -class HTMLCollectionImpl { +var HTMLCollectionImpl = /** @class */ (function () { /** * Initializes a new instance of `HTMLCollection`. * * @param root - root node * @param filter - node filter */ - constructor(root, filter) { + function HTMLCollectionImpl(root, filter) { this._live = true; this._root = root; this._filter = filter; return new Proxy(this, this); } + Object.defineProperty(HTMLCollectionImpl.prototype, "length", { + /** @inheritdoc */ + get: function () { + var _this = this; + /** + * The length attribute’s getter must return the number of nodes + * represented by the collection. + */ + var count = 0; + var node = algorithm_1.tree_getFirstDescendantNode(this._root, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); }); + while (node !== null) { + count++; + node = algorithm_1.tree_getNextDescendantNode(this._root, node, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); }); + } + return count; + }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get length() { - /** - * The length attribute’s getter must return the number of nodes - * represented by the collection. - */ - let count = 0; - let node = algorithm_1.tree_getFirstDescendantNode(this._root, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e)); - while (node !== null) { - count++; - node = algorithm_1.tree_getNextDescendantNode(this._root, node, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e)); - } - return count; - } - /** @inheritdoc */ - item(index) { + HTMLCollectionImpl.prototype.item = function (index) { + var _this = this; /** * The item(index) method, when invoked, must return the indexth element * in the collection. If there is no indexth element in the collection, * then the method must return null. */ - let i = 0; - let node = algorithm_1.tree_getFirstDescendantNode(this._root, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e)); + var i = 0; + var node = algorithm_1.tree_getFirstDescendantNode(this._root, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); }); while (node !== null) { if (i === index) return node; else i++; - node = algorithm_1.tree_getNextDescendantNode(this._root, node, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e)); + node = algorithm_1.tree_getNextDescendantNode(this._root, node, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); }); } return null; - } + }; /** @inheritdoc */ - namedItem(key) { + HTMLCollectionImpl.prototype.namedItem = function (key) { + var _this = this; /** * 1. If key is the empty string, return null. * 2. Return the first element in the collection for which at least one of @@ -9820,65 +11204,65 @@ class HTMLCollectionImpl { */ if (key === '') return null; - let ele = algorithm_1.tree_getFirstDescendantNode(this._root, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e)); + var ele = algorithm_1.tree_getFirstDescendantNode(this._root, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); }); while (ele != null) { if (ele._uniqueIdentifier === key) { return ele; } else if (ele._namespace === infra_1.namespace.HTML) { - for (let i = 0; i < ele._attributeList.length; i++) { - const attr = ele._attributeList[i]; + for (var i = 0; i < ele._attributeList.length; i++) { + var attr = ele._attributeList[i]; if (attr._localName === "name" && attr._namespace === null && attr._namespacePrefix === null && attr._value === key) return ele; } } - ele = algorithm_1.tree_getNextDescendantNode(this._root, ele, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e)); + ele = algorithm_1.tree_getNextDescendantNode(this._root, ele, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); }); } return null; - } + }; /** @inheritdoc */ - [Symbol.iterator]() { - const root = this._root; - const filter = this._filter; - let currentNode = algorithm_1.tree_getFirstDescendantNode(root, false, false, (e) => util_1.Guard.isElementNode(e) && filter(e)); + HTMLCollectionImpl.prototype[Symbol.iterator] = function () { + var root = this._root; + var filter = this._filter; + var currentNode = algorithm_1.tree_getFirstDescendantNode(root, false, false, function (e) { return util_1.Guard.isElementNode(e) && filter(e); }); return { - next() { + next: function () { if (currentNode === null) { return { done: true, value: null }; } else { - const result = { done: false, value: currentNode }; - currentNode = algorithm_1.tree_getNextDescendantNode(root, currentNode, false, false, (e) => util_1.Guard.isElementNode(e) && filter(e)); + var result = { done: false, value: currentNode }; + currentNode = algorithm_1.tree_getNextDescendantNode(root, currentNode, false, false, function (e) { return util_1.Guard.isElementNode(e) && filter(e); }); return result; } } }; - } + }; /** * Implements a proxy get trap to provide array-like access. */ - get(target, key, receiver) { + HTMLCollectionImpl.prototype.get = function (target, key, receiver) { if (!util_2.isString(key) || HTMLCollectionImpl.reservedNames.indexOf(key) !== -1) { return Reflect.get(target, key, receiver); } - const index = Number(key); + var index = Number(key); if (isNaN(index)) { return target.namedItem(key) || undefined; } else { return target.item(index) || undefined; } - } + }; /** * Implements a proxy set trap to provide array-like access. */ - set(target, key, value, receiver) { + HTMLCollectionImpl.prototype.set = function (target, key, value, receiver) { if (!util_2.isString(key) || HTMLCollectionImpl.reservedNames.indexOf(key) !== -1) { return Reflect.set(target, key, value, receiver); } - const index = Number(key); - const node = isNaN(index) ? + var index = Number(key); + var node = isNaN(index) ? target.namedItem(key) || undefined : target.item(index) || undefined; if (node && node._parent) { algorithm_1.mutation_replace(node, value, node._parent); @@ -9887,32 +11271,57 @@ class HTMLCollectionImpl { else { return false; } - } + }; /** * Creates a new `HTMLCollection`. * * @param root - root node * @param filter - node filter */ - static _create(root, filter = (() => true)) { + HTMLCollectionImpl._create = function (root, filter) { + if (filter === void 0) { filter = (function () { return true; }); } return new HTMLCollectionImpl(root, filter); - } -} + }; + HTMLCollectionImpl.reservedNames = ['_root', '_live', '_filter', 'length', + 'item', 'namedItem', 'get', 'set']; + return HTMLCollectionImpl; +}()); exports.HTMLCollectionImpl = HTMLCollectionImpl; -HTMLCollectionImpl.reservedNames = ['_root', '_live', '_filter', 'length', - 'item', 'namedItem', 'get', 'set']; //# sourceMappingURL=HTMLCollectionImpl.js.map /***/ }), +/* 205 */, +/* 206 */, +/* 207 */, +/* 208 */, +/* 209 */, +/* 210 */, +/* 211 */ +/***/ (function(__unusedmodule, exports) { -/***/ 211: -/***/ (function(module) { +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +exports.STATE_GPG_PRIVATE_KEY_FINGERPRINT = exports.INPUT_DEFAULT_GPG_PASSPHRASE = exports.INPUT_DEFAULT_GPG_PRIVATE_KEY = exports.INPUT_GPG_PASSPHRASE = exports.INPUT_GPG_PRIVATE_KEY = exports.INPUT_SETTINGS_PATH = exports.INPUT_SERVER_PASSWORD = exports.INPUT_SERVER_USERNAME = exports.INPUT_SERVER_ID = exports.INPUT_JDK_FILE = exports.INPUT_DISTRIBUTION = exports.INPUT_JAVA_PACKAGE = exports.INPUT_ARCHITECTURE = exports.INPUT_JAVA_VERSION = exports.MACOS_JAVA_CONTENT_POSTFIX = void 0; +exports.MACOS_JAVA_CONTENT_POSTFIX = 'Contents/Home'; +exports.INPUT_JAVA_VERSION = 'java-version'; +exports.INPUT_ARCHITECTURE = 'architecture'; +exports.INPUT_JAVA_PACKAGE = 'java-package'; +exports.INPUT_DISTRIBUTION = 'distribution'; +exports.INPUT_JDK_FILE = 'jdkFile'; +exports.INPUT_SERVER_ID = 'server-id'; +exports.INPUT_SERVER_USERNAME = 'server-username'; +exports.INPUT_SERVER_PASSWORD = 'server-password'; +exports.INPUT_SETTINGS_PATH = 'settings-path'; +exports.INPUT_GPG_PRIVATE_KEY = 'gpg-private-key'; +exports.INPUT_GPG_PASSPHRASE = 'gpg-passphrase'; +exports.INPUT_DEFAULT_GPG_PRIVATE_KEY = undefined; +exports.INPUT_DEFAULT_GPG_PASSPHRASE = 'GPG_PASSPHRASE'; +exports.STATE_GPG_PRIVATE_KEY_FINGERPRINT = 'gpg-private-key-fingerprint'; -module.exports = require("https"); /***/ }), - -/***/ 212: +/* 212 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; @@ -9924,8 +11333,95 @@ exports.DOMParser = DOMParserImpl_1.DOMParserImpl; //# sourceMappingURL=index.js.map /***/ }), +/* 213 */, +/* 214 */, +/* 215 */, +/* 216 */, +/* 217 */, +/* 218 */, +/* 219 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 247: +const Range = __webpack_require__(124) + +// Mostly just for testing and legacy API reasons +const toComparators = (range, options) => + new Range(range, options).set + .map(comp => comp.map(c => c.value).join(' ').trim().split(' ')) + +module.exports = toComparators + + +/***/ }), +/* 220 */, +/* 221 */, +/* 222 */, +/* 223 */, +/* 224 */, +/* 225 */, +/* 226 */, +/* 227 */, +/* 228 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +function resolveYamlBoolean(data) { + if (data === null) return false; + + var max = data.length; + + return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) || + (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE')); +} + +function constructYamlBoolean(data) { + return data === 'true' || + data === 'True' || + data === 'TRUE'; +} + +function isBoolean(object) { + return Object.prototype.toString.call(object) === '[object Boolean]'; +} + +module.exports = new Type('tag:yaml.org,2002:bool', { + kind: 'scalar', + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: function (object) { return object ? 'true' : 'false'; }, + uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; }, + camelcase: function (object) { return object ? 'True' : 'False'; } + }, + defaultStyle: 'lowercase' +}); + + +/***/ }), +/* 229 */, +/* 230 */, +/* 231 */, +/* 232 */, +/* 233 */, +/* 234 */, +/* 235 */, +/* 236 */, +/* 237 */, +/* 238 */, +/* 239 */, +/* 240 */, +/* 241 */, +/* 242 */, +/* 243 */, +/* 244 */, +/* 245 */, +/* 246 */, +/* 247 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -9939,20 +11435,26 @@ Object.defineProperty(exports, "__esModule", { value: true }); * _Note:_ The DocumentOrShadowRoot mixin is expected to be used by other * standards that want to define APIs shared between documents and shadow roots. */ -class DocumentOrShadowRootImpl { -} +var DocumentOrShadowRootImpl = /** @class */ (function () { + function DocumentOrShadowRootImpl() { + } + return DocumentOrShadowRootImpl; +}()); exports.DocumentOrShadowRootImpl = DocumentOrShadowRootImpl; //# sourceMappingURL=DocumentOrShadowRootImpl.js.map /***/ }), - -/***/ 252: +/* 248 */, +/* 249 */, +/* 250 */, +/* 251 */, +/* 252 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); +var dom_1 = __webpack_require__(113); dom_1.dom.setFeatures(true); var dom_2 = __webpack_require__(113); exports.DOMImplementation = dom_2.DOMImplementation; @@ -9963,305 +11465,68 @@ exports.XMLSerializer = serializer_1.XMLSerializer; //# sourceMappingURL=index.js.map /***/ }), - -/***/ 255: +/* 253 */, +/* 254 */, +/* 255 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(625); -const util_1 = __webpack_require__(592); -const util_2 = __webpack_require__(918); -const builder_1 = __webpack_require__(535); -const dom_1 = __webpack_require__(743); -const util_3 = __webpack_require__(669); -const builder_2 = __webpack_require__(535); -/** @inheritdoc */ -function builder(p1, p2) { - const options = formatBuilderOptions(isXMLBuilderCreateOptions(p1) ? p1 : interfaces_1.DefaultBuilderOptions); - const nodes = util_2.Guard.isNode(p1) || util_3.isArray(p1) ? p1 : p2; - if (nodes === undefined) { - throw new Error("Invalid arguments."); - } - if (util_3.isArray(nodes)) { - const builders = []; - for (let i = 0; i < nodes.length; i++) { - const builder = new builder_1.XMLBuilderImpl(nodes[i]); - builder.set(options); - builders.push(builder); - } - return builders; - } - else { - const builder = new builder_1.XMLBuilderImpl(nodes); - builder.set(options); - return builder; - } -} -exports.builder = builder; -/** @inheritdoc */ -function create(p1, p2) { - const options = formatBuilderOptions(p1 === undefined || isXMLBuilderCreateOptions(p1) ? - p1 : interfaces_1.DefaultBuilderOptions); - const contents = isXMLBuilderCreateOptions(p1) ? p2 : p1; - let builder; - if (contents === undefined) { - // empty document - const doc = dom_1.createDocument(); - builder = new builder_1.XMLBuilderImpl(doc); - setOptions(doc, options); - } - else if (util_1.isObject(contents)) { - // JS object - const doc = dom_1.createDocument(); - builder = new builder_1.XMLBuilderImpl(doc); - setOptions(doc, options); - builder.ele(contents); - } - else if (/^\s*" + - dom_1.sanitizeInput(contents, options.invalidCharReplacement) + "", "text/xml"); - dom_1.throwIfParserError(doc); - setOptions(doc, options, true); - /* istanbul ignore next */ - if (doc.documentElement === null) { - throw new Error("Document element is null."); - } - const frag = doc.createDocumentFragment(); - for (const child of doc.documentElement.childNodes) { - const newChild = doc.importNode(child, true); - frag.appendChild(newChild); - } - builder = new builder_1.XMLBuilderImpl(frag); - } - else { - // JSON - const doc = dom_1.createDocument(); - setOptions(doc, options, true); - builder = new builder_1.XMLBuilderImpl(doc.createDocumentFragment()); - const obj = JSON.parse(contents); - builder.ele(obj); - } - return builder; -} -exports.fragment = fragment; -/** @inheritdoc */ -function convert(p1, p2, p3) { - let builderOptions; - let contents; - let convertOptions; - if (isXMLBuilderCreateOptions(p1) && p2 !== undefined) { - builderOptions = p1; - contents = p2; - convertOptions = p3; - } - else { - builderOptions = interfaces_1.DefaultBuilderOptions; - contents = p1; - convertOptions = p2 || undefined; - } - return create(builderOptions, contents).end(convertOptions); -} -exports.convert = convert; -/** - * Creates an XML builder which serializes the document in chunks. - * - * @param options - callback builder options - * - * @returns callback builder - */ -function createCB(options) { - return new builder_2.XMLBuilderCBImpl(options); -} -exports.createCB = createCB; -/** - * Creates an XML builder which serializes the fragment in chunks. - * - * @param options - callback builder options - * - * @returns callback builder - */ -function fragmentCB(options) { - return new builder_2.XMLBuilderCBImpl(options, true); -} -exports.fragmentCB = fragmentCB; -function isXMLBuilderCreateOptions(obj) { - if (!util_1.isPlainObject(obj)) - return false; - for (const key in obj) { - /* istanbul ignore else */ - if (obj.hasOwnProperty(key)) { - if (!interfaces_1.XMLBuilderOptionKeys.has(key)) - return false; - } - } - return true; -} -function formatBuilderOptions(createOptions = {}) { - const options = util_1.applyDefaults(createOptions, interfaces_1.DefaultBuilderOptions); - if (options.convert.att.length === 0 || - options.convert.ins.length === 0 || - options.convert.text.length === 0 || - options.convert.cdata.length === 0 || - options.convert.comment.length === 0) { - throw new Error("JS object converter strings cannot be zero length."); - } - return options; -} -function setOptions(doc, options, isFragment) { - const docWithSettings = doc; - docWithSettings._xmlBuilderOptions = options; - docWithSettings._isFragment = isFragment; -} +var builder_1 = __webpack_require__(535); +exports.builder = builder_1.builder; +exports.create = builder_1.create; +exports.fragment = builder_1.fragment; +exports.convert = builder_1.convert; +exports.createCB = builder_1.createCB; +exports.fragmentCB = builder_1.fragmentCB; //# sourceMappingURL=index.js.map /***/ }), +/* 256 */, +/* 257 */, +/* 258 */, +/* 259 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 260: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Walks through the code points of a string. - */ -class StringWalker { - /** - * Initializes a new `StringWalker`. - * - * @param input - input string - */ - constructor(input) { - this._pointer = 0; - this._chars = Array.from(input); - this._length = this._chars.length; - } - /** - * Determines if the current position is beyond the end of string. - */ - get eof() { return this._pointer >= this._length; } - /** - * Returns the number of code points in the input string. - */ - get length() { return this._length; } - /** - * Returns the current code point. Returns `-1` if the position is beyond - * the end of string. - */ - codePoint() { - if (this._codePoint === undefined) { - if (this.eof) { - this._codePoint = -1; - } - else { - const cp = this._chars[this._pointer].codePointAt(0); - /* istanbul ignore else */ - if (cp !== undefined) { - this._codePoint = cp; - } - else { - this._codePoint = -1; - } - } - } - return this._codePoint; - } - /** - * Returns the current character. Returns an empty string if the position is - * beyond the end of string. - */ - c() { - if (this._c === undefined) { - this._c = (this.eof ? "" : this._chars[this._pointer]); - } - return this._c; - } - /** - * Returns the remaining string. - */ - remaining() { - if (this._remaining === undefined) { - this._remaining = (this.eof ? - "" : this._chars.slice(this._pointer + 1).join('')); - } - return this._remaining; - } - /** - * Returns the substring from the current character to the end of string. - */ - substring() { - if (this._substring === undefined) { - this._substring = (this.eof ? - "" : this._chars.slice(this._pointer).join('')); - } - return this._substring; - } - /** - * Gets or sets the current position. - */ - get pointer() { return this._pointer; } - set pointer(val) { - if (val === this._pointer) - return; - this._pointer = val; - this._codePoint = undefined; - this._c = undefined; - this._remaining = undefined; - this._substring = undefined; - } +const Range = __webpack_require__(124) +const intersects = (r1, r2, options) => { + r1 = new Range(r1, options) + r2 = new Range(r2, options) + return r1.intersects(r2) } -exports.StringWalker = StringWalker; -//# sourceMappingURL=StringWalker.js.map +module.exports = intersects + /***/ }), - -/***/ 263: +/* 260 */, +/* 261 */, +/* 262 */, +/* 263 */ /***/ (function(__unusedmodule, exports) { "use strict"; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; Object.defineProperty(exports, "__esModule", { value: true }); /** * Returns the count of bytes in a sequence. @@ -10285,8 +11550,8 @@ function byteLowercase(list) { * To byte-lowercase a byte sequence, increase each byte it contains, in the * range 0x41 (A) to 0x5A (Z), inclusive, by 0x20. */ - for (let i = 0; i < list.length; i++) { - const c = list[i]; + for (var i = 0; i < list.length; i++) { + var c = list[i]; if (c >= 0x41 && c <= 0x5A) { list[i] = c + 0x20; } @@ -10303,8 +11568,8 @@ function byteUppercase(list) { * To byte-uppercase a byte sequence, subtract each byte it contains, in the * range 0x61 (a) to 0x7A (z), inclusive, by 0x20. */ - for (let i = 0; i < list.length; i++) { - const c = list[i]; + for (var i = 0; i < list.length; i++) { + var c = list[i]; if (c >= 0x61 && c <= 0x7A) { list[i] = c - 0x20; } @@ -10324,9 +11589,9 @@ function byteCaseInsensitiveMatch(listA, listB) { */ if (listA.length !== listB.length) return false; - for (let i = 0; i < listA.length; i++) { - let a = listA[i]; - let b = listB[i]; + for (var i = 0; i < listA.length; i++) { + var a = listA[i]; + var b = listB[i]; if (a >= 0x41 && a <= 0x5A) a += 0x20; if (b >= 0x41 && b <= 0x5A) @@ -10353,7 +11618,7 @@ function startsWith(listA, listB) { * 2.5. Return false if aByte is not bByte. * 2.6. Set i to i + 1. */ - let i = 0; + var i = 0; while (true) { if (i >= listA.length) return false; @@ -10381,14 +11646,14 @@ function byteLessThan(listA, listB) { * 4. If the nth byte of a is less than the nth byte of b, then return true. * 5. Return false. */ - let i = 0; + var i = 0; while (true) { if (i >= listA.length) return false; if (i >= listB.length) return true; - const a = listA[i]; - const b = listB[i]; + var a = listA[i]; + var b = listB[i]; if (a < b) return true; else if (a > b) @@ -10408,32 +11673,67 @@ function isomorphicDecode(list) { * equal to input’s length and whose code points have the same values as * input’s bytes, in the same order. */ - return String.fromCodePoint(...list); + return String.fromCodePoint.apply(String, __spread(list)); } exports.isomorphicDecode = isomorphicDecode; //# sourceMappingURL=ByteSequence.js.map /***/ }), +/* 264 */, +/* 265 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 266: +"use strict"; +// Standard YAML's Failsafe schema. +// http://www.yaml.org/spec/1.2/spec.html#id2802346 + + + + + +var Schema = __webpack_require__(733); + + +module.exports = new Schema({ + explicit: [ + __webpack_require__(450), + __webpack_require__(921), + __webpack_require__(988) + ] +}); + + +/***/ }), +/* 266 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const _1 = __webpack_require__(113); -const util_1 = __webpack_require__(337); +var DOMImpl_1 = __webpack_require__(648); +var util_1 = __webpack_require__(592); /** * Represents an ordered list of nodes. * This is a static implementation of `NodeList`. */ -class NodeListStaticImpl { +var NodeListStaticImpl = /** @class */ (function () { /** * Initializes a new instance of `NodeList`. * * @param root - root node */ - constructor(root) { + function NodeListStaticImpl(root) { this._live = false; this._items = []; this._length = 0; @@ -10442,16 +11742,20 @@ class NodeListStaticImpl { this._filter = function (node) { return true; }; return new Proxy(this, this); } + Object.defineProperty(NodeListStaticImpl.prototype, "length", { + /** @inheritdoc */ + get: function () { + /** + * The length attribute must return the number of nodes represented by + * the collection. + */ + return this._items.length; + }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get length() { - /** - * The length attribute must return the number of nodes represented by - * the collection. - */ - return this._items.length; - } - /** @inheritdoc */ - item(index) { + NodeListStaticImpl.prototype.item = function (index) { /** * The item(index) method must return the indexth node in the collection. * If there is no indexth node in the collection, then the method must @@ -10460,12 +11764,13 @@ class NodeListStaticImpl { if (index < 0 || index > this.length - 1) return null; return this._items[index]; - } + }; /** @inheritdoc */ - keys() { - return { - [Symbol.iterator]: function () { - let index = 0; + NodeListStaticImpl.prototype.keys = function () { + var _a; + return _a = {}, + _a[Symbol.iterator] = function () { + var index = 0; return { next: function () { if (index === this.length) { @@ -10476,31 +11781,33 @@ class NodeListStaticImpl { } }.bind(this) }; - }.bind(this) - }; - } + }.bind(this), + _a; + }; /** @inheritdoc */ - values() { - return { - [Symbol.iterator]: function () { - const it = this[Symbol.iterator](); + NodeListStaticImpl.prototype.values = function () { + var _a; + return _a = {}, + _a[Symbol.iterator] = function () { + var it = this[Symbol.iterator](); return { - next() { + next: function () { return it.next(); } }; - }.bind(this) - }; - } + }.bind(this), + _a; + }; /** @inheritdoc */ - entries() { - return { - [Symbol.iterator]: function () { - const it = this[Symbol.iterator](); - let index = 0; + NodeListStaticImpl.prototype.entries = function () { + var _a; + return _a = {}, + _a[Symbol.iterator] = function () { + var it = this[Symbol.iterator](); + var index = 0; return { - next() { - const itResult = it.next(); + next: function () { + var itResult = it.next(); if (itResult.done) { return { done: true, value: null }; } @@ -10509,49 +11816,60 @@ class NodeListStaticImpl { } } }; - }.bind(this) - }; - } + }.bind(this), + _a; + }; /** @inheritdoc */ - [Symbol.iterator]() { - const it = this._items[Symbol.iterator](); + NodeListStaticImpl.prototype[Symbol.iterator] = function () { + var it = this._items[Symbol.iterator](); return { - next() { + next: function () { return it.next(); } }; - } + }; /** @inheritdoc */ - forEach(callback, thisArg) { + NodeListStaticImpl.prototype.forEach = function (callback, thisArg) { + var e_1, _a; if (thisArg === undefined) { - thisArg = _1.dom.window; + thisArg = DOMImpl_1.dom.window; } - let index = 0; - for (const node of this._items) { - callback.call(thisArg, node, index++, this); + var index = 0; + try { + for (var _b = __values(this._items), _c = _b.next(); !_c.done; _c = _b.next()) { + var node = _c.value; + callback.call(thisArg, node, index++, this); + } } - } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + }; /** * Implements a proxy get trap to provide array-like access. */ - get(target, key, receiver) { + NodeListStaticImpl.prototype.get = function (target, key, receiver) { if (!util_1.isString(key)) { return Reflect.get(target, key, receiver); } - const index = Number(key); + var index = Number(key); if (isNaN(index)) { return Reflect.get(target, key, receiver); } return target._items[index] || undefined; - } + }; /** * Implements a proxy set trap to provide array-like access. */ - set(target, key, value, receiver) { + NodeListStaticImpl.prototype.set = function (target, key, value, receiver) { if (!util_1.isString(key)) { return Reflect.set(target, key, value, receiver); } - const index = Number(key); + var index = Number(key); if (isNaN(index)) { return Reflect.set(target, key, value, receiver); } @@ -10562,70 +11880,39 @@ class NodeListStaticImpl { else { return false; } - } + }; /** * Creates a new `NodeList`. * * @param root - root node * @param items - a list of items to initialize the list */ - static _create(root, items) { - const list = new NodeListStaticImpl(root); + NodeListStaticImpl._create = function (root, items) { + var list = new NodeListStaticImpl(root); list._items = items; return list; - } -} + }; + return NodeListStaticImpl; +}()); exports.NodeListStaticImpl = NodeListStaticImpl; //# sourceMappingURL=NodeListStaticImpl.js.map /***/ }), - -/***/ 271: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents an object with lazy initialization. - */ -class Lazy { - /** - * Initializes a new instance of `Lazy`. - * - * @param initFunc - initializer function - */ - constructor(initFunc) { - this._initialized = false; - this._value = undefined; - this._initFunc = initFunc; - } - /** - * Gets the value of the object. - */ - get value() { - if (!this._initialized) { - this._value = this._initFunc(); - this._initialized = true; - } - return this._value; - } -} -exports.Lazy = Lazy; -//# sourceMappingURL=Lazy.js.map - -/***/ }), - -/***/ 272: +/* 267 */, +/* 268 */, +/* 269 */, +/* 270 */, +/* 271 */, +/* 272 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const interfaces_1 = __webpack_require__(970); -const TraversalAlgorithm_1 = __webpack_require__(464); -const TreeAlgorithm_1 = __webpack_require__(873); +var DOMImpl_1 = __webpack_require__(648); +var interfaces_1 = __webpack_require__(970); +var TraversalAlgorithm_1 = __webpack_require__(464); +var TreeAlgorithm_1 = __webpack_require__(873); /** * Returns the next or previous node in the subtree, or `null` if * there are none. @@ -10639,8 +11926,8 @@ function nodeIterator_traverse(iterator, forward) { * 1. Let node be iterator’s reference. * 2. Let beforeNode be iterator’s pointer before reference. */ - let node = iterator._reference; - let beforeNode = iterator._pointerBeforeReference; + var node = iterator._reference; + var beforeNode = iterator._pointerBeforeReference; /** * 3. While true: */ @@ -10658,7 +11945,7 @@ function nodeIterator_traverse(iterator, forward) { * node in iterator’s iterator collection. If there is no such node, * then return null. */ - const nextNode = TreeAlgorithm_1.tree_getFollowingNode(iterator._root, node); + var nextNode = TreeAlgorithm_1.tree_getFollowingNode(iterator._root, node); if (nextNode) { node = nextNode; } @@ -10683,7 +11970,7 @@ function nodeIterator_traverse(iterator, forward) { * node in iterator’s iterator collection. If there is no such node, * then return null. */ - const prevNode = TreeAlgorithm_1.tree_getPrecedingNode(iterator.root, node); + var prevNode = TreeAlgorithm_1.tree_getPrecedingNode(iterator.root, node); if (prevNode) { node = prevNode; } @@ -10702,7 +11989,7 @@ function nodeIterator_traverse(iterator, forward) { * 3.2. Let result be the result of filtering node within iterator. * 3.3. If result is FILTER_ACCEPT, then break. */ - const result = TraversalAlgorithm_1.traversal_filter(iterator, node); + var result = TraversalAlgorithm_1.traversal_filter(iterator, node); if (result === interfaces_1.FilterResult.Accept) { break; } @@ -10721,20 +12008,83 @@ exports.nodeIterator_traverse = nodeIterator_traverse; * Gets the global iterator list. */ function nodeIterator_iteratorList() { - return dom_1.dom.window._iteratorList; + return DOMImpl_1.dom.window._iteratorList; } exports.nodeIterator_iteratorList = nodeIterator_iteratorList; //# sourceMappingURL=NodeIteratorAlgorithm.js.map /***/ }), - -/***/ 279: +/* 273 */, +/* 274 */, +/* 275 */, +/* 276 */, +/* 277 */, +/* 278 */, +/* 279 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(68); +var util_1 = __webpack_require__(592); /** * Gets the value corresponding to the given key. * @@ -10764,18 +12114,39 @@ exports.set = set; * items to remove */ function remove(map, conditionOrItem) { + var e_1, _a, e_2, _b; if (!util_1.isFunction(conditionOrItem)) { map.delete(conditionOrItem); } else { - const toRemove = []; - for (const item of map) { - if (!!conditionOrItem.call(null, item)) { - toRemove.push(item[0]); + var toRemove = []; + try { + for (var map_1 = __values(map), map_1_1 = map_1.next(); !map_1_1.done; map_1_1 = map_1.next()) { + var item = map_1_1.value; + if (!!conditionOrItem.call(null, item)) { + toRemove.push(item[0]); + } } } - for (const key of toRemove) { - map.delete(key); + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (map_1_1 && !map_1_1.done && (_a = map_1.return)) _a.call(map_1); + } + finally { if (e_1) throw e_1.error; } + } + try { + for (var toRemove_1 = __values(toRemove), toRemove_1_1 = toRemove_1.next(); !toRemove_1_1.done; toRemove_1_1 = toRemove_1.next()) { + var key = toRemove_1_1.value; + map.delete(key); + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (toRemove_1_1 && !toRemove_1_1.done && (_b = toRemove_1.return)) _b.call(toRemove_1); + } + finally { if (e_2) throw e_2.error; } } } } @@ -10788,15 +12159,26 @@ exports.remove = remove; * items */ function contains(map, conditionOrItem) { + var e_3, _a; if (!util_1.isFunction(conditionOrItem)) { return map.has(conditionOrItem); } else { - for (const item of map) { - if (!!conditionOrItem.call(null, item)) { - return true; + try { + for (var map_2 = __values(map), map_2_1 = map_2.next(); !map_2_1.done; map_2_1 = map_2.next()) { + var item = map_2_1.value; + if (!!conditionOrItem.call(null, item)) { + return true; + } } } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (map_2_1 && !map_2_1.done && (_a = map_2.return)) _a.call(map_2); + } + finally { if (e_3) throw e_3.error; } + } return false; } } @@ -10816,7 +12198,7 @@ exports.keys = keys; * @param map - a map */ function values(map) { - return [...map.values()]; + return __spread(map.values()); } exports.values = values; /** @@ -10826,16 +12208,27 @@ exports.values = values; * @param condition - an optional condition to match */ function size(map, condition) { + var e_4, _a; if (condition === undefined) { return map.size; } else { - let count = 0; - for (const item of map) { - if (!!condition.call(null, item)) { - count++; + var count = 0; + try { + for (var map_3 = __values(map), map_3_1 = map_3.next(); !map_3_1.done; map_3_1 = map_3.next()) { + var item = map_3_1.value; + if (!!condition.call(null, item)) { + count++; + } } } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (map_3_1 && !map_3_1.done && (_a = map_3.return)) _a.call(map_3); + } + finally { if (e_4) throw e_4.error; } + } return count; } } @@ -10855,17 +12248,46 @@ exports.isEmpty = isEmpty; * @param map - a map * @param condition - an optional condition to match */ -function* forEach(map, condition) { - if (condition === undefined) { - yield* map; - } - else { - for (const item of map) { - if (!!condition.call(null, item)) { - yield item; - } +function forEach(map, condition) { + var map_4, map_4_1, item, e_5_1; + var e_5, _a; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + if (!(condition === undefined)) return [3 /*break*/, 2]; + return [5 /*yield**/, __values(map)]; + case 1: + _b.sent(); + return [3 /*break*/, 9]; + case 2: + _b.trys.push([2, 7, 8, 9]); + map_4 = __values(map), map_4_1 = map_4.next(); + _b.label = 3; + case 3: + if (!!map_4_1.done) return [3 /*break*/, 6]; + item = map_4_1.value; + if (!!!condition.call(null, item)) return [3 /*break*/, 5]; + return [4 /*yield*/, item]; + case 4: + _b.sent(); + _b.label = 5; + case 5: + map_4_1 = map_4.next(); + return [3 /*break*/, 3]; + case 6: return [3 /*break*/, 9]; + case 7: + e_5_1 = _b.sent(); + e_5 = { error: e_5_1 }; + return [3 /*break*/, 9]; + case 8: + try { + if (map_4_1 && !map_4_1.done && (_a = map_4.return)) _a.call(map_4); + } + finally { if (e_5) throw e_5.error; } + return [7 /*endfinally*/]; + case 9: return [2 /*return*/]; } - } + }); } exports.forEach = forEach; /** @@ -10886,8 +12308,10 @@ exports.clone = clone; * is less than its second argument, and `false` otherwise. */ function sortInAscendingOrder(map, lessThanAlgo) { - const list = new Array(...map); - list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1); + var list = new (Array.bind.apply(Array, __spread([void 0], map)))(); + list.sort(function (itemA, itemB) { + return lessThanAlgo.call(null, itemA, itemB) ? -1 : 1; + }); return new Map(list); } exports.sortInAscendingOrder = sortInAscendingOrder; @@ -10900,16 +12324,11693 @@ exports.sortInAscendingOrder = sortInAscendingOrder; * is less than its second argument, and `false` otherwise. */ function sortInDescendingOrder(map, lessThanAlgo) { - const list = new Array(...map); - list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1); + var list = new (Array.bind.apply(Array, __spread([void 0], map)))(); + list.sort(function (itemA, itemB) { + return lessThanAlgo.call(null, itemA, itemB) ? 1 : -1; + }); return new Map(list); } exports.sortInDescendingOrder = sortInDescendingOrder; //# sourceMappingURL=Map.js.map /***/ }), +/* 280 */, +/* 281 */, +/* 282 */, +/* 283 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 280: +const compare = __webpack_require__(874) +const compareLoose = (a, b) => compare(a, b, true) +module.exports = compareLoose + + +/***/ }), +/* 284 */, +/* 285 */, +/* 286 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Represents the state of the URL parser. + */ +var ParserState; +(function (ParserState) { + ParserState[ParserState["SchemeStart"] = 0] = "SchemeStart"; + ParserState[ParserState["Scheme"] = 1] = "Scheme"; + ParserState[ParserState["NoScheme"] = 2] = "NoScheme"; + ParserState[ParserState["SpecialRelativeOrAuthority"] = 3] = "SpecialRelativeOrAuthority"; + ParserState[ParserState["PathOrAuthority"] = 4] = "PathOrAuthority"; + ParserState[ParserState["Relative"] = 5] = "Relative"; + ParserState[ParserState["RelativeSlash"] = 6] = "RelativeSlash"; + ParserState[ParserState["SpecialAuthoritySlashes"] = 7] = "SpecialAuthoritySlashes"; + ParserState[ParserState["SpecialAuthorityIgnoreSlashes"] = 8] = "SpecialAuthorityIgnoreSlashes"; + ParserState[ParserState["Authority"] = 9] = "Authority"; + ParserState[ParserState["Host"] = 10] = "Host"; + ParserState[ParserState["Hostname"] = 11] = "Hostname"; + ParserState[ParserState["Port"] = 12] = "Port"; + ParserState[ParserState["File"] = 13] = "File"; + ParserState[ParserState["FileSlash"] = 14] = "FileSlash"; + ParserState[ParserState["FileHost"] = 15] = "FileHost"; + ParserState[ParserState["PathStart"] = 16] = "PathStart"; + ParserState[ParserState["Path"] = 17] = "Path"; + ParserState[ParserState["CannotBeABaseURLPath"] = 18] = "CannotBeABaseURLPath"; + ParserState[ParserState["Query"] = 19] = "Query"; + ParserState[ParserState["Fragment"] = 20] = "Fragment"; +})(ParserState = exports.ParserState || (exports.ParserState = {})); +exports.OpaqueOrigin = ["", "", null, null]; +//# sourceMappingURL=interfaces.js.map + +/***/ }), +/* 287 */, +/* 288 */, +/* 289 */, +/* 290 */, +/* 291 */, +/* 292 */, +/* 293 */, +/* 294 */, +/* 295 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var _1 = __webpack_require__(535); +/** + * Creates an XML builder which serializes the document in chunks. + * + * @param options - callback builder options + * + * @returns callback builder + */ +function createCB(options) { + return new _1.XMLBuilderCBImpl(options); +} +exports.createCB = createCB; +/** + * Creates an XML builder which serializes the fragment in chunks. + * + * @param options - callback builder options + * + * @returns callback builder + */ +function fragmentCB(options) { + return new _1.XMLBuilderCBImpl(options, true); +} +exports.fragmentCB = fragmentCB; +//# sourceMappingURL=BuilderFunctionsCB.js.map + +/***/ }), +/* 296 */, +/* 297 */, +/* 298 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const eq = (a, b, loose) => compare(a, b, loose) === 0 +module.exports = eq + + +/***/ }), +/* 299 */, +/* 300 */, +/* 301 */, +/* 302 */, +/* 303 */, +/* 304 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var DOMImpl_1 = __webpack_require__(648); +var TreeAlgorithm_1 = __webpack_require__(873); +var util_1 = __webpack_require__(918); +var ShadowTreeAlgorithm_1 = __webpack_require__(180); +var supportedTokens = new Map(); +/** + * Runs removing steps for node. + * + * @param removedNode - removed node + * @param oldParent - old parent node + */ +function dom_runRemovingSteps(removedNode, oldParent) { + // No steps defined +} +exports.dom_runRemovingSteps = dom_runRemovingSteps; +/** + * Runs cloning steps for node. + * + * @param copy - node clone + * @param node - node + * @param document - document to own the cloned node + * @param cloneChildrenFlag - whether child nodes are cloned + */ +function dom_runCloningSteps(copy, node, document, cloneChildrenFlag) { + // No steps defined +} +exports.dom_runCloningSteps = dom_runCloningSteps; +/** + * Runs adopting steps for node. + * + * @param node - node + * @param oldDocument - old document + */ +function dom_runAdoptingSteps(node, oldDocument) { + // No steps defined +} +exports.dom_runAdoptingSteps = dom_runAdoptingSteps; +/** + * Runs attribute change steps for an element node. + * + * @param element - element node owning the attribute + * @param localName - attribute's local name + * @param oldValue - attribute's old value + * @param value - attribute's new value + * @param namespace - attribute's namespace + */ +function dom_runAttributeChangeSteps(element, localName, oldValue, value, namespace) { + var e_1, _a; + // run default steps + if (DOMImpl_1.dom.features.slots) { + updateASlotablesName.call(element, element, localName, oldValue, value, namespace); + updateASlotsName.call(element, element, localName, oldValue, value, namespace); + } + updateAnElementID.call(element, element, localName, value, namespace); + try { + // run custom steps + for (var _b = __values(element._attributeChangeSteps), _c = _b.next(); !_c.done; _c = _b.next()) { + var step = _c.value; + step.call(element, element, localName, oldValue, value, namespace); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } +} +exports.dom_runAttributeChangeSteps = dom_runAttributeChangeSteps; +/** + * Runs insertion steps for a node. + * + * @param insertedNode - inserted node + */ +function dom_runInsertionSteps(insertedNode) { + // No steps defined +} +exports.dom_runInsertionSteps = dom_runInsertionSteps; +/** + * Runs pre-removing steps for a node iterator and node. + * + * @param nodeIterator - a node iterator + * @param toBeRemoved - node to be removed + */ +function dom_runNodeIteratorPreRemovingSteps(nodeIterator, toBeRemoved) { + removeNodeIterator.call(nodeIterator, nodeIterator, toBeRemoved); +} +exports.dom_runNodeIteratorPreRemovingSteps = dom_runNodeIteratorPreRemovingSteps; +/** + * Determines if there are any supported tokens defined for the given + * attribute name. + * + * @param attributeName - an attribute name + */ +function dom_hasSupportedTokens(attributeName) { + return supportedTokens.has(attributeName); +} +exports.dom_hasSupportedTokens = dom_hasSupportedTokens; +/** + * Returns the set of supported tokens defined for the given attribute name. + * + * @param attributeName - an attribute name + */ +function dom_getSupportedTokens(attributeName) { + return supportedTokens.get(attributeName) || new Set(); +} +exports.dom_getSupportedTokens = dom_getSupportedTokens; +/** + * Runs event construction steps. + * + * @param event - an event + */ +function dom_runEventConstructingSteps(event) { + // No steps defined +} +exports.dom_runEventConstructingSteps = dom_runEventConstructingSteps; +/** + * Runs child text content change steps for a parent node. + * + * @param parent - parent node with text node child nodes + */ +function dom_runChildTextContentChangeSteps(parent) { + // No steps defined +} +exports.dom_runChildTextContentChangeSteps = dom_runChildTextContentChangeSteps; +/** + * Defines pre-removing steps for a node iterator. + */ +function removeNodeIterator(nodeIterator, toBeRemovedNode) { + /** + * 1. If toBeRemovedNode is not an inclusive ancestor of nodeIterator’s + * reference, or toBeRemovedNode is nodeIterator’s root, then return. + */ + if (toBeRemovedNode === nodeIterator._root || + !TreeAlgorithm_1.tree_isAncestorOf(nodeIterator._reference, toBeRemovedNode, true)) { + return; + } + /** + * 2. If nodeIterator’s pointer before reference is true, then: + */ + if (nodeIterator._pointerBeforeReference) { + /** + * 2.1. Let next be toBeRemovedNode’s first following node that is an + * inclusive descendant of nodeIterator’s root and is not an inclusive + * descendant of toBeRemovedNode, and null if there is no such node. + */ + while (true) { + var nextNode = TreeAlgorithm_1.tree_getFollowingNode(nodeIterator._root, toBeRemovedNode); + if (nextNode !== null && + TreeAlgorithm_1.tree_isDescendantOf(nodeIterator._root, nextNode, true) && + !TreeAlgorithm_1.tree_isDescendantOf(toBeRemovedNode, nextNode, true)) { + /** + * 2.2. If next is non-null, then set nodeIterator’s reference to next + * and return. + */ + nodeIterator._reference = nextNode; + return; + } + else if (nextNode === null) { + /** + * 2.3. Otherwise, set nodeIterator’s pointer before reference to false. + */ + nodeIterator._pointerBeforeReference = false; + return; + } + } + } + /** + * 3. Set nodeIterator’s reference to toBeRemovedNode’s parent, if + * toBeRemovedNode’s previous sibling is null, and to the inclusive + * descendant of toBeRemovedNode’s previous sibling that appears last in + * tree order otherwise. + */ + if (toBeRemovedNode._previousSibling === null) { + if (toBeRemovedNode._parent !== null) { + nodeIterator._reference = toBeRemovedNode._parent; + } + } + else { + var referenceNode = toBeRemovedNode._previousSibling; + var childNode = TreeAlgorithm_1.tree_getFirstDescendantNode(toBeRemovedNode._previousSibling, true, false); + while (childNode !== null) { + if (childNode !== null) { + referenceNode = childNode; + } + // loop through to get the last descendant node + childNode = TreeAlgorithm_1.tree_getNextDescendantNode(toBeRemovedNode._previousSibling, childNode, true, false); + } + nodeIterator._reference = referenceNode; + } +} +/** + * Defines attribute change steps to update a slot’s name. + */ +function updateASlotsName(element, localName, oldValue, value, namespace) { + /** + * 1. If element is a slot, localName is name, and namespace is null, then: + * 1.1. If value is oldValue, then return. + * 1.2. If value is null and oldValue is the empty string, then return. + * 1.3. If value is the empty string and oldValue is null, then return. + * 1.4. If value is null or the empty string, then set element’s name to the + * empty string. + * 1.5. Otherwise, set element’s name to value. + * 1.6. Run assign slotables for a tree with element’s root. + */ + if (util_1.Guard.isSlot(element) && localName === "name" && namespace === null) { + if (value === oldValue) + return; + if (value === null && oldValue === '') + return; + if (value === '' && oldValue === null) + return; + if ((value === null || value === '')) { + element._name = ''; + } + else { + element._name = value; + } + ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(element)); + } +} +/** + * Defines attribute change steps to update a slotable’s name. + */ +function updateASlotablesName(element, localName, oldValue, value, namespace) { + /** + * 1. If localName is slot and namespace is null, then: + * 1.1. If value is oldValue, then return. + * 1.2. If value is null and oldValue is the empty string, then return. + * 1.3. If value is the empty string and oldValue is null, then return. + * 1.4. If value is null or the empty string, then set element’s name to + * the empty string. + * 1.5. Otherwise, set element’s name to value. + * 1.6. If element is assigned, then run assign slotables for element’s + * assigned slot. + * 1.7. Run assign a slot for element. + */ + if (util_1.Guard.isSlotable(element) && localName === "slot" && namespace === null) { + if (value === oldValue) + return; + if (value === null && oldValue === '') + return; + if (value === '' && oldValue === null) + return; + if ((value === null || value === '')) { + element._name = ''; + } + else { + element._name = value; + } + if (ShadowTreeAlgorithm_1.shadowTree_isAssigned(element)) { + ShadowTreeAlgorithm_1.shadowTree_assignSlotables(element._assignedSlot); + } + ShadowTreeAlgorithm_1.shadowTree_assignASlot(element); + } +} +/** + * Defines attribute change steps to update an element's ID. + */ +function updateAnElementID(element, localName, value, namespace) { + /** + * 1. If localName is id, namespace is null, and value is null or the empty + * string, then unset element’s ID. + * 2. Otherwise, if localName is id, namespace is null, then set element’s + * ID to value. + */ + if (localName === "id" && namespace === null) { + if (!value) + element._uniqueIdentifier = undefined; + else + element._uniqueIdentifier = value; + } +} +//# sourceMappingURL=DOMAlgorithm.js.map + +/***/ }), +/* 305 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Pre-serializes XML nodes. + */ +var BaseReader = /** @class */ (function () { + /** + * Initializes a new instance of `BaseReader`. + * + * @param builderOptions - XML builder options + */ + function BaseReader(builderOptions) { + this._builderOptions = builderOptions; + if (builderOptions.parser) { + Object.assign(this, builderOptions.parser); + } + } + BaseReader.prototype._docType = function (parent, name, publicId, systemId) { + return parent.dtd({ name: name, pubID: publicId, sysID: systemId }); + }; + BaseReader.prototype._comment = function (parent, data) { + return parent.com(data); + }; + BaseReader.prototype._text = function (parent, data) { + return parent.txt(data); + }; + BaseReader.prototype._instruction = function (parent, target, data) { + return parent.ins(target, data); + }; + BaseReader.prototype._cdata = function (parent, data) { + return parent.dat(data); + }; + BaseReader.prototype._element = function (parent, namespace, name) { + return (namespace === undefined ? parent.ele(name) : parent.ele(namespace, name)); + }; + BaseReader.prototype._attribute = function (parent, namespace, name, value) { + return (namespace === undefined ? parent.att(name, value) : parent.att(namespace, name, value)); + }; + /** + * Main parser function which parses the given object and returns an XMLBuilder. + * + * @param node - node to recieve parsed content + * @param obj - object to parse + */ + BaseReader.prototype.parse = function (node, obj) { + return this._parse(node, obj); + }; + /** + * Creates a DocType node. + * The node will be skipped if the function returns `undefined`. + * + * @param name - node name + * @param publicId - public identifier + * @param systemId - system identifier + */ + BaseReader.prototype.docType = function (parent, name, publicId, systemId) { + return this._docType(parent, name, publicId, systemId); + }; + /** + * Creates a comment node. + * The node will be skipped if the function returns `undefined`. + * + * @param parent - parent node + * @param data - node data + */ + BaseReader.prototype.comment = function (parent, data) { + return this._comment(parent, data); + }; + /** + * Creates a text node. + * The node will be skipped if the function returns `undefined`. + * + * @param parent - parent node + * @param data - node data + */ + BaseReader.prototype.text = function (parent, data) { + return this._text(parent, data); + }; + /** + * Creates a processing instruction node. + * The node will be skipped if the function returns `undefined`. + * + * @param parent - parent node + * @param target - instruction target + * @param data - node data + */ + BaseReader.prototype.instruction = function (parent, target, data) { + return this._instruction(parent, target, data); + }; + /** + * Creates a CData section node. + * The node will be skipped if the function returns `undefined`. + * + * @param parent - parent node + * @param data - node data + */ + BaseReader.prototype.cdata = function (parent, data) { + return this._cdata(parent, data); + }; + /** + * Creates an element node. + * The node will be skipped if the function returns `undefined`. + * + * @param parent - parent node + * @param namespace - node namespace + * @param name - node name + */ + BaseReader.prototype.element = function (parent, namespace, name) { + return this._element(parent, namespace, name); + }; + /** + * Creates an attribute or namespace declaration. + * The node will be skipped if the function returns `undefined`. + * + * @param parent - parent node + * @param namespace - node namespace + * @param name - node name + * @param value - node value + */ + BaseReader.prototype.attribute = function (parent, namespace, name, value) { + return this._attribute(parent, namespace, name, value); + }; + return BaseReader; +}()); +exports.BaseReader = BaseReader; +//# sourceMappingURL=BaseReader.js.map + +/***/ }), +/* 306 */, +/* 307 */, +/* 308 */, +/* 309 */, +/* 310 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) +const satisfies = (version, range, options) => { + try { + range = new Range(range, options) + } catch (er) { + return false + } + return range.test(version) +} +module.exports = satisfies + + +/***/ }), +/* 311 */, +/* 312 */, +/* 313 */, +/* 314 */, +/* 315 */, +/* 316 */, +/* 317 */, +/* 318 */, +/* 319 */, +/* 320 */, +/* 321 */, +/* 322 */ +/***/ (function(__unusedmodule, exports, __webpack_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.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.getToolcachePath = exports.isVersionSatisfies = exports.getDownloadArchiveExtension = exports.extractJdkFile = exports.getVersionFromToolcachePath = exports.getTempDir = void 0; +const os_1 = __importDefault(__webpack_require__(87)); +const path_1 = __importDefault(__webpack_require__(622)); +const fs = __importStar(__webpack_require__(747)); +const semver = __importStar(__webpack_require__(876)); +const tc = __importStar(__webpack_require__(139)); +function getTempDir() { + let tempDirectory = process.env['RUNNER_TEMP'] || os_1.default.tmpdir(); + return tempDirectory; +} +exports.getTempDir = getTempDir; +function getVersionFromToolcachePath(toolPath) { + if (toolPath) { + return path_1.default.basename(path_1.default.dirname(toolPath)); + } + return toolPath; +} +exports.getVersionFromToolcachePath = getVersionFromToolcachePath; +function extractJdkFile(toolPath, extension) { + return __awaiter(this, void 0, void 0, function* () { + if (!extension) { + extension = toolPath.endsWith('.tar.gz') ? 'tar.gz' : path_1.default.extname(toolPath); + if (extension.startsWith('.')) { + extension = extension.substring(1); + } + } + switch (extension) { + case 'tar.gz': + case 'tar': + return yield tc.extractTar(toolPath); + case 'zip': + return yield tc.extractZip(toolPath); + default: + return yield tc.extract7z(toolPath); + } + }); +} +exports.extractJdkFile = extractJdkFile; +function getDownloadArchiveExtension() { + return process.platform === 'win32' ? 'zip' : 'tar.gz'; +} +exports.getDownloadArchiveExtension = getDownloadArchiveExtension; +function isVersionSatisfies(range, version) { + var _a; + if (semver.valid(range)) { + // if full version with build digit is provided as a range (such as '1.2.3+4') + // we should check for exact equal via compareBuild + // since semver.satisfies doesn't handle 4th digit + const semRange = semver.parse(range); + if (semRange && ((_a = semRange.build) === null || _a === void 0 ? void 0 : _a.length) > 0) { + return semver.compareBuild(range, version) === 0; + } + } + return semver.satisfies(version, range); +} +exports.isVersionSatisfies = isVersionSatisfies; +function getToolcachePath(toolName, version, architecture) { + var _a; + const toolcacheRoot = (_a = process.env['RUNNER_TOOL_CACHE']) !== null && _a !== void 0 ? _a : ''; + const fullPath = path_1.default.join(toolcacheRoot, toolName, version, architecture); + if (fs.existsSync(fullPath)) { + return fullPath; + } + return null; +} +exports.getToolcachePath = getToolcachePath; + + +/***/ }), +/* 323 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const outside = __webpack_require__(881) +// Determine if version is less than all the versions possible in the range +const ltr = (version, range, options) => outside(version, range, '<', options) +module.exports = ltr + + +/***/ }), +/* 324 */, +/* 325 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var ObjectWriter_1 = __webpack_require__(419); +var util_1 = __webpack_require__(592); +var BaseWriter_1 = __webpack_require__(462); +/** + * Serializes XML nodes into a YAML string. + */ +var YAMLWriter = /** @class */ (function (_super) { + __extends(YAMLWriter, _super); + /** + * Initializes a new instance of `YAMLWriter`. + * + * @param builderOptions - XML builder options + * @param writerOptions - serialization options + */ + function YAMLWriter(builderOptions, writerOptions) { + var _this = _super.call(this, builderOptions) || this; + // provide default options + _this._writerOptions = util_1.applyDefaults(writerOptions, { + wellFormed: false, + noDoubleEncoding: false, + indent: ' ', + newline: '\n', + offset: 0, + group: false, + verbose: false + }); + if (_this._writerOptions.indent.length < 2) { + throw new Error("YAML indententation string must be at least two characters long."); + } + if (_this._writerOptions.offset < 0) { + throw new Error("YAML offset should be zero or a positive number."); + } + return _this; + } + /** + * Produces an XML serialization of the given node. + * + * @param node - node to serialize + * @param writerOptions - serialization options + */ + YAMLWriter.prototype.serialize = function (node) { + // convert to object + var objectWriterOptions = util_1.applyDefaults(this._writerOptions, { + format: "object", + wellFormed: false, + noDoubleEncoding: false, + }); + var objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions); + var val = objectWriter.serialize(node); + var markup = this._beginLine(this._writerOptions, 0) + '---' + this._endLine(this._writerOptions) + + this._convertObject(val, this._writerOptions, 0); + // remove trailing newline + /* istanbul ignore else */ + if (markup.slice(-this._writerOptions.newline.length) === this._writerOptions.newline) { + markup = markup.slice(0, -this._writerOptions.newline.length); + } + return markup; + }; + /** + * Produces an XML serialization of the given object. + * + * @param obj - object to serialize + * @param options - serialization options + * @param level - depth of the XML tree + * @param indentLeaf - indents leaf nodes + */ + YAMLWriter.prototype._convertObject = function (obj, options, level, suppressIndent) { + var e_1, _a; + var _this = this; + if (suppressIndent === void 0) { suppressIndent = false; } + var markup = ''; + if (util_1.isArray(obj)) { + try { + for (var obj_1 = __values(obj), obj_1_1 = obj_1.next(); !obj_1_1.done; obj_1_1 = obj_1.next()) { + var val = obj_1_1.value; + markup += this._beginLine(options, level, true); + if (!util_1.isObject(val)) { + markup += this._val(val) + this._endLine(options); + } + else if (util_1.isEmpty(val)) { + markup += '""' + this._endLine(options); + } + else { + markup += this._convertObject(val, options, level, true); + } + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (obj_1_1 && !obj_1_1.done && (_a = obj_1.return)) _a.call(obj_1); + } + finally { if (e_1) throw e_1.error; } + } + } + else /* if (isObject(obj)) */ { + util_1.forEachObject(obj, function (key, val) { + if (suppressIndent) { + markup += _this._key(key); + suppressIndent = false; + } + else { + markup += _this._beginLine(options, level) + _this._key(key); + } + if (!util_1.isObject(val)) { + markup += ' ' + _this._val(val) + _this._endLine(options); + } + else if (util_1.isEmpty(val)) { + markup += ' ""' + _this._endLine(options); + } + else { + markup += _this._endLine(options) + + _this._convertObject(val, options, level + 1); + } + }, this); + } + return markup; + }; + /** + * Produces characters to be prepended to a line of string in pretty-print + * mode. + * + * @param options - serialization options + * @param level - current depth of the XML tree + * @param isArray - whether this line is an array item + */ + YAMLWriter.prototype._beginLine = function (options, level, isArray) { + if (isArray === void 0) { isArray = false; } + var indentLevel = options.offset + level + 1; + var chars = new Array(indentLevel).join(options.indent); + if (isArray) { + return chars.substr(0, chars.length - 2) + '-' + chars.substr(-1, 1); + } + else { + return chars; + } + }; + /** + * Produces characters to be appended to a line of string in pretty-print + * mode. + * + * @param options - serialization options + */ + YAMLWriter.prototype._endLine = function (options) { + return options.newline; + }; + /** + * Produces a YAML key string delimited with double quotes. + */ + YAMLWriter.prototype._key = function (key) { + return "\"" + key + "\":"; + }; + /** + * Produces a YAML value string delimited with double quotes. + */ + YAMLWriter.prototype._val = function (val) { + return JSON.stringify(val); + }; + return YAMLWriter; +}(BaseWriter_1.BaseWriter)); +exports.YAMLWriter = YAMLWriter; +//# sourceMappingURL=YAMLWriter.js.map + +/***/ }), +/* 326 */, +/* 327 */, +/* 328 */, +/* 329 */, +/* 330 */, +/* 331 */ +/***/ (function(__unusedmodule, exports, __webpack_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.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.generate = exports.createAuthenticationSettings = exports.configureAuthentication = exports.SETTINGS_FILE = exports.M2_DIR = void 0; +const path = __importStar(__webpack_require__(622)); +const core = __importStar(__webpack_require__(470)); +const io = __importStar(__webpack_require__(1)); +const fs = __importStar(__webpack_require__(747)); +const os = __importStar(__webpack_require__(87)); +const xmlbuilder2_1 = __webpack_require__(255); +const constants = __importStar(__webpack_require__(211)); +const gpg = __importStar(__webpack_require__(884)); +exports.M2_DIR = '.m2'; +exports.SETTINGS_FILE = 'settings.xml'; +function configureAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + const id = core.getInput(constants.INPUT_SERVER_ID); + const username = core.getInput(constants.INPUT_SERVER_USERNAME); + const password = core.getInput(constants.INPUT_SERVER_PASSWORD); + const gpgPrivateKey = core.getInput(constants.INPUT_GPG_PRIVATE_KEY) || constants.INPUT_DEFAULT_GPG_PRIVATE_KEY; + const gpgPassphrase = core.getInput(constants.INPUT_GPG_PASSPHRASE) || + (gpgPrivateKey ? constants.INPUT_DEFAULT_GPG_PASSPHRASE : undefined); + if (gpgPrivateKey) { + core.setSecret(gpgPrivateKey); + } + yield createAuthenticationSettings(id, username, password, gpgPassphrase); + if (gpgPrivateKey) { + core.info('Importing private gpg key'); + const keyFingerprint = (yield gpg.importKey(gpgPrivateKey)) || ''; + core.saveState(constants.STATE_GPG_PRIVATE_KEY_FINGERPRINT, keyFingerprint); + } + }); +} +exports.configureAuthentication = configureAuthentication; +function createAuthenticationSettings(id, username, password, gpgPassphrase = undefined) { + return __awaiter(this, void 0, void 0, function* () { + core.info(`Creating ${exports.SETTINGS_FILE} with server-id: ${id}`); + // when an alternate m2 location is specified use only that location (no .m2 directory) + // otherwise use the home/.m2/ path + const settingsDirectory = path.join(core.getInput(constants.INPUT_SETTINGS_PATH) || os.homedir(), core.getInput(constants.INPUT_SETTINGS_PATH) ? '' : exports.M2_DIR); + yield io.mkdirP(settingsDirectory); + yield write(settingsDirectory, generate(id, username, password, gpgPassphrase)); + }); +} +exports.createAuthenticationSettings = createAuthenticationSettings; +// only exported for testing purposes +function generate(id, username, password, gpgPassphrase) { + const xmlObj = { + settings: { + '@xmlns': 'http://maven.apache.org/SETTINGS/1.0.0', + '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance', + '@xsi:schemaLocation': 'http://maven.apache.org/SETTINGS/1.0.0 https://maven.apache.org/xsd/settings-1.0.0.xsd', + servers: { + server: [ + { + id: id, + username: `\${env.${username}}`, + password: `\${env.${password}}` + } + ] + } + } + }; + if (gpgPassphrase) { + const gpgServer = { + id: 'gpg.passphrase', + passphrase: `\${env.${gpgPassphrase}}` + }; + xmlObj.settings.servers.server.push(gpgServer); + } + return xmlbuilder2_1.create(xmlObj).end({ + headless: true, + prettyPrint: true, + width: 80 + }); +} +exports.generate = generate; +function write(directory, settings) { + return __awaiter(this, void 0, void 0, function* () { + const location = path.join(directory, exports.SETTINGS_FILE); + if (fs.existsSync(location)) { + core.info(`Overwriting existing file ${location}`); + } + else { + core.info(`Writing ${location}`); + } + return fs.writeFileSync(location, settings, { + encoding: 'utf-8', + flag: 'w' + }); + }); +} + + +/***/ }), +/* 332 */, +/* 333 */, +/* 334 */, +/* 335 */, +/* 336 */, +/* 337 */, +/* 338 */, +/* 339 */, +/* 340 */, +/* 341 */, +/* 342 */, +/* 343 */, +/* 344 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var PotentialCustomElementName = /[a-z]([\0-\t\x2D\._a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*-([\0-\t\x2D\._a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*/; +var NamesWithHyphen = new Set(['annotation-xml', 'color-profile', + 'font-face', 'font-face-src', 'font-face-uri', 'font-face-format', + 'font-face-name', 'missing-glyph']); +var ElementNames = new Set(['article', 'aside', 'blockquote', + 'body', 'div', 'footer', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', + 'header', 'main', 'nav', 'p', 'section', 'span']); +var VoidElementNames = new Set(['area', 'base', 'basefont', + 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen', + 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']); +var ShadowHostNames = new Set(['article', 'aside', 'blockquote', 'body', + 'div', 'footer', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'main', + 'nav', 'p', 'section', 'span']); +/** + * Determines if the given string is a valid custom element name. + * + * @param name - a name string + */ +function customElement_isValidCustomElementName(name) { + if (!PotentialCustomElementName.test(name)) + return false; + if (NamesWithHyphen.has(name)) + return false; + return true; +} +exports.customElement_isValidCustomElementName = customElement_isValidCustomElementName; +/** + * Determines if the given string is a valid element name. + * + * @param name - a name string + */ +function customElement_isValidElementName(name) { + return (ElementNames.has(name)); +} +exports.customElement_isValidElementName = customElement_isValidElementName; +/** + * Determines if the given string is a void element name. + * + * @param name - a name string + */ +function customElement_isVoidElementName(name) { + return (VoidElementNames.has(name)); +} +exports.customElement_isVoidElementName = customElement_isVoidElementName; +/** + * Determines if the given string is a valid shadow host element name. + * + * @param name - a name string + */ +function customElement_isValidShadowHostName(name) { + return (ShadowHostNames.has(name)); +} +exports.customElement_isValidShadowHostName = customElement_isValidShadowHostName; +/** + * Enqueues an upgrade reaction for a custom element. + * + * @param element - a custom element + * @param definition - a custom element definition + */ +function customElement_enqueueACustomElementUpgradeReaction(element, definition) { + // TODO: Implement in HTML DOM +} +exports.customElement_enqueueACustomElementUpgradeReaction = customElement_enqueueACustomElementUpgradeReaction; +/** + * Enqueues a callback reaction for a custom element. + * + * @param element - a custom element + * @param callbackName - name of the callback + * @param args - callback arguments + */ +function customElement_enqueueACustomElementCallbackReaction(element, callbackName, args) { + // TODO: Implement in HTML DOM +} +exports.customElement_enqueueACustomElementCallbackReaction = customElement_enqueueACustomElementCallbackReaction; +/** + * Upgrade a custom element. + * + * @param element - a custom element + */ +function customElement_upgrade(definition, element) { + // TODO: Implement in HTML DOM +} +exports.customElement_upgrade = customElement_upgrade; +/** + * Tries to upgrade a custom element. + * + * @param element - a custom element + */ +function customElement_tryToUpgrade(element) { + // TODO: Implement in HTML DOM +} +exports.customElement_tryToUpgrade = customElement_tryToUpgrade; +/** + * Looks up a custom element definition. + * + * @param document - a document + * @param namespace - element namespace + * @param localName - element local name + * @param is - an `is` value + */ +function customElement_lookUpACustomElementDefinition(document, namespace, localName, is) { + // TODO: Implement in HTML DOM + return null; +} +exports.customElement_lookUpACustomElementDefinition = customElement_lookUpACustomElementDefinition; +//# sourceMappingURL=CustomElementAlgorithm.js.map + +/***/ }), +/* 345 */, +/* 346 */, +/* 347 */, +/* 348 */, +/* 349 */, +/* 350 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var interfaces_1 = __webpack_require__(970); +var TreeAlgorithm_1 = __webpack_require__(873); +/** + * Defines the position of a boundary point relative to another. + * + * @param bp - a boundary point + * @param relativeTo - a boundary point to compare to + */ +function boundaryPoint_position(bp, relativeTo) { + var nodeA = bp[0]; + var offsetA = bp[1]; + var nodeB = relativeTo[0]; + var offsetB = relativeTo[1]; + /** + * 1. Assert: nodeA and nodeB have the same root. + */ + console.assert(TreeAlgorithm_1.tree_rootNode(nodeA) === TreeAlgorithm_1.tree_rootNode(nodeB), "Boundary points must share the same root node."); + /** + * 2. If nodeA is nodeB, then return equal if offsetA is offsetB, before + * if offsetA is less than offsetB, and after if offsetA is greater than + * offsetB. + */ + if (nodeA === nodeB) { + if (offsetA === offsetB) { + return interfaces_1.BoundaryPosition.Equal; + } + else if (offsetA < offsetB) { + return interfaces_1.BoundaryPosition.Before; + } + else { + return interfaces_1.BoundaryPosition.After; + } + } + /** + * 3. If nodeA is following nodeB, then if the position of (nodeB, offsetB) + * relative to (nodeA, offsetA) is before, return after, and if it is after, + * return before. + */ + if (TreeAlgorithm_1.tree_isFollowing(nodeB, nodeA)) { + var pos = boundaryPoint_position([nodeB, offsetB], [nodeA, offsetA]); + if (pos === interfaces_1.BoundaryPosition.Before) { + return interfaces_1.BoundaryPosition.After; + } + else if (pos === interfaces_1.BoundaryPosition.After) { + return interfaces_1.BoundaryPosition.Before; + } + } + /** + * 4. If nodeA is an ancestor of nodeB: + */ + if (TreeAlgorithm_1.tree_isAncestorOf(nodeB, nodeA)) { + /** + * 4.1. Let child be nodeB. + * 4.2. While child is not a child of nodeA, set child to its parent. + * 4.3. If child’s index is less than offsetA, then return after. + */ + var child = nodeB; + while (!TreeAlgorithm_1.tree_isChildOf(nodeA, child)) { + /* istanbul ignore else */ + if (child._parent !== null) { + child = child._parent; + } + } + if (TreeAlgorithm_1.tree_index(child) < offsetA) { + return interfaces_1.BoundaryPosition.After; + } + } + /** + * 5. Return before. + */ + return interfaces_1.BoundaryPosition.Before; +} +exports.boundaryPoint_position = boundaryPoint_position; +//# sourceMappingURL=BoundaryPointAlgorithm.js.map + +/***/ }), +/* 351 */, +/* 352 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var esprima; + +// Browserified version does not have esprima +// +// 1. For node.js just require module as deps +// 2. For browser try to require mudule via external AMD system. +// If not found - try to fallback to window.esprima. If not +// found too - then fail to parse. +// +try { + // workaround to exclude package from browserify list. + var _require = require; + esprima = _require('esprima'); +} catch (_) { + /* eslint-disable no-redeclare */ + /* global window */ + if (typeof window !== 'undefined') esprima = window.esprima; +} + +var Type = __webpack_require__(945); + +function resolveJavascriptFunction(data) { + if (data === null) return false; + + try { + var source = '(' + data + ')', + ast = esprima.parse(source, { range: true }); + + if (ast.type !== 'Program' || + ast.body.length !== 1 || + ast.body[0].type !== 'ExpressionStatement' || + (ast.body[0].expression.type !== 'ArrowFunctionExpression' && + ast.body[0].expression.type !== 'FunctionExpression')) { + return false; + } + + return true; + } catch (err) { + return false; + } +} + +function constructJavascriptFunction(data) { + /*jslint evil:true*/ + + var source = '(' + data + ')', + ast = esprima.parse(source, { range: true }), + params = [], + body; + + if (ast.type !== 'Program' || + ast.body.length !== 1 || + ast.body[0].type !== 'ExpressionStatement' || + (ast.body[0].expression.type !== 'ArrowFunctionExpression' && + ast.body[0].expression.type !== 'FunctionExpression')) { + throw new Error('Failed to resolve function'); + } + + ast.body[0].expression.params.forEach(function (param) { + params.push(param.name); + }); + + body = ast.body[0].expression.body.range; + + // Esprima's ranges include the first '{' and the last '}' characters on + // function expressions. So cut them out. + if (ast.body[0].expression.body.type === 'BlockStatement') { + /*eslint-disable no-new-func*/ + return new Function(params, source.slice(body[0] + 1, body[1] - 1)); + } + // ES6 arrow functions can omit the BlockStatement. In that case, just return + // the body. + /*eslint-disable no-new-func*/ + return new Function(params, 'return ' + source.slice(body[0], body[1])); +} + +function representJavascriptFunction(object /*, style*/) { + return object.toString(); +} + +function isFunction(object) { + return Object.prototype.toString.call(object) === '[object Function]'; +} + +module.exports = new Type('tag:yaml.org,2002:js/function', { + kind: 'scalar', + resolve: resolveJavascriptFunction, + construct: constructJavascriptFunction, + predicate: isFunction, + represent: representJavascriptFunction +}); + + +/***/ }), +/* 353 */, +/* 354 */, +/* 355 */, +/* 356 */, +/* 357 */ +/***/ (function(module) { + +module.exports = require("assert"); + +/***/ }), +/* 358 */, +/* 359 */, +/* 360 */, +/* 361 */, +/* 362 */, +/* 363 */, +/* 364 */, +/* 365 */, +/* 366 */, +/* 367 */, +/* 368 */, +/* 369 */, +/* 370 */, +/* 371 */, +/* 372 */, +/* 373 */ +/***/ (function(module) { + +module.exports = require("crypto"); + +/***/ }), +/* 374 */, +/* 375 */, +/* 376 */, +/* 377 */, +/* 378 */, +/* 379 */, +/* 380 */, +/* 381 */, +/* 382 */, +/* 383 */, +/* 384 */, +/* 385 */, +/* 386 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +function resolveJavascriptUndefined() { + return true; +} + +function constructJavascriptUndefined() { + /*eslint-disable no-undefined*/ + return undefined; +} + +function representJavascriptUndefined() { + return ''; +} + +function isUndefined(object) { + return typeof object === 'undefined'; +} + +module.exports = new Type('tag:yaml.org,2002:js/undefined', { + kind: 'scalar', + resolve: resolveJavascriptUndefined, + construct: constructJavascriptUndefined, + predicate: isUndefined, + represent: representJavascriptUndefined +}); + + +/***/ }), +/* 387 */, +/* 388 */, +/* 389 */, +/* 390 */, +/* 391 */, +/* 392 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * A namespace prefix map is a map that associates namespaceURI and namespace + * prefix lists, where namespaceURI values are the map's unique keys (which can + * include the null value representing no namespace), and ordered lists of + * associated prefix values are the map's key values. The namespace prefix map + * will be populated by previously seen namespaceURIs and all their previously + * encountered prefix associations for a given node and its ancestors. + * + * _Note:_ The last seen prefix for a given namespaceURI is at the end of its + * respective list. The list is searched to find potentially matching prefixes, + * and if no matches are found for the given namespaceURI, then the last prefix + * in the list is used. See copy a namespace prefix map and retrieve a preferred + * prefix string for additional details. + * + * See: https://w3c.github.io/DOM-Parsing/#the-namespace-prefix-map + */ +var NamespacePrefixMap = /** @class */ (function () { + function NamespacePrefixMap() { + this._items = {}; + this._nullItems = []; + } + /** + * Creates a copy of the map. + */ + NamespacePrefixMap.prototype.copy = function () { + /** + * To copy a namespace prefix map map means to copy the map's keys into a + * new empty namespace prefix map, and to copy each of the values in the + * namespace prefix list associated with each keys' value into a new list + * which should be associated with the respective key in the new map. + */ + var mapCopy = new NamespacePrefixMap(); + for (var key in this._items) { + mapCopy._items[key] = this._items[key].slice(0); + } + mapCopy._nullItems = this._nullItems.slice(0); + return mapCopy; + }; + /** + * Retrieves a preferred prefix string from the namespace prefix map. + * + * @param preferredPrefix - preferred prefix string + * @param ns - namespace + */ + NamespacePrefixMap.prototype.get = function (preferredPrefix, ns) { + /** + * 1. Let candidates list be the result of retrieving a list from map where + * there exists a key in map that matches the value of ns or if there is no + * such key, then stop running these steps, and return the null value. + */ + var candidatesList = ns === null ? this._nullItems : (this._items[ns] || null); + if (candidatesList === null) { + return null; + } + /** + * 2. Otherwise, for each prefix value prefix in candidates list, iterating + * from beginning to end: + * + * _Note:_ There will always be at least one prefix value in the list. + */ + var prefix = null; + for (var i = 0; i < candidatesList.length; i++) { + prefix = candidatesList[i]; + /** + * 2.1. If prefix matches preferred prefix, then stop running these steps + * and return prefix. + */ + if (prefix === preferredPrefix) { + return prefix; + } + } + /** + * 2.2. If prefix is the last item in the candidates list, then stop + * running these steps and return prefix. + */ + return prefix; + }; + /** + * Checks if a prefix string is found in the namespace prefix map associated + * with the given namespace. + * + * @param prefix - prefix string + * @param ns - namespace + */ + NamespacePrefixMap.prototype.has = function (prefix, ns) { + /** + * 1. Let candidates list be the result of retrieving a list from map where + * there exists a key in map that matches the value of ns or if there is + * no such key, then stop running these steps, and return false. + */ + var candidatesList = ns === null ? this._nullItems : (this._items[ns] || null); + if (candidatesList === null) { + return false; + } + /** + * 2. If the value of prefix occurs at least once in candidates list, + * return true, otherwise return false. + */ + return (candidatesList.indexOf(prefix) !== -1); + }; + /** + * Checks if a prefix string is found in the namespace prefix map. + * + * @param prefix - prefix string + */ + NamespacePrefixMap.prototype.hasPrefix = function (prefix) { + if (this._nullItems.indexOf(prefix) !== -1) + return true; + for (var key in this._items) { + if (this._items[key].indexOf(prefix) !== -1) + return true; + } + return false; + }; + /** + * Adds a prefix string associated with a namespace to the prefix map. + * + * @param prefix - prefix string + * @param ns - namespace + */ + NamespacePrefixMap.prototype.set = function (prefix, ns) { + /** + * 1. Let candidates list be the result of retrieving a list from map where + * there exists a key in map that matches the value of ns or if there is + * no such key, then let candidates list be null. + */ + var candidatesList = ns === null ? this._nullItems : (this._items[ns] || null); + /** + * 2. If candidates list is null, then create a new list with prefix as the + * only item in the list, and associate that list with a new key ns in map. + * 3. Otherwise, append prefix to the end of candidates list. + * + * _Note:_ The steps in retrieve a preferred prefix string use the list to + * track the most recently used (MRU) prefix associated with a given + * namespace, which will be the prefix at the end of the list. This list + * may contain duplicates of the same prefix value seen earlier + * (and that's OK). + */ + if (ns !== null && candidatesList === null) { + this._items[ns] = [prefix]; + } + else { + candidatesList.push(prefix); + } + }; + return NamespacePrefixMap; +}()); +exports.NamespacePrefixMap = NamespacePrefixMap; +//# sourceMappingURL=NamespacePrefixMap.js.map + +/***/ }), +/* 393 */ +/***/ (function(__unusedmodule, exports, __webpack_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.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.ZuluDistribution = void 0; +const core = __importStar(__webpack_require__(470)); +const tc = __importStar(__webpack_require__(139)); +const path_1 = __importDefault(__webpack_require__(622)); +const fs_1 = __importDefault(__webpack_require__(747)); +const semver_1 = __importDefault(__webpack_require__(876)); +const base_installer_1 = __webpack_require__(83); +const util_1 = __webpack_require__(322); +class ZuluDistribution extends base_installer_1.JavaBase { + constructor(installerOptions) { + super('Zulu', installerOptions); + } + findPackageForDownload(version) { + return __awaiter(this, void 0, void 0, function* () { + const availableVersionsRaw = yield this.getAvailableVersions(); + const availableVersions = availableVersionsRaw.map(item => { + return { + version: this.convertVersionToSemver(item.jdk_version), + url: item.url, + zuluVersion: this.convertVersionToSemver(item.zulu_version) + }; + }); + const satisfiedVersions = availableVersions + .filter(item => util_1.isVersionSatisfies(version, item.version)) + .sort((a, b) => { + // Azul provides two versions: jdk_version and azul_version + // we should sort by both fields by descending + return (-semver_1.default.compareBuild(a.version, b.version) || + -semver_1.default.compareBuild(a.zuluVersion, b.zuluVersion)); + }) + .map(item => { + return { + version: item.version, + url: item.url + }; + }); + const resolvedFullVersion = satisfiedVersions.length > 0 ? satisfiedVersions[0] : null; + if (!resolvedFullVersion) { + const availableOptions = availableVersions.map(item => item.version).join(', '); + const availableOptionsMessage = availableOptions + ? `\nAvailable versions: ${availableOptions}` + : ''; + throw new Error(`Could not find satisfied version for semver ${version}. ${availableOptionsMessage}`); + } + return resolvedFullVersion; + }); + } + downloadTool(javaRelease) { + return __awaiter(this, void 0, void 0, function* () { + let extractedJavaPath; + core.info(`Downloading Java ${javaRelease.version} (${this.distribution}) from ${javaRelease.url} ...`); + const javaArchivePath = yield tc.downloadTool(javaRelease.url); + core.info(`Extracting Java archive...`); + let extension = util_1.getDownloadArchiveExtension(); + extractedJavaPath = yield util_1.extractJdkFile(javaArchivePath, extension); + const archiveName = fs_1.default.readdirSync(extractedJavaPath)[0]; + const archivePath = path_1.default.join(extractedJavaPath, archiveName); + const javaPath = yield tc.cacheDir(archivePath, this.toolcacheFolderName, this.getToolcacheVersionName(javaRelease.version), this.architecture); + return { version: javaRelease.version, path: javaPath }; + }); + } + getAvailableVersions() { + var _a, _b; + return __awaiter(this, void 0, void 0, function* () { + const { arch, hw_bitness, abi } = this.getArchitectureOptions(); + const [bundleType, features] = this.packageType.split('+'); + const platform = this.getPlatformOption(); + const extension = util_1.getDownloadArchiveExtension(); + const javafx = (_a = features === null || features === void 0 ? void 0 : features.includes('fx')) !== null && _a !== void 0 ? _a : false; + const releaseStatus = this.stable ? 'ga' : 'ea'; + console.time('azul-retrieve-available-versions'); + const requestArguments = [ + `os=${platform}`, + `ext=${extension}`, + `bundle_type=${bundleType}`, + `javafx=${javafx}`, + `arch=${arch}`, + `hw_bitness=${hw_bitness}`, + `release_status=${releaseStatus}`, + abi ? `abi=${abi}` : null, + features ? `features=${features}` : null + ] + .filter(Boolean) + .join('&'); + const availableVersionsUrl = `https://api.azul.com/zulu/download/community/v1.0/bundles/?${requestArguments}`; + if (core.isDebug()) { + core.debug(`Gathering available versions from '${availableVersionsUrl}'`); + } + const availableVersions = (_b = (yield this.http.getJson(availableVersionsUrl)).result) !== null && _b !== void 0 ? _b : []; + if (core.isDebug()) { + core.startGroup('Print information about available versions'); + console.timeEnd('azul-retrieve-available-versions'); + console.log(`Available versions: [${availableVersions.length}]`); + console.log(availableVersions.map(item => item.jdk_version.join('.')).join(', ')); + core.endGroup(); + } + return availableVersions; + }); + } + getArchitectureOptions() { + if (this.architecture == 'x64') { + return { arch: 'x86', hw_bitness: '64', abi: '' }; + } + else if (this.architecture == 'x86') { + return { arch: 'x86', hw_bitness: '32', abi: '' }; + } + else { + return { arch: this.architecture, hw_bitness: '', abi: '' }; + } + } + getPlatformOption() { + // Azul has own platform names so need to map them + switch (process.platform) { + case 'darwin': + return 'macos'; + case 'win32': + return 'windows'; + default: + return process.platform; + } + } + // Azul API returns jdk_version as array of digits like [11, 0, 2, 1] + convertVersionToSemver(version_array) { + const mainVersion = version_array.slice(0, 3).join('.'); + if (version_array.length > 3) { + // intentionally ignore more than 4 numbers because it is invalid semver + return `${mainVersion}+${version_array[3]}`; + } + return mainVersion; + } +} +exports.ZuluDistribution = ZuluDistribution; + + +/***/ }), +/* 394 */, +/* 395 */, +/* 396 */ +/***/ (function(module) { + +"use strict"; + +module.exports = function (Yallist) { + Yallist.prototype[Symbol.iterator] = function* () { + for (let walker = this.head; walker; walker = walker.next) { + yield walker.value + } + } +} + + +/***/ }), +/* 397 */, +/* 398 */, +/* 399 */, +/* 400 */, +/* 401 */, +/* 402 */, +/* 403 */, +/* 404 */, +/* 405 */, +/* 406 */, +/* 407 */, +/* 408 */, +/* 409 */, +/* 410 */, +/* 411 */, +/* 412 */, +/* 413 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Represents an abstract range with a start and end boundary point. + */ +var AbstractRangeImpl = /** @class */ (function () { + function AbstractRangeImpl() { + } + Object.defineProperty(AbstractRangeImpl.prototype, "_startNode", { + get: function () { return this._start[0]; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AbstractRangeImpl.prototype, "_startOffset", { + get: function () { return this._start[1]; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AbstractRangeImpl.prototype, "_endNode", { + get: function () { return this._end[0]; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AbstractRangeImpl.prototype, "_endOffset", { + get: function () { return this._end[1]; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AbstractRangeImpl.prototype, "_collapsed", { + get: function () { + return (this._start[0] === this._end[0] && + this._start[1] === this._end[1]); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AbstractRangeImpl.prototype, "startContainer", { + /** @inheritdoc */ + get: function () { return this._startNode; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AbstractRangeImpl.prototype, "startOffset", { + /** @inheritdoc */ + get: function () { return this._startOffset; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AbstractRangeImpl.prototype, "endContainer", { + /** @inheritdoc */ + get: function () { return this._endNode; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AbstractRangeImpl.prototype, "endOffset", { + /** @inheritdoc */ + get: function () { return this._endOffset; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AbstractRangeImpl.prototype, "collapsed", { + /** @inheritdoc */ + get: function () { return this._collapsed; }, + enumerable: true, + configurable: true + }); + return AbstractRangeImpl; +}()); +exports.AbstractRangeImpl = AbstractRangeImpl; +//# sourceMappingURL=AbstractRangeImpl.js.map + +/***/ }), +/* 414 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + + +var yaml = __webpack_require__(9); + + +module.exports = yaml; + + +/***/ }), +/* 415 */, +/* 416 */, +/* 417 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var common = __webpack_require__(740); +var Type = __webpack_require__(945); + +var YAML_FLOAT_PATTERN = new RegExp( + // 2.5e4, 2.5 and integers + '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' + + // .2e4, .2 + // special case, seems not from spec + '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' + + // 20:59 + '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' + + // .inf + '|[-+]?\\.(?:inf|Inf|INF)' + + // .nan + '|\\.(?:nan|NaN|NAN))$'); + +function resolveYamlFloat(data) { + if (data === null) return false; + + if (!YAML_FLOAT_PATTERN.test(data) || + // Quick hack to not allow integers end with `_` + // Probably should update regexp & check speed + data[data.length - 1] === '_') { + return false; + } + + return true; +} + +function constructYamlFloat(data) { + var value, sign, base, digits; + + value = data.replace(/_/g, '').toLowerCase(); + sign = value[0] === '-' ? -1 : 1; + digits = []; + + if ('+-'.indexOf(value[0]) >= 0) { + value = value.slice(1); + } + + if (value === '.inf') { + return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + + } else if (value === '.nan') { + return NaN; + + } else if (value.indexOf(':') >= 0) { + value.split(':').forEach(function (v) { + digits.unshift(parseFloat(v, 10)); + }); + + value = 0.0; + base = 1; + + digits.forEach(function (d) { + value += d * base; + base *= 60; + }); + + return sign * value; + + } + return sign * parseFloat(value, 10); +} + + +var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; + +function representYamlFloat(object, style) { + var res; + + if (isNaN(object)) { + switch (style) { + case 'lowercase': return '.nan'; + case 'uppercase': return '.NAN'; + case 'camelcase': return '.NaN'; + } + } else if (Number.POSITIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '.inf'; + case 'uppercase': return '.INF'; + case 'camelcase': return '.Inf'; + } + } else if (Number.NEGATIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '-.inf'; + case 'uppercase': return '-.INF'; + case 'camelcase': return '-.Inf'; + } + } else if (common.isNegativeZero(object)) { + return '-0.0'; + } + + res = object.toString(10); + + // JS stringifier can build scientific format without dots: 5e-100, + // while YAML requres dot: 5.e-100. Fix it with simple hack + + return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res; +} + +function isFloat(object) { + return (Object.prototype.toString.call(object) === '[object Number]') && + (object % 1 !== 0 || common.isNegativeZero(object)); +} + +module.exports = new Type('tag:yaml.org,2002:float', { + kind: 'scalar', + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: 'lowercase' +}); + + +/***/ }), +/* 418 */, +/* 419 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var util_1 = __webpack_require__(592); +var interfaces_1 = __webpack_require__(970); +var BaseWriter_1 = __webpack_require__(462); +/** + * Serializes XML nodes into objects and arrays. + */ +var ObjectWriter = /** @class */ (function (_super) { + __extends(ObjectWriter, _super); + /** + * Initializes a new instance of `ObjectWriter`. + * + * @param builderOptions - XML builder options + * @param writerOptions - serialization options + */ + function ObjectWriter(builderOptions, writerOptions) { + var _this = _super.call(this, builderOptions) || this; + _this._writerOptions = util_1.applyDefaults(writerOptions, { + format: "object", + wellFormed: false, + noDoubleEncoding: false, + group: false, + verbose: false + }); + return _this; + } + /** + * Produces an XML serialization of the given node. + * + * @param node - node to serialize + */ + ObjectWriter.prototype.serialize = function (node) { + this._currentList = []; + this._currentIndex = 0; + this._listRegister = [this._currentList]; + /** + * First pass, serialize nodes + * This creates a list of nodes grouped under node types while preserving + * insertion order. For example: + * [ + * root: [ + * node: [ + * { "@" : { "att1": "val1", "att2": "val2" } + * { "#": "node text" } + * { childNode: [] } + * { "#": "more text" } + * ], + * node: [ + * { "@" : { "att": "val" } + * { "#": [ "text line1", "text line2" ] } + * ] + * ] + * ] + */ + this.serializeNode(node, this._writerOptions.wellFormed, this._writerOptions.noDoubleEncoding); + /** + * Second pass, process node lists. Above example becomes: + * { + * root: { + * node: [ + * { + * "@att1": "val1", + * "@att2": "val2", + * "#1": "node text", + * childNode: {}, + * "#2": "more text" + * }, + * { + * "@att": "val", + * "#": [ "text line1", "text line2" ] + * } + * ] + * } + * } + */ + return this._process(this._currentList, this._writerOptions); + }; + ObjectWriter.prototype._process = function (items, options) { + var _a, _b, _c, _d, _e, _f, _g; + if (items.length === 0) + return {}; + // determine if there are non-unique element names + var namesSeen = {}; + var hasNonUniqueNames = false; + var textCount = 0; + var commentCount = 0; + var instructionCount = 0; + var cdataCount = 0; + for (var i = 0; i < items.length; i++) { + var item = items[i]; + var key = Object.keys(item)[0]; + switch (key) { + case "@": + continue; + case "#": + textCount++; + break; + case "!": + commentCount++; + break; + case "?": + instructionCount++; + break; + case "$": + cdataCount++; + break; + default: + if (namesSeen[key]) { + hasNonUniqueNames = true; + } + else { + namesSeen[key] = true; + } + break; + } + } + var defAttrKey = this._getAttrKey(); + var defTextKey = this._getNodeKey(interfaces_1.NodeType.Text); + var defCommentKey = this._getNodeKey(interfaces_1.NodeType.Comment); + var defInstructionKey = this._getNodeKey(interfaces_1.NodeType.ProcessingInstruction); + var defCdataKey = this._getNodeKey(interfaces_1.NodeType.CData); + if (textCount === 1 && items.length === 1 && util_1.isString(items[0]["#"])) { + // special case of an element node with a single text node + return items[0]["#"]; + } + else if (hasNonUniqueNames) { + var obj = {}; + // process attributes first + for (var i = 0; i < items.length; i++) { + var item = items[i]; + var key = Object.keys(item)[0]; + if (key === "@") { + var attrs = item["@"]; + var attrKeys = Object.keys(attrs); + if (attrKeys.length === 1) { + obj[defAttrKey + attrKeys[0]] = attrs[attrKeys[0]]; + } + else { + obj[defAttrKey] = item["@"]; + } + } + } + // list contains element nodes with non-unique names + // return an array with mixed content notation + var result = []; + for (var i = 0; i < items.length; i++) { + var item = items[i]; + var key = Object.keys(item)[0]; + switch (key) { + case "@": + // attributes were processed above + break; + case "#": + result.push((_a = {}, _a[defTextKey] = item["#"], _a)); + break; + case "!": + result.push((_b = {}, _b[defCommentKey] = item["!"], _b)); + break; + case "?": + result.push((_c = {}, _c[defInstructionKey] = item["?"], _c)); + break; + case "$": + result.push((_d = {}, _d[defCdataKey] = item["$"], _d)); + break; + default: + // element node + var ele = item; + if (ele[key].length !== 0 && util_1.isArray(ele[key][0])) { + // group of element nodes + var eleGroup = []; + var listOfLists = ele[key]; + for (var i_1 = 0; i_1 < listOfLists.length; i_1++) { + eleGroup.push(this._process(listOfLists[i_1], options)); + } + result.push((_e = {}, _e[key] = eleGroup, _e)); + } + else { + // single element node + if (options.verbose) { + result.push((_f = {}, _f[key] = [this._process(ele[key], options)], _f)); + } + else { + result.push((_g = {}, _g[key] = this._process(ele[key], options), _g)); + } + } + break; + } + } + obj[defTextKey] = result; + return obj; + } + else { + // all element nodes have unique names + // return an object while prefixing data node keys + var textId = 1; + var commentId = 1; + var instructionId = 1; + var cdataId = 1; + var obj = {}; + for (var i = 0; i < items.length; i++) { + var item = items[i]; + var key = Object.keys(item)[0]; + switch (key) { + case "@": + var attrs = item["@"]; + var attrKeys = Object.keys(attrs); + if (!options.group || attrKeys.length === 1) { + for (var attrName in attrs) { + obj[defAttrKey + attrName] = attrs[attrName]; + } + } + else { + obj[defAttrKey] = attrs; + } + break; + case "#": + textId = this._processSpecItem(item["#"], obj, options.group, defTextKey, textCount, textId); + break; + case "!": + commentId = this._processSpecItem(item["!"], obj, options.group, defCommentKey, commentCount, commentId); + break; + case "?": + instructionId = this._processSpecItem(item["?"], obj, options.group, defInstructionKey, instructionCount, instructionId); + break; + case "$": + cdataId = this._processSpecItem(item["$"], obj, options.group, defCdataKey, cdataCount, cdataId); + break; + default: + // element node + var ele = item; + if (ele[key].length !== 0 && util_1.isArray(ele[key][0])) { + // group of element nodes + var eleGroup = []; + var listOfLists = ele[key]; + for (var i_2 = 0; i_2 < listOfLists.length; i_2++) { + eleGroup.push(this._process(listOfLists[i_2], options)); + } + obj[key] = eleGroup; + } + else { + // single element node + if (options.verbose) { + obj[key] = [this._process(ele[key], options)]; + } + else { + obj[key] = this._process(ele[key], options); + } + } + break; + } + } + return obj; + } + }; + ObjectWriter.prototype._processSpecItem = function (item, obj, group, defKey, count, id) { + var e_1, _a; + if (!group && util_1.isArray(item) && count + item.length > 2) { + try { + for (var item_1 = __values(item), item_1_1 = item_1.next(); !item_1_1.done; item_1_1 = item_1.next()) { + var subItem = item_1_1.value; + var key = defKey + (id++).toString(); + obj[key] = subItem; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (item_1_1 && !item_1_1.done && (_a = item_1.return)) _a.call(item_1); + } + finally { if (e_1) throw e_1.error; } + } + } + else { + var key = count > 1 ? defKey + (id++).toString() : defKey; + obj[key] = item; + } + return id; + }; + /** @inheritdoc */ + ObjectWriter.prototype.beginElement = function (name) { + var _a, _b; + var childItems = []; + if (this._currentList.length === 0) { + this._currentList.push((_a = {}, _a[name] = childItems, _a)); + } + else { + var lastItem = this._currentList[this._currentList.length - 1]; + if (this._isElementNode(lastItem, name)) { + if (lastItem[name].length !== 0 && util_1.isArray(lastItem[name][0])) { + var listOfLists = lastItem[name]; + listOfLists.push(childItems); + } + else { + lastItem[name] = [lastItem[name], childItems]; + } + } + else { + this._currentList.push((_b = {}, _b[name] = childItems, _b)); + } + } + this._currentIndex++; + if (this._listRegister.length > this._currentIndex) { + this._listRegister[this._currentIndex] = childItems; + } + else { + this._listRegister.push(childItems); + } + this._currentList = childItems; + }; + /** @inheritdoc */ + ObjectWriter.prototype.endElement = function () { + this._currentList = this._listRegister[--this._currentIndex]; + }; + /** @inheritdoc */ + ObjectWriter.prototype.attribute = function (name, value) { + var _a, _b; + if (this._currentList.length === 0) { + this._currentList.push({ "@": (_a = {}, _a[name] = value, _a) }); + } + else { + var lastItem = this._currentList[this._currentList.length - 1]; + /* istanbul ignore else */ + if (this._isAttrNode(lastItem)) { + lastItem["@"][name] = value; + } + else { + this._currentList.push({ "@": (_b = {}, _b[name] = value, _b) }); + } + } + }; + /** @inheritdoc */ + ObjectWriter.prototype.comment = function (data) { + if (this._currentList.length === 0) { + this._currentList.push({ "!": data }); + } + else { + var lastItem = this._currentList[this._currentList.length - 1]; + if (this._isCommentNode(lastItem)) { + if (util_1.isArray(lastItem["!"])) { + lastItem["!"].push(data); + } + else { + lastItem["!"] = [lastItem["!"], data]; + } + } + else { + this._currentList.push({ "!": data }); + } + } + }; + /** @inheritdoc */ + ObjectWriter.prototype.text = function (data) { + if (this._currentList.length === 0) { + this._currentList.push({ "#": data }); + } + else { + var lastItem = this._currentList[this._currentList.length - 1]; + if (this._isTextNode(lastItem)) { + if (util_1.isArray(lastItem["#"])) { + lastItem["#"].push(data); + } + else { + lastItem["#"] = [lastItem["#"], data]; + } + } + else { + this._currentList.push({ "#": data }); + } + } + }; + /** @inheritdoc */ + ObjectWriter.prototype.instruction = function (target, data) { + var value = (data === "" ? target : target + " " + data); + if (this._currentList.length === 0) { + this._currentList.push({ "?": value }); + } + else { + var lastItem = this._currentList[this._currentList.length - 1]; + if (this._isInstructionNode(lastItem)) { + if (util_1.isArray(lastItem["?"])) { + lastItem["?"].push(value); + } + else { + lastItem["?"] = [lastItem["?"], value]; + } + } + else { + this._currentList.push({ "?": value }); + } + } + }; + /** @inheritdoc */ + ObjectWriter.prototype.cdata = function (data) { + if (this._currentList.length === 0) { + this._currentList.push({ "$": data }); + } + else { + var lastItem = this._currentList[this._currentList.length - 1]; + if (this._isCDATANode(lastItem)) { + if (util_1.isArray(lastItem["$"])) { + lastItem["$"].push(data); + } + else { + lastItem["$"] = [lastItem["$"], data]; + } + } + else { + this._currentList.push({ "$": data }); + } + } + }; + ObjectWriter.prototype._isAttrNode = function (x) { + return "@" in x; + }; + ObjectWriter.prototype._isTextNode = function (x) { + return "#" in x; + }; + ObjectWriter.prototype._isCommentNode = function (x) { + return "!" in x; + }; + ObjectWriter.prototype._isInstructionNode = function (x) { + return "?" in x; + }; + ObjectWriter.prototype._isCDATANode = function (x) { + return "$" in x; + }; + ObjectWriter.prototype._isElementNode = function (x, name) { + return name in x; + }; + /** + * Returns an object key for an attribute or namespace declaration. + */ + ObjectWriter.prototype._getAttrKey = function () { + return this._builderOptions.convert.att; + }; + /** + * Returns an object key for the given node type. + * + * @param nodeType - node type to get a key for + */ + ObjectWriter.prototype._getNodeKey = function (nodeType) { + switch (nodeType) { + case interfaces_1.NodeType.Comment: + return this._builderOptions.convert.comment; + case interfaces_1.NodeType.Text: + return this._builderOptions.convert.text; + case interfaces_1.NodeType.ProcessingInstruction: + return this._builderOptions.convert.ins; + case interfaces_1.NodeType.CData: + return this._builderOptions.convert.cdata; + /* istanbul ignore next */ + default: + throw new Error("Invalid node type."); + } + }; + return ObjectWriter; +}(BaseWriter_1.BaseWriter)); +exports.ObjectWriter = ObjectWriter; +//# sourceMappingURL=ObjectWriter.js.map + +/***/ }), +/* 420 */, +/* 421 */, +/* 422 */, +/* 423 */, +/* 424 */, +/* 425 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var DOMImpl_1 = __webpack_require__(648); +var DOMException_1 = __webpack_require__(35); +var infra_1 = __webpack_require__(23); +var algorithm_1 = __webpack_require__(163); +/** + * Represents a token set. + */ +var DOMTokenListImpl = /** @class */ (function () { + /** + * Initializes a new instance of `DOMTokenList`. + * + * @param element - associated element + * @param attribute - associated attribute + */ + function DOMTokenListImpl(element, attribute) { + /** + * 1. Let element be associated element. + * 2. Let localName be associated attribute’s local name. + * 3. Let value be the result of getting an attribute value given element + * and localName. + * 4. Run the attribute change steps for element, localName, value, value, + * and null. + */ + this._element = element; + this._attribute = attribute; + this._tokenSet = new Set(); + var localName = attribute._localName; + var value = algorithm_1.element_getAnAttributeValue(element, localName); + // define a closure to be called when the associated attribute's value changes + var thisObj = this; + function updateTokenSet(element, localName, oldValue, value, namespace) { + /** + * 1. If localName is associated attribute’s local name, namespace is null, + * and value is null, then empty token set. + * 2. Otherwise, if localName is associated attribute’s local name, + * namespace is null, then set token set to value, parsed. + */ + if (localName === thisObj._attribute._localName && namespace === null) { + if (!value) + thisObj._tokenSet.clear(); + else + thisObj._tokenSet = algorithm_1.orderedSet_parse(value); + } + } + // add the closure to the associated element's attribute change steps + this._element._attributeChangeSteps.push(updateTokenSet); + if (DOMImpl_1.dom.features.steps) { + algorithm_1.dom_runAttributeChangeSteps(element, localName, value, value, null); + } + } + Object.defineProperty(DOMTokenListImpl.prototype, "length", { + /** @inheritdoc */ + get: function () { + /** + * The length attribute' getter must return context object’s token set’s + * size. + */ + return this._tokenSet.size; + }, + enumerable: true, + configurable: true + }); + /** @inheritdoc */ + DOMTokenListImpl.prototype.item = function (index) { + var e_1, _a; + /** + * 1. If index is equal to or greater than context object’s token set’s + * size, then return null. + * 2. Return context object’s token set[index]. + */ + var i = 0; + try { + for (var _b = __values(this._tokenSet), _c = _b.next(); !_c.done; _c = _b.next()) { + var token = _c.value; + if (i === index) + return token; + i++; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + return null; + }; + /** @inheritdoc */ + DOMTokenListImpl.prototype.contains = function (token) { + /** + * The contains(token) method, when invoked, must return true if context + * object’s token set[token] exists, and false otherwise. + */ + return this._tokenSet.has(token); + }; + /** @inheritdoc */ + DOMTokenListImpl.prototype.add = function () { + var e_2, _a; + var tokens = []; + for (var _i = 0; _i < arguments.length; _i++) { + tokens[_i] = arguments[_i]; + } + try { + /** + * 1. For each token in tokens: + * 1.1. If token is the empty string, then throw a "SyntaxError" + * DOMException. + * 1.2. If token contains any ASCII whitespace, then throw an + * "InvalidCharacterError" DOMException. + * 2. For each token in tokens, append token to context object’s token set. + * 3. Run the update steps. + */ + for (var tokens_1 = __values(tokens), tokens_1_1 = tokens_1.next(); !tokens_1_1.done; tokens_1_1 = tokens_1.next()) { + var token = tokens_1_1.value; + if (token === '') { + throw new DOMException_1.SyntaxError("Cannot add an empty token."); + } + else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) { + throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace."); + } + else { + this._tokenSet.add(token); + } + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (tokens_1_1 && !tokens_1_1.done && (_a = tokens_1.return)) _a.call(tokens_1); + } + finally { if (e_2) throw e_2.error; } + } + algorithm_1.tokenList_updateSteps(this); + }; + /** @inheritdoc */ + DOMTokenListImpl.prototype.remove = function () { + var e_3, _a; + var tokens = []; + for (var _i = 0; _i < arguments.length; _i++) { + tokens[_i] = arguments[_i]; + } + try { + /** + * 1. For each token in tokens: + * 1.1. If token is the empty string, then throw a "SyntaxError" + * DOMException. + * 1.2. If token contains any ASCII whitespace, then throw an + * "InvalidCharacterError" DOMException. + * 2. For each token in tokens, remove token from context object’s token set. + * 3. Run the update steps. + */ + for (var tokens_2 = __values(tokens), tokens_2_1 = tokens_2.next(); !tokens_2_1.done; tokens_2_1 = tokens_2.next()) { + var token = tokens_2_1.value; + if (token === '') { + throw new DOMException_1.SyntaxError("Cannot remove an empty token."); + } + else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) { + throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace."); + } + else { + this._tokenSet.delete(token); + } + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (tokens_2_1 && !tokens_2_1.done && (_a = tokens_2.return)) _a.call(tokens_2); + } + finally { if (e_3) throw e_3.error; } + } + algorithm_1.tokenList_updateSteps(this); + }; + /** @inheritdoc */ + DOMTokenListImpl.prototype.toggle = function (token, force) { + if (force === void 0) { force = undefined; } + /** + * 1. If token is the empty string, then throw a "SyntaxError" DOMException. + * 2. If token contains any ASCII whitespace, then throw an + * "InvalidCharacterError" DOMException. + */ + if (token === '') { + throw new DOMException_1.SyntaxError("Cannot toggle an empty token."); + } + else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) { + throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace."); + } + /** + * 3. If context object’s token set[token] exists, then: + */ + if (this._tokenSet.has(token)) { + /** + * 3.1. If force is either not given or is false, then remove token from + * context object’s token set, run the update steps and return false. + * 3.2. Return true. + */ + if (force === undefined || force === false) { + this._tokenSet.delete(token); + algorithm_1.tokenList_updateSteps(this); + return false; + } + return true; + } + /** + * 4. Otherwise, if force not given or is true, append token to context + * object’s token set, run the update steps, and return true. + */ + if (force === undefined || force === true) { + this._tokenSet.add(token); + algorithm_1.tokenList_updateSteps(this); + return true; + } + /** + * 5. Return false. + */ + return false; + }; + /** @inheritdoc */ + DOMTokenListImpl.prototype.replace = function (token, newToken) { + /** + * 1. If either token or newToken is the empty string, then throw a + * "SyntaxError" DOMException. + * 2. If either token or newToken contains any ASCII whitespace, then throw + * an "InvalidCharacterError" DOMException. + */ + if (token === '' || newToken === '') { + throw new DOMException_1.SyntaxError("Cannot replace an empty token."); + } + else if (infra_1.codePoint.ASCIIWhiteSpace.test(token) || infra_1.codePoint.ASCIIWhiteSpace.test(newToken)) { + throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace."); + } + /** + * 3. If context object’s token set does not contain token, then return + * false. + */ + if (!this._tokenSet.has(token)) + return false; + /** + * 4. Replace token in context object’s token set with newToken. + * 5. Run the update steps. + * 6. Return true. + */ + infra_1.set.replace(this._tokenSet, token, newToken); + algorithm_1.tokenList_updateSteps(this); + return true; + }; + /** @inheritdoc */ + DOMTokenListImpl.prototype.supports = function (token) { + /** + * 1. Let result be the return value of validation steps called with token. + * 2. Return result. + */ + return algorithm_1.tokenList_validationSteps(this, token); + }; + Object.defineProperty(DOMTokenListImpl.prototype, "value", { + /** @inheritdoc */ + get: function () { + /** + * The value attribute must return the result of running context object’s + * serialize steps. + */ + return algorithm_1.tokenList_serializeSteps(this); + }, + set: function (value) { + /** + * Setting the value attribute must set an attribute value for the + * associated element using associated attribute’s local name and the given + * value. + */ + algorithm_1.element_setAnAttributeValue(this._element, this._attribute._localName, value); + }, + enumerable: true, + configurable: true + }); + /** + * Returns an iterator for the token set. + */ + DOMTokenListImpl.prototype[Symbol.iterator] = function () { + var it = this._tokenSet[Symbol.iterator](); + return { + next: function () { + return it.next(); + } + }; + }; + /** + * Creates a new `DOMTokenList`. + * + * @param element - associated element + * @param attribute - associated attribute + */ + DOMTokenListImpl._create = function (element, attribute) { + return new DOMTokenListImpl(element, attribute); + }; + return DOMTokenListImpl; +}()); +exports.DOMTokenListImpl = DOMTokenListImpl; +//# sourceMappingURL=DOMTokenListImpl.js.map + +/***/ }), +/* 426 */, +/* 427 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var interfaces_1 = __webpack_require__(970); +var algorithm_1 = __webpack_require__(163); +var WebIDLAlgorithm_1 = __webpack_require__(495); +/** + * Represents a DOM event. + */ +var EventImpl = /** @class */ (function () { + /** + * Initializes a new instance of `Event`. + */ + function EventImpl(type, eventInit) { + this._target = null; + this._relatedTarget = null; + this._touchTargetList = []; + this._path = []; + this._currentTarget = null; + this._eventPhase = interfaces_1.EventPhase.None; + this._stopPropagationFlag = false; + this._stopImmediatePropagationFlag = false; + this._canceledFlag = false; + this._inPassiveListenerFlag = false; + this._composedFlag = false; + this._initializedFlag = false; + this._dispatchFlag = false; + this._isTrusted = false; + this._bubbles = false; + this._cancelable = false; + /** + * When a constructor of the Event interface, or of an interface that + * inherits from the Event interface, is invoked, these steps must be run, + * given the arguments type and eventInitDict: + * 1. Let event be the result of running the inner event creation steps with + * this interface, null, now, and eventInitDict. + * 2. Initialize event’s type attribute to type. + * 3. Return event. + */ + this._type = type; + if (eventInit) { + this._bubbles = eventInit.bubbles || false; + this._cancelable = eventInit.cancelable || false; + this._composedFlag = eventInit.composed || false; + } + this._initializedFlag = true; + this._timeStamp = new Date().getTime(); + } + Object.defineProperty(EventImpl.prototype, "type", { + /** @inheritdoc */ + get: function () { return this._type; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventImpl.prototype, "target", { + /** @inheritdoc */ + get: function () { return this._target; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventImpl.prototype, "srcElement", { + /** @inheritdoc */ + get: function () { return this._target; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventImpl.prototype, "currentTarget", { + /** @inheritdoc */ + get: function () { return this._currentTarget; }, + enumerable: true, + configurable: true + }); + /** @inheritdoc */ + EventImpl.prototype.composedPath = function () { + /** + * 1. Let composedPath be an empty list. + * 2. Let path be the context object’s path. + * 3. If path is empty, then return composedPath. + * 4. Let currentTarget be the context object’s currentTarget attribute + * value. + * 5. Append currentTarget to composedPath. + * 6. Let currentTargetIndex be 0. + * 7. Let currentTargetHiddenSubtreeLevel be 0. + */ + var composedPath = []; + var path = this._path; + if (path.length === 0) + return composedPath; + var currentTarget = this._currentTarget; + if (currentTarget === null) { + throw new Error("Event currentTarget is null."); + } + composedPath.push(currentTarget); + var currentTargetIndex = 0; + var currentTargetHiddenSubtreeLevel = 0; + /** + * 8. Let index be path’s size − 1. + * 9. While index is greater than or equal to 0: + */ + var index = path.length - 1; + while (index >= 0) { + /** + * 9.1. If path[index]'s root-of-closed-tree is true, then increase + * currentTargetHiddenSubtreeLevel by 1. + * 9.2. If path[index]'s invocation target is currentTarget, then set + * currentTargetIndex to index and break. + * 9.3. If path[index]'s slot-in-closed-tree is true, then decrease + * currentTargetHiddenSubtreeLevel by 1. + * 9.4. Decrease index by 1. + */ + if (path[index].rootOfClosedTree) { + currentTargetHiddenSubtreeLevel++; + } + if (path[index].invocationTarget === currentTarget) { + currentTargetIndex = index; + break; + } + if (path[index].slotInClosedTree) { + currentTargetHiddenSubtreeLevel--; + } + index--; + } + /** + * 10. Let currentHiddenLevel and maxHiddenLevel be + * currentTargetHiddenSubtreeLevel. + */ + var currentHiddenLevel = currentTargetHiddenSubtreeLevel; + var maxHiddenLevel = currentTargetHiddenSubtreeLevel; + /** + * 11. Set index to currentTargetIndex − 1. + * 12. While index is greater than or equal to 0: + */ + index = currentTargetIndex - 1; + while (index >= 0) { + /** + * 12.1. If path[index]'s root-of-closed-tree is true, then increase + * currentHiddenLevel by 1. + * 12.2. If currentHiddenLevel is less than or equal to maxHiddenLevel, + * then prepend path[index]'s invocation target to composedPath. + */ + if (path[index].rootOfClosedTree) { + currentHiddenLevel++; + } + if (currentHiddenLevel <= maxHiddenLevel) { + composedPath.unshift(path[index].invocationTarget); + } + /** + * 12.3. If path[index]'s slot-in-closed-tree is true, then: + */ + if (path[index].slotInClosedTree) { + /** + * 12.3.1. Decrease currentHiddenLevel by 1. + * 12.3.2. If currentHiddenLevel is less than maxHiddenLevel, then set + * maxHiddenLevel to currentHiddenLevel. + */ + currentHiddenLevel--; + if (currentHiddenLevel < maxHiddenLevel) { + maxHiddenLevel = currentHiddenLevel; + } + } + /** + * 12.4. Decrease index by 1. + */ + index--; + } + /** + * 13. Set currentHiddenLevel and maxHiddenLevel to + * currentTargetHiddenSubtreeLevel. + */ + currentHiddenLevel = currentTargetHiddenSubtreeLevel; + maxHiddenLevel = currentTargetHiddenSubtreeLevel; + /** + * 14. Set index to currentTargetIndex + 1. + * 15. While index is less than path’s size: + */ + index = currentTargetIndex + 1; + while (index < path.length) { + /** + * 15.1. If path[index]'s slot-in-closed-tree is true, then increase + * currentHiddenLevel by 1. + * 15.2. If currentHiddenLevel is less than or equal to maxHiddenLevel, + * then append path[index]'s invocation target to composedPath. + */ + if (path[index].slotInClosedTree) { + currentHiddenLevel++; + } + if (currentHiddenLevel <= maxHiddenLevel) { + composedPath.push(path[index].invocationTarget); + } + /** + * 15.3. If path[index]'s root-of-closed-tree is true, then: + */ + if (path[index].rootOfClosedTree) { + /** + * 15.3.1. Decrease currentHiddenLevel by 1. + * 15.3.2. If currentHiddenLevel is less than maxHiddenLevel, then set + * maxHiddenLevel to currentHiddenLevel. + */ + currentHiddenLevel--; + if (currentHiddenLevel < maxHiddenLevel) { + maxHiddenLevel = currentHiddenLevel; + } + } + /** + * 15.4. Increase index by 1. + */ + index++; + } + /** + * 16. Return composedPath. + */ + return composedPath; + }; + Object.defineProperty(EventImpl.prototype, "eventPhase", { + /** @inheritdoc */ + get: function () { return this._eventPhase; }, + enumerable: true, + configurable: true + }); + /** @inheritdoc */ + EventImpl.prototype.stopPropagation = function () { this._stopPropagationFlag = true; }; + Object.defineProperty(EventImpl.prototype, "cancelBubble", { + /** @inheritdoc */ + get: function () { return this._stopPropagationFlag; }, + set: function (value) { if (value) + this.stopPropagation(); }, + enumerable: true, + configurable: true + }); + /** @inheritdoc */ + EventImpl.prototype.stopImmediatePropagation = function () { + this._stopPropagationFlag = true; + this._stopImmediatePropagationFlag = true; + }; + Object.defineProperty(EventImpl.prototype, "bubbles", { + /** @inheritdoc */ + get: function () { return this._bubbles; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventImpl.prototype, "cancelable", { + /** @inheritdoc */ + get: function () { return this._cancelable; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventImpl.prototype, "returnValue", { + /** @inheritdoc */ + get: function () { return !this._canceledFlag; }, + set: function (value) { + if (!value) { + algorithm_1.event_setTheCanceledFlag(this); + } + }, + enumerable: true, + configurable: true + }); + /** @inheritdoc */ + EventImpl.prototype.preventDefault = function () { + algorithm_1.event_setTheCanceledFlag(this); + }; + Object.defineProperty(EventImpl.prototype, "defaultPrevented", { + /** @inheritdoc */ + get: function () { return this._canceledFlag; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventImpl.prototype, "composed", { + /** @inheritdoc */ + get: function () { return this._composedFlag; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventImpl.prototype, "isTrusted", { + /** @inheritdoc */ + get: function () { return this._isTrusted; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventImpl.prototype, "timeStamp", { + /** @inheritdoc */ + get: function () { return this._timeStamp; }, + enumerable: true, + configurable: true + }); + /** @inheritdoc */ + EventImpl.prototype.initEvent = function (type, bubbles, cancelable) { + if (bubbles === void 0) { bubbles = false; } + if (cancelable === void 0) { cancelable = false; } + /** + * 1. If the context object’s dispatch flag is set, then return. + */ + if (this._dispatchFlag) + return; + /** + * 2. Initialize the context object with type, bubbles, and cancelable. + */ + algorithm_1.event_initialize(this, type, bubbles, cancelable); + }; + EventImpl.NONE = 0; + EventImpl.CAPTURING_PHASE = 1; + EventImpl.AT_TARGET = 2; + EventImpl.BUBBLING_PHASE = 3; + return EventImpl; +}()); +exports.EventImpl = EventImpl; +/** + * Define constants on prototype. + */ +WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "NONE", 0); +WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "CAPTURING_PHASE", 1); +WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "AT_TARGET", 2); +WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "BUBBLING_PHASE", 3); +//# sourceMappingURL=EventImpl.js.map + +/***/ }), +/* 428 */, +/* 429 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var algorithm_1 = __webpack_require__(163); +/** + * Represents a mixin that allows nodes to become the contents of + * a element. This mixin is implemented by {@link Element} and + * {@link Text}. + */ +var SlotableImpl = /** @class */ (function () { + function SlotableImpl() { + } + Object.defineProperty(SlotableImpl.prototype, "_name", { + get: function () { return this.__name || ''; }, + set: function (val) { this.__name = val; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SlotableImpl.prototype, "_assignedSlot", { + get: function () { return this.__assignedSlot || null; }, + set: function (val) { this.__assignedSlot = val; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SlotableImpl.prototype, "assignedSlot", { + /** @inheritdoc */ + get: function () { + return algorithm_1.shadowTree_findASlot(this, true); + }, + enumerable: true, + configurable: true + }); + return SlotableImpl; +}()); +exports.SlotableImpl = SlotableImpl; +//# sourceMappingURL=SlotableImpl.js.map + +/***/ }), +/* 430 */, +/* 431 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const os = __importStar(__webpack_require__(87)); +const utils_1 = __webpack_require__(82); +/** + * Commands + * + * Command Format: + * ::name key=value,key=value::message + * + * Examples: + * ::warning::This is the message + * ::set-env name=MY_VAR::some value + */ +function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); +} +exports.issueCommand = issueCommand; +function issue(name, message = '') { + issueCommand(name, {}, message); +} +exports.issue = issue; +const CMD_STRING = '::'; +class Command { + constructor(command, properties, message) { + if (!command) { + command = 'missing.command'; + } + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += ' '; + let first = true; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) { + first = false; + } + else { + cmdStr += ','; + } + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; + } +} +function escapeData(s) { + return utils_1.toCommandValue(s) + .replace(/%/g, '%25') + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A'); +} +function escapeProperty(s) { + return utils_1.toCommandValue(s) + .replace(/%/g, '%25') + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A') + .replace(/:/g, '%3A') + .replace(/,/g, '%2C'); +} +//# sourceMappingURL=command.js.map + +/***/ }), +/* 432 */, +/* 433 */, +/* 434 */, +/* 435 */, +/* 436 */, +/* 437 */, +/* 438 */, +/* 439 */, +/* 440 */, +/* 441 */, +/* 442 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Determines if the given string is valid for a `"Name"` construct. + * + * @param name - name string to test + */ +function xml_isName(name) { + for (var i = 0; i < name.length; i++) { + var n = name.charCodeAt(i); + // NameStartChar + if ((n >= 97 && n <= 122) || // [a-z] + (n >= 65 && n <= 90) || // [A-Z] + n === 58 || n === 95 || // ':' or '_' + (n >= 0xC0 && n <= 0xD6) || + (n >= 0xD8 && n <= 0xF6) || + (n >= 0xF8 && n <= 0x2FF) || + (n >= 0x370 && n <= 0x37D) || + (n >= 0x37F && n <= 0x1FFF) || + (n >= 0x200C && n <= 0x200D) || + (n >= 0x2070 && n <= 0x218F) || + (n >= 0x2C00 && n <= 0x2FEF) || + (n >= 0x3001 && n <= 0xD7FF) || + (n >= 0xF900 && n <= 0xFDCF) || + (n >= 0xFDF0 && n <= 0xFFFD)) { + continue; + } + else if (i !== 0 && + (n === 45 || n === 46 || // '-' or '.' + (n >= 48 && n <= 57) || // [0-9] + (n === 0xB7) || + (n >= 0x0300 && n <= 0x036F) || + (n >= 0x203F && n <= 0x2040))) { + continue; + } + if (n >= 0xD800 && n <= 0xDBFF && i < name.length - 1) { + var n2 = name.charCodeAt(i + 1); + if (n2 >= 0xDC00 && n2 <= 0xDFFF) { + n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000; + i++; + if (n >= 0x10000 && n <= 0xEFFFF) { + continue; + } + } + } + return false; + } + return true; +} +exports.xml_isName = xml_isName; +/** + * Determines if the given string is valid for a `"QName"` construct. + * + * @param name - name string to test + */ +function xml_isQName(name) { + var colonFound = false; + for (var i = 0; i < name.length; i++) { + var n = name.charCodeAt(i); + // NameStartChar + if ((n >= 97 && n <= 122) || // [a-z] + (n >= 65 && n <= 90) || // [A-Z] + n === 95 || // '_' + (n >= 0xC0 && n <= 0xD6) || + (n >= 0xD8 && n <= 0xF6) || + (n >= 0xF8 && n <= 0x2FF) || + (n >= 0x370 && n <= 0x37D) || + (n >= 0x37F && n <= 0x1FFF) || + (n >= 0x200C && n <= 0x200D) || + (n >= 0x2070 && n <= 0x218F) || + (n >= 0x2C00 && n <= 0x2FEF) || + (n >= 0x3001 && n <= 0xD7FF) || + (n >= 0xF900 && n <= 0xFDCF) || + (n >= 0xFDF0 && n <= 0xFFFD)) { + continue; + } + else if (i !== 0 && + (n === 45 || n === 46 || // '-' or '.' + (n >= 48 && n <= 57) || // [0-9] + (n === 0xB7) || + (n >= 0x0300 && n <= 0x036F) || + (n >= 0x203F && n <= 0x2040))) { + continue; + } + else if (i !== 0 && n === 58) { // : + if (colonFound) + return false; // multiple colons in qname + if (i === name.length - 1) + return false; // colon at the end of qname + colonFound = true; + continue; + } + if (n >= 0xD800 && n <= 0xDBFF && i < name.length - 1) { + var n2 = name.charCodeAt(i + 1); + if (n2 >= 0xDC00 && n2 <= 0xDFFF) { + n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000; + i++; + if (n >= 0x10000 && n <= 0xEFFFF) { + continue; + } + } + } + return false; + } + return true; +} +exports.xml_isQName = xml_isQName; +/** + * Determines if the given string contains legal characters. + * + * @param chars - sequence of characters to test + */ +function xml_isLegalChar(chars) { + for (var i = 0; i < chars.length; i++) { + var n = chars.charCodeAt(i); + // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] + if (n === 0x9 || n === 0xA || n === 0xD || + (n >= 0x20 && n <= 0xD7FF) || + (n >= 0xE000 && n <= 0xFFFD)) { + continue; + } + if (n >= 0xD800 && n <= 0xDBFF && i < chars.length - 1) { + var n2 = chars.charCodeAt(i + 1); + if (n2 >= 0xDC00 && n2 <= 0xDFFF) { + n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000; + i++; + if (n >= 0x10000 && n <= 0x10FFFF) { + continue; + } + } + } + return false; + } + return true; +} +exports.xml_isLegalChar = xml_isLegalChar; +/** + * Determines if the given string contains legal characters for a public + * identifier. + * + * @param chars - sequence of characters to test + */ +function xml_isPubidChar(chars) { + for (var i = 0; i < chars.length; i++) { + // PubId chars are all in the ASCII range, no need to check surrogates + var n = chars.charCodeAt(i); + // #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] + if ((n >= 97 && n <= 122) || // [a-z] + (n >= 65 && n <= 90) || // [A-Z] + (n >= 39 && n <= 59) || // ['()*+,-./] | [0-9] | [:;] + n === 0x20 || n === 0xD || n === 0xA || // #x20 | #xD | #xA + (n >= 35 && n <= 37) || // [#$%] + n === 33 || // ! + n === 61 || n === 63 || n === 64 || n === 95) { // [=?@_] + continue; + } + else { + return false; + } + } + return true; +} +exports.xml_isPubidChar = xml_isPubidChar; +//# sourceMappingURL=XMLAlgorithm.js.map + +/***/ }), +/* 443 */, +/* 444 */, +/* 445 */, +/* 446 */, +/* 447 */, +/* 448 */, +/* 449 */, +/* 450 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +module.exports = new Type('tag:yaml.org,2002:str', { + kind: 'scalar', + construct: function (data) { return data !== null ? data : ''; } +}); + + +/***/ }), +/* 451 */, +/* 452 */, +/* 453 */, +/* 454 */, +/* 455 */, +/* 456 */, +/* 457 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +/*eslint-disable max-len,no-use-before-define*/ + +var common = __webpack_require__(740); +var YAMLException = __webpack_require__(556); +var Mark = __webpack_require__(93); +var DEFAULT_SAFE_SCHEMA = __webpack_require__(723); +var DEFAULT_FULL_SCHEMA = __webpack_require__(910); + + +var _hasOwnProperty = Object.prototype.hasOwnProperty; + + +var CONTEXT_FLOW_IN = 1; +var CONTEXT_FLOW_OUT = 2; +var CONTEXT_BLOCK_IN = 3; +var CONTEXT_BLOCK_OUT = 4; + + +var CHOMPING_CLIP = 1; +var CHOMPING_STRIP = 2; +var CHOMPING_KEEP = 3; + + +var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; +var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; +var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; +var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; + + +function _class(obj) { return Object.prototype.toString.call(obj); } + +function is_EOL(c) { + return (c === 0x0A/* LF */) || (c === 0x0D/* CR */); +} + +function is_WHITE_SPACE(c) { + return (c === 0x09/* Tab */) || (c === 0x20/* Space */); +} + +function is_WS_OR_EOL(c) { + return (c === 0x09/* Tab */) || + (c === 0x20/* Space */) || + (c === 0x0A/* LF */) || + (c === 0x0D/* CR */); +} + +function is_FLOW_INDICATOR(c) { + return c === 0x2C/* , */ || + c === 0x5B/* [ */ || + c === 0x5D/* ] */ || + c === 0x7B/* { */ || + c === 0x7D/* } */; +} + +function fromHexCode(c) { + var lc; + + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } + + /*eslint-disable no-bitwise*/ + lc = c | 0x20; + + if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) { + return lc - 0x61 + 10; + } + + return -1; +} + +function escapedHexLen(c) { + if (c === 0x78/* x */) { return 2; } + if (c === 0x75/* u */) { return 4; } + if (c === 0x55/* U */) { return 8; } + return 0; +} + +function fromDecimalCode(c) { + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } + + return -1; +} + +function simpleEscapeSequence(c) { + /* eslint-disable indent */ + return (c === 0x30/* 0 */) ? '\x00' : + (c === 0x61/* a */) ? '\x07' : + (c === 0x62/* b */) ? '\x08' : + (c === 0x74/* t */) ? '\x09' : + (c === 0x09/* Tab */) ? '\x09' : + (c === 0x6E/* n */) ? '\x0A' : + (c === 0x76/* v */) ? '\x0B' : + (c === 0x66/* f */) ? '\x0C' : + (c === 0x72/* r */) ? '\x0D' : + (c === 0x65/* e */) ? '\x1B' : + (c === 0x20/* Space */) ? ' ' : + (c === 0x22/* " */) ? '\x22' : + (c === 0x2F/* / */) ? '/' : + (c === 0x5C/* \ */) ? '\x5C' : + (c === 0x4E/* N */) ? '\x85' : + (c === 0x5F/* _ */) ? '\xA0' : + (c === 0x4C/* L */) ? '\u2028' : + (c === 0x50/* P */) ? '\u2029' : ''; +} + +function charFromCodepoint(c) { + if (c <= 0xFFFF) { + return String.fromCharCode(c); + } + // Encode UTF-16 surrogate pair + // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF + return String.fromCharCode( + ((c - 0x010000) >> 10) + 0xD800, + ((c - 0x010000) & 0x03FF) + 0xDC00 + ); +} + +var simpleEscapeCheck = new Array(256); // integer, for fast access +var simpleEscapeMap = new Array(256); +for (var i = 0; i < 256; i++) { + simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; + simpleEscapeMap[i] = simpleEscapeSequence(i); +} + + +function State(input, options) { + this.input = input; + + this.filename = options['filename'] || null; + this.schema = options['schema'] || DEFAULT_FULL_SCHEMA; + this.onWarning = options['onWarning'] || null; + this.legacy = options['legacy'] || false; + this.json = options['json'] || false; + this.listener = options['listener'] || null; + + this.implicitTypes = this.schema.compiledImplicit; + this.typeMap = this.schema.compiledTypeMap; + + this.length = input.length; + this.position = 0; + this.line = 0; + this.lineStart = 0; + this.lineIndent = 0; + + this.documents = []; + + /* + this.version; + this.checkLineBreaks; + this.tagMap; + this.anchorMap; + this.tag; + this.anchor; + this.kind; + this.result;*/ + +} + + +function generateError(state, message) { + return new YAMLException( + message, + new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart))); +} + +function throwError(state, message) { + throw generateError(state, message); +} + +function throwWarning(state, message) { + if (state.onWarning) { + state.onWarning.call(null, generateError(state, message)); + } +} + + +var directiveHandlers = { + + YAML: function handleYamlDirective(state, name, args) { + + var match, major, minor; + + if (state.version !== null) { + throwError(state, 'duplication of %YAML directive'); + } + + if (args.length !== 1) { + throwError(state, 'YAML directive accepts exactly one argument'); + } + + match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); + + if (match === null) { + throwError(state, 'ill-formed argument of the YAML directive'); + } + + major = parseInt(match[1], 10); + minor = parseInt(match[2], 10); + + if (major !== 1) { + throwError(state, 'unacceptable YAML version of the document'); + } + + state.version = args[0]; + state.checkLineBreaks = (minor < 2); + + if (minor !== 1 && minor !== 2) { + throwWarning(state, 'unsupported YAML version of the document'); + } + }, + + TAG: function handleTagDirective(state, name, args) { + + var handle, prefix; + + if (args.length !== 2) { + throwError(state, 'TAG directive accepts exactly two arguments'); + } + + handle = args[0]; + prefix = args[1]; + + if (!PATTERN_TAG_HANDLE.test(handle)) { + throwError(state, 'ill-formed tag handle (first argument) of the TAG directive'); + } + + if (_hasOwnProperty.call(state.tagMap, handle)) { + throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } + + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive'); + } + + state.tagMap[handle] = prefix; + } +}; + + +function captureSegment(state, start, end, checkJson) { + var _position, _length, _character, _result; + + if (start < end) { + _result = state.input.slice(start, end); + + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_character === 0x09 || + (0x20 <= _character && _character <= 0x10FFFF))) { + throwError(state, 'expected valid JSON character'); + } + } + } else if (PATTERN_NON_PRINTABLE.test(_result)) { + throwError(state, 'the stream contains non-printable characters'); + } + + state.result += _result; + } +} + +function mergeMappings(state, destination, source, overridableKeys) { + var sourceKeys, key, index, quantity; + + if (!common.isObject(source)) { + throwError(state, 'cannot merge mappings; the provided source object is unacceptable'); + } + + sourceKeys = Object.keys(source); + + for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { + key = sourceKeys[index]; + + if (!_hasOwnProperty.call(destination, key)) { + destination[key] = source[key]; + overridableKeys[key] = true; + } + } +} + +function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) { + var index, quantity; + + // The output is a plain object here, so keys can only be strings. + // We need to convert keyNode to a string, but doing so can hang the process + // (deeply nested arrays that explode exponentially using aliases). + if (Array.isArray(keyNode)) { + keyNode = Array.prototype.slice.call(keyNode); + + for (index = 0, quantity = keyNode.length; index < quantity; index += 1) { + if (Array.isArray(keyNode[index])) { + throwError(state, 'nested arrays are not supported inside keys'); + } + + if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') { + keyNode[index] = '[object Object]'; + } + } + } + + // Avoid code execution in load() via toString property + // (still use its own toString for arrays, timestamps, + // and whatever user schema extensions happen to have @@toStringTag) + if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') { + keyNode = '[object Object]'; + } + + + keyNode = String(keyNode); + + if (_result === null) { + _result = {}; + } + + if (keyTag === 'tag:yaml.org,2002:merge') { + if (Array.isArray(valueNode)) { + for (index = 0, quantity = valueNode.length; index < quantity; index += 1) { + mergeMappings(state, _result, valueNode[index], overridableKeys); + } + } else { + mergeMappings(state, _result, valueNode, overridableKeys); + } + } else { + if (!state.json && + !_hasOwnProperty.call(overridableKeys, keyNode) && + _hasOwnProperty.call(_result, keyNode)) { + state.line = startLine || state.line; + state.position = startPos || state.position; + throwError(state, 'duplicated mapping key'); + } + _result[keyNode] = valueNode; + delete overridableKeys[keyNode]; + } + + return _result; +} + +function readLineBreak(state) { + var ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x0A/* LF */) { + state.position++; + } else if (ch === 0x0D/* CR */) { + state.position++; + if (state.input.charCodeAt(state.position) === 0x0A/* LF */) { + state.position++; + } + } else { + throwError(state, 'a line break is expected'); + } + + state.line += 1; + state.lineStart = state.position; +} + +function skipSeparationSpace(state, allowComments, checkIndent) { + var lineBreaks = 0, + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (allowComments && ch === 0x23/* # */) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0); + } + + if (is_EOL(ch)) { + readLineBreak(state); + + ch = state.input.charCodeAt(state.position); + lineBreaks++; + state.lineIndent = 0; + + while (ch === 0x20/* Space */) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + } else { + break; + } + } + + if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) { + throwWarning(state, 'deficient indentation'); + } + + return lineBreaks; +} + +function testDocumentSeparator(state) { + var _position = state.position, + ch; + + ch = state.input.charCodeAt(_position); + + // Condition state.position === state.lineStart is tested + // in parent on each call, for efficiency. No needs to test here again. + if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) && + ch === state.input.charCodeAt(_position + 1) && + ch === state.input.charCodeAt(_position + 2)) { + + _position += 3; + + ch = state.input.charCodeAt(_position); + + if (ch === 0 || is_WS_OR_EOL(ch)) { + return true; + } + } + + return false; +} + +function writeFoldedLines(state, count) { + if (count === 1) { + state.result += ' '; + } else if (count > 1) { + state.result += common.repeat('\n', count - 1); + } +} + + +function readPlainScalar(state, nodeIndent, withinFlowCollection) { + var preceding, + following, + captureStart, + captureEnd, + hasPendingContent, + _line, + _lineStart, + _lineIndent, + _kind = state.kind, + _result = state.result, + ch; + + ch = state.input.charCodeAt(state.position); + + if (is_WS_OR_EOL(ch) || + is_FLOW_INDICATOR(ch) || + ch === 0x23/* # */ || + ch === 0x26/* & */ || + ch === 0x2A/* * */ || + ch === 0x21/* ! */ || + ch === 0x7C/* | */ || + ch === 0x3E/* > */ || + ch === 0x27/* ' */ || + ch === 0x22/* " */ || + ch === 0x25/* % */ || + ch === 0x40/* @ */ || + ch === 0x60/* ` */) { + return false; + } + + if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + return false; + } + } + + state.kind = 'scalar'; + state.result = ''; + captureStart = captureEnd = state.position; + hasPendingContent = false; + + while (ch !== 0) { + if (ch === 0x3A/* : */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + break; + } + + } else if (ch === 0x23/* # */) { + preceding = state.input.charCodeAt(state.position - 1); + + if (is_WS_OR_EOL(preceding)) { + break; + } + + } else if ((state.position === state.lineStart && testDocumentSeparator(state)) || + withinFlowCollection && is_FLOW_INDICATOR(ch)) { + break; + + } else if (is_EOL(ch)) { + _line = state.line; + _lineStart = state.lineStart; + _lineIndent = state.lineIndent; + skipSeparationSpace(state, false, -1); + + if (state.lineIndent >= nodeIndent) { + hasPendingContent = true; + ch = state.input.charCodeAt(state.position); + continue; + } else { + state.position = captureEnd; + state.line = _line; + state.lineStart = _lineStart; + state.lineIndent = _lineIndent; + break; + } + } + + if (hasPendingContent) { + captureSegment(state, captureStart, captureEnd, false); + writeFoldedLines(state, state.line - _line); + captureStart = captureEnd = state.position; + hasPendingContent = false; + } + + if (!is_WHITE_SPACE(ch)) { + captureEnd = state.position + 1; + } + + ch = state.input.charCodeAt(++state.position); + } + + captureSegment(state, captureStart, captureEnd, false); + + if (state.result) { + return true; + } + + state.kind = _kind; + state.result = _result; + return false; +} + +function readSingleQuotedScalar(state, nodeIndent) { + var ch, + captureStart, captureEnd; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x27/* ' */) { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x27/* ' */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x27/* ' */) { + captureStart = state.position; + state.position++; + captureEnd = state.position; + } else { + return true; + } + + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a single quoted scalar'); + + } else { + state.position++; + captureEnd = state.position; + } + } + + throwError(state, 'unexpected end of the stream within a single quoted scalar'); +} + +function readDoubleQuotedScalar(state, nodeIndent) { + var captureStart, + captureEnd, + hexLength, + hexResult, + tmp, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x22/* " */) { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x22/* " */) { + captureSegment(state, captureStart, state.position, true); + state.position++; + return true; + + } else if (ch === 0x5C/* \ */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + + if (is_EOL(ch)) { + skipSeparationSpace(state, false, nodeIndent); + + // TODO: rework to inline fn with no type cast? + } else if (ch < 256 && simpleEscapeCheck[ch]) { + state.result += simpleEscapeMap[ch]; + state.position++; + + } else if ((tmp = escapedHexLen(ch)) > 0) { + hexLength = tmp; + hexResult = 0; + + for (; hexLength > 0; hexLength--) { + ch = state.input.charCodeAt(++state.position); + + if ((tmp = fromHexCode(ch)) >= 0) { + hexResult = (hexResult << 4) + tmp; + + } else { + throwError(state, 'expected hexadecimal character'); + } + } + + state.result += charFromCodepoint(hexResult); + + state.position++; + + } else { + throwError(state, 'unknown escape sequence'); + } + + captureStart = captureEnd = state.position; + + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a double quoted scalar'); + + } else { + state.position++; + captureEnd = state.position; + } + } + + throwError(state, 'unexpected end of the stream within a double quoted scalar'); +} + +function readFlowCollection(state, nodeIndent) { + var readNext = true, + _line, + _tag = state.tag, + _result, + _anchor = state.anchor, + following, + terminator, + isPair, + isExplicitPair, + isMapping, + overridableKeys = {}, + keyNode, + keyTag, + valueNode, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x5B/* [ */) { + terminator = 0x5D;/* ] */ + isMapping = false; + _result = []; + } else if (ch === 0x7B/* { */) { + terminator = 0x7D;/* } */ + isMapping = true; + _result = {}; + } else { + return false; + } + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(++state.position); + + while (ch !== 0) { + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if (ch === terminator) { + state.position++; + state.tag = _tag; + state.anchor = _anchor; + state.kind = isMapping ? 'mapping' : 'sequence'; + state.result = _result; + return true; + } else if (!readNext) { + throwError(state, 'missed comma between flow collection entries'); + } + + keyTag = keyNode = valueNode = null; + isPair = isExplicitPair = false; + + if (ch === 0x3F/* ? */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following)) { + isPair = isExplicitPair = true; + state.position++; + skipSeparationSpace(state, true, nodeIndent); + } + } + + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + keyTag = state.tag; + keyNode = state.result; + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) { + isPair = true; + ch = state.input.charCodeAt(++state.position); + skipSeparationSpace(state, true, nodeIndent); + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state.result; + } + + if (isMapping) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode); + } else if (isPair) { + _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode)); + } else { + _result.push(keyNode); + } + + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x2C/* , */) { + readNext = true; + ch = state.input.charCodeAt(++state.position); + } else { + readNext = false; + } + } + + throwError(state, 'unexpected end of the stream within a flow collection'); +} + +function readBlockScalar(state, nodeIndent) { + var captureStart, + folding, + chomping = CHOMPING_CLIP, + didReadContent = false, + detectedIndent = false, + textIndent = nodeIndent, + emptyLines = 0, + atMoreIndented = false, + tmp, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x7C/* | */) { + folding = false; + } else if (ch === 0x3E/* > */) { + folding = true; + } else { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + + while (ch !== 0) { + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x2B/* + */ || ch === 0x2D/* - */) { + if (CHOMPING_CLIP === chomping) { + chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP; + } else { + throwError(state, 'repeat of a chomping mode identifier'); + } + + } else if ((tmp = fromDecimalCode(ch)) >= 0) { + if (tmp === 0) { + throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one'); + } else if (!detectedIndent) { + textIndent = nodeIndent + tmp - 1; + detectedIndent = true; + } else { + throwError(state, 'repeat of an indentation width identifier'); + } + + } else { + break; + } + } + + if (is_WHITE_SPACE(ch)) { + do { ch = state.input.charCodeAt(++state.position); } + while (is_WHITE_SPACE(ch)); + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (!is_EOL(ch) && (ch !== 0)); + } + } + + while (ch !== 0) { + readLineBreak(state); + state.lineIndent = 0; + + ch = state.input.charCodeAt(state.position); + + while ((!detectedIndent || state.lineIndent < textIndent) && + (ch === 0x20/* Space */)) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + + if (!detectedIndent && state.lineIndent > textIndent) { + textIndent = state.lineIndent; + } + + if (is_EOL(ch)) { + emptyLines++; + continue; + } + + // End of the scalar. + if (state.lineIndent < textIndent) { + + // Perform the chomping. + if (chomping === CHOMPING_KEEP) { + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } else if (chomping === CHOMPING_CLIP) { + if (didReadContent) { // i.e. only if the scalar is not empty. + state.result += '\n'; + } + } + + // Break this `while` cycle and go to the funciton's epilogue. + break; + } + + // Folded style: use fancy rules to handle line breaks. + if (folding) { + + // Lines starting with white space characters (more-indented lines) are not folded. + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + // except for the first content line (cf. Example 8.1) + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + + // End of more-indented block. + } else if (atMoreIndented) { + atMoreIndented = false; + state.result += common.repeat('\n', emptyLines + 1); + + // Just one line break - perceive as the same line. + } else if (emptyLines === 0) { + if (didReadContent) { // i.e. only if we have already read some scalar content. + state.result += ' '; + } + + // Several line breaks - perceive as different lines. + } else { + state.result += common.repeat('\n', emptyLines); + } + + // Literal style: just add exact number of line breaks between content lines. + } else { + // Keep all line breaks except the header line break. + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } + + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state.position; + + while (!is_EOL(ch) && (ch !== 0)) { + ch = state.input.charCodeAt(++state.position); + } + + captureSegment(state, captureStart, state.position, false); + } + + return true; +} + +function readBlockSequence(state, nodeIndent) { + var _line, + _tag = state.tag, + _anchor = state.anchor, + _result = [], + following, + detected = false, + ch; + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + + if (ch !== 0x2D/* - */) { + break; + } + + following = state.input.charCodeAt(state.position + 1); + + if (!is_WS_OR_EOL(following)) { + break; + } + + detected = true; + state.position++; + + if (skipSeparationSpace(state, true, -1)) { + if (state.lineIndent <= nodeIndent) { + _result.push(null); + ch = state.input.charCodeAt(state.position); + continue; + } + } + + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state.result); + skipSeparationSpace(state, true, -1); + + ch = state.input.charCodeAt(state.position); + + if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { + throwError(state, 'bad indentation of a sequence entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'sequence'; + state.result = _result; + return true; + } + return false; +} + +function readBlockMapping(state, nodeIndent, flowIndent) { + var following, + allowCompact, + _line, + _pos, + _tag = state.tag, + _anchor = state.anchor, + _result = {}, + overridableKeys = {}, + keyTag = null, + keyNode = null, + valueNode = null, + atExplicitKey = false, + detected = false, + ch; + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + following = state.input.charCodeAt(state.position + 1); + _line = state.line; // Save the current line. + _pos = state.position; + + // + // Explicit notation case. There are two separate blocks: + // first for the key (denoted by "?") and second for the value (denoted by ":") + // + if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) { + + if (ch === 0x3F/* ? */) { + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + keyTag = keyNode = valueNode = null; + } + + detected = true; + atExplicitKey = true; + allowCompact = true; + + } else if (atExplicitKey) { + // i.e. 0x3A/* : */ === character after the explicit key. + atExplicitKey = false; + allowCompact = true; + + } else { + throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line'); + } + + state.position += 1; + ch = following; + + // + // Implicit notation case. Flow-style node as the key first, then ":", and the value. + // + } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + + if (state.line === _line) { + ch = state.input.charCodeAt(state.position); + + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (ch === 0x3A/* : */) { + ch = state.input.charCodeAt(++state.position); + + if (!is_WS_OR_EOL(ch)) { + throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping'); + } + + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + keyTag = keyNode = valueNode = null; + } + + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state.tag; + keyNode = state.result; + + } else if (detected) { + throwError(state, 'can not read an implicit mapping pair; a colon is missed'); + + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + + } else if (detected) { + throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key'); + + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + + } else { + break; // Reading is done. Go to the epilogue. + } + + // + // Common reading code for both explicit and implicit notations. + // + if (state.line === _line || state.lineIndent > nodeIndent) { + if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state.result; + } else { + valueNode = state.result; + } + } + + if (!atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos); + keyTag = keyNode = valueNode = null; + } + + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + } + + if (state.lineIndent > nodeIndent && (ch !== 0)) { + throwError(state, 'bad indentation of a mapping entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + + // + // Epilogue. + // + + // Special case: last mapping's node contains only the key in explicit notation. + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + } + + // Expose the resulting mapping. + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'mapping'; + state.result = _result; + } + + return detected; +} + +function readTagProperty(state) { + var _position, + isVerbatim = false, + isNamed = false, + tagHandle, + tagName, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x21/* ! */) return false; + + if (state.tag !== null) { + throwError(state, 'duplication of a tag property'); + } + + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x3C/* < */) { + isVerbatim = true; + ch = state.input.charCodeAt(++state.position); + + } else if (ch === 0x21/* ! */) { + isNamed = true; + tagHandle = '!!'; + ch = state.input.charCodeAt(++state.position); + + } else { + tagHandle = '!'; + } + + _position = state.position; + + if (isVerbatim) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && ch !== 0x3E/* > */); + + if (state.position < state.length) { + tagName = state.input.slice(_position, state.position); + ch = state.input.charCodeAt(++state.position); + } else { + throwError(state, 'unexpected end of the stream within a verbatim tag'); + } + } else { + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + + if (ch === 0x21/* ! */) { + if (!isNamed) { + tagHandle = state.input.slice(_position - 1, state.position + 1); + + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state, 'named tag handle cannot contain such characters'); + } + + isNamed = true; + _position = state.position + 1; + } else { + throwError(state, 'tag suffix cannot contain exclamation marks'); + } + } + + ch = state.input.charCodeAt(++state.position); + } + + tagName = state.input.slice(_position, state.position); + + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state, 'tag suffix cannot contain flow indicator characters'); + } + } + + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state, 'tag name cannot contain such characters: ' + tagName); + } + + if (isVerbatim) { + state.tag = tagName; + + } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) { + state.tag = state.tagMap[tagHandle] + tagName; + + } else if (tagHandle === '!') { + state.tag = '!' + tagName; + + } else if (tagHandle === '!!') { + state.tag = 'tag:yaml.org,2002:' + tagName; + + } else { + throwError(state, 'undeclared tag handle "' + tagHandle + '"'); + } + + return true; +} + +function readAnchorProperty(state) { + var _position, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x26/* & */) return false; + + if (state.anchor !== null) { + throwError(state, 'duplication of an anchor property'); + } + + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (state.position === _position) { + throwError(state, 'name of an anchor node must contain at least one character'); + } + + state.anchor = state.input.slice(_position, state.position); + return true; +} + +function readAlias(state) { + var _position, alias, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x2A/* * */) return false; + + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (state.position === _position) { + throwError(state, 'name of an alias node must contain at least one character'); + } + + alias = state.input.slice(_position, state.position); + + if (!state.anchorMap.hasOwnProperty(alias)) { + throwError(state, 'unidentified alias "' + alias + '"'); + } + + state.result = state.anchorMap[alias]; + skipSeparationSpace(state, true, -1); + return true; +} + +function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, + allowBlockScalars, + allowBlockCollections, + indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } + + if (indentStatus === 1) { + while (readTagProperty(state) || readAnchorProperty(state)) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } else { + allowBlockCollections = false; + } + } + } + + if (allowBlockCollections) { + allowBlockCollections = atNewLine || allowCompact; + } + + if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { + if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { + flowIndent = parentIndent; + } else { + flowIndent = parentIndent + 1; + } + + blockIndent = state.position - state.lineStart; + + if (indentStatus === 1) { + if (allowBlockCollections && + (readBlockSequence(state, blockIndent) || + readBlockMapping(state, blockIndent, flowIndent)) || + readFlowCollection(state, flowIndent)) { + hasContent = true; + } else { + if ((allowBlockScalars && readBlockScalar(state, flowIndent)) || + readSingleQuotedScalar(state, flowIndent) || + readDoubleQuotedScalar(state, flowIndent)) { + hasContent = true; + + } else if (readAlias(state)) { + hasContent = true; + + if (state.tag !== null || state.anchor !== null) { + throwError(state, 'alias node should not have any properties'); + } + + } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; + + if (state.tag === null) { + state.tag = '?'; + } + } + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else if (indentStatus === 0) { + // Special case: block sequences are allowed to have same indentation level as the parent. + // http://www.yaml.org/spec/1.2/spec.html#id2799784 + hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); + } + } + + if (state.tag !== null && state.tag !== '!') { + if (state.tag === '?') { + // Implicit resolving is not allowed for non-scalar types, and '?' + // non-specific tag is only automatically assigned to plain scalars. + // + // We only need to check kind conformity in case user explicitly assigns '?' + // tag, for example like this: "! [0]" + // + if (state.result !== null && state.kind !== 'scalar') { + throwError(state, 'unacceptable node kind for ! tag; it should be "scalar", not "' + state.kind + '"'); + } + + for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type = state.implicitTypes[typeIndex]; + + if (type.resolve(state.result)) { // `state.result` updated in resolver if matched + state.result = type.construct(state.result); + state.tag = type.tag; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + break; + } + } + } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) { + type = state.typeMap[state.kind || 'fallback'][state.tag]; + + if (state.result !== null && type.kind !== state.kind) { + throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"'); + } + + if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched + throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag'); + } else { + state.result = type.construct(state.result); + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else { + throwError(state, 'unknown tag !<' + state.tag + '>'); + } + } + + if (state.listener !== null) { + state.listener('close', state); + } + return state.tag !== null || state.anchor !== null || hasContent; +} + +function readDocument(state) { + var documentStart = state.position, + _position, + directiveName, + directiveArgs, + hasDirectives = false, + ch; + + state.version = null; + state.checkLineBreaks = state.legacy; + state.tagMap = {}; + state.anchorMap = {}; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + skipSeparationSpace(state, true, -1); + + ch = state.input.charCodeAt(state.position); + + if (state.lineIndent > 0 || ch !== 0x25/* % */) { + break; + } + + hasDirectives = true; + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + directiveName = state.input.slice(_position, state.position); + directiveArgs = []; + + if (directiveName.length < 1) { + throwError(state, 'directive name must not be less than one character in length'); + } + + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && !is_EOL(ch)); + break; + } + + if (is_EOL(ch)) break; + + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + directiveArgs.push(state.input.slice(_position, state.position)); + } + + if (ch !== 0) readLineBreak(state); + + if (_hasOwnProperty.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state, directiveName, directiveArgs); + } else { + throwWarning(state, 'unknown document directive "' + directiveName + '"'); + } + } + + skipSeparationSpace(state, true, -1); + + if (state.lineIndent === 0 && + state.input.charCodeAt(state.position) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 1) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 2) === 0x2D/* - */) { + state.position += 3; + skipSeparationSpace(state, true, -1); + + } else if (hasDirectives) { + throwError(state, 'directives end mark is expected'); + } + + composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state, true, -1); + + if (state.checkLineBreaks && + PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { + throwWarning(state, 'non-ASCII line breaks are interpreted as content'); + } + + state.documents.push(state.result); + + if (state.position === state.lineStart && testDocumentSeparator(state)) { + + if (state.input.charCodeAt(state.position) === 0x2E/* . */) { + state.position += 3; + skipSeparationSpace(state, true, -1); + } + return; + } + + if (state.position < (state.length - 1)) { + throwError(state, 'end of the stream or a document separator is expected'); + } else { + return; + } +} + + +function loadDocuments(input, options) { + input = String(input); + options = options || {}; + + if (input.length !== 0) { + + // Add tailing `\n` if not exists + if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ && + input.charCodeAt(input.length - 1) !== 0x0D/* CR */) { + input += '\n'; + } + + // Strip BOM + if (input.charCodeAt(0) === 0xFEFF) { + input = input.slice(1); + } + } + + var state = new State(input, options); + + var nullpos = input.indexOf('\0'); + + if (nullpos !== -1) { + state.position = nullpos; + throwError(state, 'null byte is not allowed in input'); + } + + // Use 0 as string terminator. That significantly simplifies bounds check. + state.input += '\0'; + + while (state.input.charCodeAt(state.position) === 0x20/* Space */) { + state.lineIndent += 1; + state.position += 1; + } + + while (state.position < (state.length - 1)) { + readDocument(state); + } + + return state.documents; +} + + +function loadAll(input, iterator, options) { + if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') { + options = iterator; + iterator = null; + } + + var documents = loadDocuments(input, options); + + if (typeof iterator !== 'function') { + return documents; + } + + for (var index = 0, length = documents.length; index < length; index += 1) { + iterator(documents[index]); + } +} + + +function load(input, options) { + var documents = loadDocuments(input, options); + + if (documents.length === 0) { + /*eslint-disable no-undefined*/ + return undefined; + } else if (documents.length === 1) { + return documents[0]; + } + throw new YAMLException('expected a single document in the stream, but found more'); +} + + +function safeLoadAll(input, iterator, options) { + if (typeof iterator === 'object' && iterator !== null && typeof options === 'undefined') { + options = iterator; + iterator = null; + } + + return loadAll(input, iterator, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); +} + + +function safeLoad(input, options) { + return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); +} + + +module.exports.loadAll = loadAll; +module.exports.load = load; +module.exports.safeLoadAll = safeLoadAll; +module.exports.safeLoad = safeLoad; + + +/***/ }), +/* 458 */, +/* 459 */, +/* 460 */, +/* 461 */, +/* 462 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var interfaces_1 = __webpack_require__(970); +var LocalNameSet_1 = __webpack_require__(575); +var NamespacePrefixMap_1 = __webpack_require__(392); +var infra_1 = __webpack_require__(23); +var algorithm_1 = __webpack_require__(163); +/** + * Pre-serializes XML nodes. + */ +var BaseWriter = /** @class */ (function () { + /** + * Initializes a new instance of `BaseWriter`. + * + * @param builderOptions - XML builder options + */ + function BaseWriter(builderOptions) { + /** + * Gets the current depth of the XML tree. + */ + this.level = 0; + this._builderOptions = builderOptions; + } + /** + * Used by derived classes to serialize the XML declaration. + * + * @param version - a version number string + * @param encoding - encoding declaration + * @param standalone - standalone document declaration + */ + BaseWriter.prototype.declaration = function (version, encoding, standalone) { }; + /** + * Used by derived classes to serialize a DocType node. + * + * @param name - node name + * @param publicId - public identifier + * @param systemId - system identifier + */ + BaseWriter.prototype.docType = function (name, publicId, systemId) { }; + /** + * Used by derived classes to serialize a comment node. + * + * @param data - node data + */ + BaseWriter.prototype.comment = function (data) { }; + /** + * Used by derived classes to serialize a text node. + * + * @param data - node data + */ + BaseWriter.prototype.text = function (data) { }; + /** + * Used by derived classes to serialize a processing instruction node. + * + * @param target - instruction target + * @param data - node data + */ + BaseWriter.prototype.instruction = function (target, data) { }; + /** + * Used by derived classes to serialize a CData section node. + * + * @param data - node data + */ + BaseWriter.prototype.cdata = function (data) { }; + /** + * Used by derived classes to serialize the beginning of the opening tag of an + * element node. + * + * @param name - node name + */ + BaseWriter.prototype.openTagBegin = function (name) { }; + /** + * Used by derived classes to serialize the ending of the opening tag of an + * element node. + * + * @param name - node name + * @param selfClosing - whether the element node is self closing + * @param voidElement - whether the element node is a HTML void element + */ + BaseWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) { }; + /** + * Used by derived classes to serialize the closing tag of an element node. + * + * @param name - node name + */ + BaseWriter.prototype.closeTag = function (name) { }; + /** + * Used by derived classes to serialize attributes or namespace declarations. + * + * @param attributes - attribute array + */ + BaseWriter.prototype.attributes = function (attributes) { + var e_1, _a; + try { + for (var attributes_1 = __values(attributes), attributes_1_1 = attributes_1.next(); !attributes_1_1.done; attributes_1_1 = attributes_1.next()) { + var attr = attributes_1_1.value; + this.attribute(attr[1] === null ? attr[2] : attr[1] + ':' + attr[2], attr[3]); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (attributes_1_1 && !attributes_1_1.done && (_a = attributes_1.return)) _a.call(attributes_1); + } + finally { if (e_1) throw e_1.error; } + } + }; + /** + * Used by derived classes to serialize an attribute or namespace declaration. + * + * @param name - node name + * @param value - node value + */ + BaseWriter.prototype.attribute = function (name, value) { }; + /** + * Used by derived classes to perform any pre-processing steps before starting + * serializing an element node. + * + * @param name - node name + */ + BaseWriter.prototype.beginElement = function (name) { }; + /** + * Used by derived classes to perform any post-processing steps after + * completing serializing an element node. + * + * @param name - node name + */ + BaseWriter.prototype.endElement = function (name) { }; + /** + * Produces an XML serialization of the given node. The pre-serializer inserts + * namespace declarations where necessary and produces qualified names for + * nodes and attributes. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype.serializeNode = function (node, requireWellFormed, noDoubleEncoding) { + var hasNamespaces = (node._nodeDocument !== undefined && node._nodeDocument._hasNamespaces); + this.level = 0; + this.currentNode = node; + if (hasNamespaces) { + /** From: https://w3c.github.io/DOM-Parsing/#xml-serialization + * + * 1. Let namespace be a context namespace with value null. + * The context namespace tracks the XML serialization algorithm's current + * default namespace. The context namespace is changed when either an Element + * Node has a default namespace declaration, or the algorithm generates a + * default namespace declaration for the Element Node to match its own + * namespace. The algorithm assumes no namespace (null) to start. + * 2. Let prefix map be a new namespace prefix map. + * 3. Add the XML namespace with prefix value "xml" to prefix map. + * 4. Let prefix index be a generated namespace prefix index with value 1. + * The generated namespace prefix index is used to generate a new unique + * prefix value when no suitable existing namespace prefix is available to + * serialize a node's namespaceURI (or the namespaceURI of one of node's + * attributes). See the generate a prefix algorithm. + */ + var namespace = null; + var prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap(); + prefixMap.set("xml", infra_1.namespace.XML); + var prefixIndex = { value: 1 }; + /** + * 5. Return the result of running the XML serialization algorithm on node + * passing the context namespace namespace, namespace prefix map prefix map, + * generated namespace prefix index reference to prefix index, and the + * flag require well-formed. If an exception occurs during the execution + * of the algorithm, then catch that exception and throw an + * "InvalidStateError" DOMException. + */ + this._serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); + } + else { + this._serializeNode(node, requireWellFormed, noDoubleEncoding); + } + }; + /** + * Produces an XML serialization of a node. + * + * @param node - node to serialize + * @param namespace - context namespace + * @param prefixMap - namespace prefix map + * @param prefixIndex - generated namespace prefix index + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeNodeNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) { + this.currentNode = node; + switch (node.nodeType) { + case interfaces_1.NodeType.Element: + this._serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.Document: + this._serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.Comment: + this._serializeComment(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.Text: + this._serializeText(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.DocumentFragment: + this._serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.DocumentType: + this._serializeDocumentType(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.ProcessingInstruction: + this._serializeProcessingInstruction(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.CData: + this._serializeCData(node, requireWellFormed, noDoubleEncoding); + break; + default: + throw new Error("Unknown node type: " + node.nodeType); + } + }; + /** + * Produces an XML serialization of a node. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeNode = function (node, requireWellFormed, noDoubleEncoding) { + this.currentNode = node; + switch (node.nodeType) { + case interfaces_1.NodeType.Element: + this._serializeElement(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.Document: + this._serializeDocument(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.Comment: + this._serializeComment(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.Text: + this._serializeText(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.DocumentFragment: + this._serializeDocumentFragment(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.DocumentType: + this._serializeDocumentType(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.ProcessingInstruction: + this._serializeProcessingInstruction(node, requireWellFormed, noDoubleEncoding); + break; + case interfaces_1.NodeType.CData: + this._serializeCData(node, requireWellFormed, noDoubleEncoding); + break; + default: + throw new Error("Unknown node type: " + node.nodeType); + } + }; + /** + * Produces an XML serialization of an element node. + * + * @param node - node to serialize + * @param namespace - context namespace + * @param prefixMap - namespace prefix map + * @param prefixIndex - generated namespace prefix index + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeElementNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) { + var e_2, _a; + var attributes = []; + /** + * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node + * + * 1. If the require well-formed flag is set (its value is true), and this + * node's localName attribute contains the character ":" (U+003A COLON) or + * does not match the XML Name production, then throw an exception; the + * serialization of this node would not be a well-formed element. + */ + if (requireWellFormed && (node.localName.indexOf(":") !== -1 || + !algorithm_1.xml_isName(node.localName))) { + throw new Error("Node local name contains invalid characters (well-formed required)."); + } + /** + * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN). + * 3. Let qualified name be an empty string. + * 4. Let skip end tag be a boolean flag with value false. + * 5. Let ignore namespace definition attribute be a boolean flag with value + * false. + * 6. Given prefix map, copy a namespace prefix map and let map be the + * result. + * 7. Let local prefixes map be an empty map. The map has unique Node prefix + * strings as its keys, with corresponding namespaceURI Node values as the + * map's key values (in this map, the null namespace is represented by the + * empty string). + * + * _Note:_ This map is local to each element. It is used to ensure there + * are no conflicting prefixes should a new namespace prefix attribute need + * to be generated. It is also used to enable skipping of duplicate prefix + * definitions when writing an element's attributes: the map allows the + * algorithm to distinguish between a prefix in the namespace prefix map + * that might be locally-defined (to the current Element) and one that is + * not. + * 8. Let local default namespace be the result of recording the namespace + * information for node given map and local prefixes map. + * + * _Note:_ The above step will update map with any found namespace prefix + * definitions, add the found prefix definitions to the local prefixes map + * and return a local default namespace value defined by a default namespace + * attribute if one exists. Otherwise it returns null. + * 9. Let inherited ns be a copy of namespace. + * 10. Let ns be the value of node's namespaceURI attribute. + */ + var qualifiedName = ''; + var skipEndTag = false; + var ignoreNamespaceDefinitionAttribute = false; + var map = prefixMap.copy(); + var localPrefixesMap = {}; + var localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap); + var inheritedNS = namespace; + var ns = node.namespaceURI; + /** 11. If inherited ns is equal to ns, then: */ + if (inheritedNS === ns) { + /** + * 11.1. If local default namespace is not null, then set ignore + * namespace definition attribute to true. + */ + if (localDefaultNamespace !== null) { + ignoreNamespaceDefinitionAttribute = true; + } + /** + * 11.2. If ns is the XML namespace, then append to qualified name the + * concatenation of the string "xml:" and the value of node's localName. + * 11.3. Otherwise, append to qualified name the value of node's + * localName. The node's prefix if it exists, is dropped. + */ + if (ns === infra_1.namespace.XML) { + qualifiedName = 'xml:' + node.localName; + } + else { + qualifiedName = node.localName; + } + /** 11.4. Append the value of qualified name to markup. */ + this.beginElement(qualifiedName); + this.openTagBegin(qualifiedName); + } + else { + /** + * 12. Otherwise, inherited ns is not equal to ns (the node's own + * namespace is different from the context namespace of its parent). + * Run these sub-steps: + * + * 12.1. Let prefix be the value of node's prefix attribute. + * 12.2. Let candidate prefix be the result of retrieving a preferred + * prefix string prefix from map given namespace ns. The above may return + * null if no namespace key ns exists in map. + */ + var prefix = node.prefix; + /** + * We don't need to run "retrieving a preferred prefix string" algorithm if + * the element has no prefix and its namespace matches to the default + * namespace. + * See: https://github.com/web-platform-tests/wpt/pull/16703 + */ + var candidatePrefix = null; + if (prefix !== null || ns !== localDefaultNamespace) { + candidatePrefix = map.get(prefix, ns); + } + /** + * 12.3. If the value of prefix matches "xmlns", then run the following + * steps: + */ + if (prefix === "xmlns") { + /** + * 12.3.1. If the require well-formed flag is set, then throw an error. + * An Element with prefix "xmlns" will not legally round-trip in a + * conforming XML parser. + */ + if (requireWellFormed) { + throw new Error("An element cannot have the 'xmlns' prefix (well-formed required)."); + } + /** + * 12.3.2. Let candidate prefix be the value of prefix. + */ + candidatePrefix = prefix; + } + /** + * 12.4.Found a suitable namespace prefix: if candidate prefix is not + * null (a namespace prefix is defined which maps to ns), then: + */ + if (candidatePrefix !== null) { + /** + * The following may serialize a different prefix than the Element's + * existing prefix if it already had one. However, the retrieving a + * preferred prefix string algorithm already tried to match the + * existing prefix if possible. + * + * 12.4.1. Append to qualified name the concatenation of candidate + * prefix, ":" (U+003A COLON), and node's localName. There exists on + * this node or the node's ancestry a namespace prefix definition that + * defines the node's namespace. + * 12.4.2. If the local default namespace is not null (there exists a + * locally-defined default namespace declaration attribute) and its + * value is not the XML namespace, then let inherited ns get the value + * of local default namespace unless the local default namespace is the + * empty string in which case let it get null (the context namespace + * is changed to the declared default, rather than this node's own + * namespace). + * + * _Note:_ Any default namespace definitions or namespace prefixes that + * define the XML namespace are omitted when serializing this node's + * attributes. + */ + qualifiedName = candidatePrefix + ':' + node.localName; + if (localDefaultNamespace !== null && localDefaultNamespace !== infra_1.namespace.XML) { + inheritedNS = localDefaultNamespace || null; + } + /** + * 12.4.3. Append the value of qualified name to markup. + */ + this.beginElement(qualifiedName); + this.openTagBegin(qualifiedName); + /** 12.5. Otherwise, if prefix is not null, then: */ + } + else if (prefix !== null) { + /** + * _Note:_ By this step, there is no namespace or prefix mapping + * declaration in this node (or any parent node visited by this + * algorithm) that defines prefix otherwise the step labelled Found + * a suitable namespace prefix would have been followed. The sub-steps + * that follow will create a new namespace prefix declaration for prefix + * and ensure that prefix does not conflict with an existing namespace + * prefix declaration of the same localName in node's attribute list. + * + * 12.5.1. If the local prefixes map contains a key matching prefix, + * then let prefix be the result of generating a prefix providing as + * input map, ns, and prefix index. + */ + if (prefix in localPrefixesMap) { + prefix = this._generatePrefix(ns, map, prefixIndex); + } + /** + * 12.5.2. Add prefix to map given namespace ns. + * 12.5.3. Append to qualified name the concatenation of prefix, ":" + * (U+003A COLON), and node's localName. + * 12.5.4. Append the value of qualified name to markup. + */ + map.set(prefix, ns); + qualifiedName += prefix + ':' + node.localName; + this.beginElement(qualifiedName); + this.openTagBegin(qualifiedName); + /** + * 12.5.5. Append the following to markup, in the order listed: + * + * _Note:_ The following serializes a namespace prefix declaration for + * prefix which was just added to the map. + * + * 12.5.5.1. " " (U+0020 SPACE); + * 12.5.5.2. The string "xmlns:"; + * 12.5.5.3. The value of prefix; + * 12.5.5.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); + * 12.5.5.5. The result of serializing an attribute value given ns and + * the require well-formed flag as input; + * 12.5.5.6. """ (U+0022 QUOTATION MARK). + */ + attributes.push([null, 'xmlns', prefix, + this._serializeAttributeValue(ns, requireWellFormed, noDoubleEncoding)]); + /** + * 12.5.5.7. If local default namespace is not null (there exists a + * locally-defined default namespace declaration attribute), then + * let inherited ns get the value of local default namespace unless the + * local default namespace is the empty string in which case let it get + * null. + */ + if (localDefaultNamespace !== null) { + inheritedNS = localDefaultNamespace || null; + } + /** + * 12.6. Otherwise, if local default namespace is null, or local + * default namespace is not null and its value is not equal to ns, then: + */ + } + else if (localDefaultNamespace === null || + (localDefaultNamespace !== null && localDefaultNamespace !== ns)) { + /** + * _Note:_ At this point, the namespace for this node still needs to be + * serialized, but there's no prefix (or candidate prefix) available; the + * following uses the default namespace declaration to define the + * namespace--optionally replacing an existing default declaration + * if present. + * + * 12.6.1. Set the ignore namespace definition attribute flag to true. + * 12.6.2. Append to qualified name the value of node's localName. + * 12.6.3. Let the value of inherited ns be ns. + * + * _Note:_ The new default namespace will be used in the serialization + * to define this node's namespace and act as the context namespace for + * its children. + */ + ignoreNamespaceDefinitionAttribute = true; + qualifiedName += node.localName; + inheritedNS = ns; + /** + * 12.6.4. Append the value of qualified name to markup. + */ + this.beginElement(qualifiedName); + this.openTagBegin(qualifiedName); + /** + * 12.6.5. Append the following to markup, in the order listed: + * + * _Note:_ The following serializes the new (or replacement) default + * namespace definition. + * + * 12.6.5.1. " " (U+0020 SPACE); + * 12.6.5.2. The string "xmlns"; + * 12.6.5.3. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); + * 12.6.5.4. The result of serializing an attribute value given ns + * and the require well-formed flag as input; + * 12.6.5.5. """ (U+0022 QUOTATION MARK). + */ + attributes.push([null, null, 'xmlns', + this._serializeAttributeValue(ns, requireWellFormed, noDoubleEncoding)]); + /** + * 12.7. Otherwise, the node has a local default namespace that matches + * ns. Append to qualified name the value of node's localName, let the + * value of inherited ns be ns, and append the value of qualified name + * to markup. + */ + } + else { + qualifiedName += node.localName; + inheritedNS = ns; + this.beginElement(qualifiedName); + this.openTagBegin(qualifiedName); + } + } + /** + * 13. Append to markup the result of the XML serialization of node's + * attributes given map, prefix index, local prefixes map, ignore namespace + * definition attribute flag, and require well-formed flag. + */ + attributes.push.apply(attributes, __spread(this._serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed, noDoubleEncoding))); + this.attributes(attributes); + /** + * 14. If ns is the HTML namespace, and the node's list of children is + * empty, and the node's localName matches any one of the following void + * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed", + * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta", + * "param", "source", "track", "wbr"; then append the following to markup, + * in the order listed: + * 14.1. " " (U+0020 SPACE); + * 14.2. "/" (U+002F SOLIDUS). + * and set the skip end tag flag to true. + * 15. If ns is not the HTML namespace, and the node's list of children is + * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end + * tag flag to true. + * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup. + */ + var isHTML = (ns === infra_1.namespace.HTML); + if (isHTML && node.childNodes.length === 0 && + BaseWriter._VoidElementNames.has(node.localName)) { + this.openTagEnd(qualifiedName, true, true); + this.endElement(qualifiedName); + skipEndTag = true; + } + else if (!isHTML && node.childNodes.length === 0) { + this.openTagEnd(qualifiedName, true, false); + this.endElement(qualifiedName); + skipEndTag = true; + } + else { + this.openTagEnd(qualifiedName, false, false); + } + /** + * 17. If the value of skip end tag is true, then return the value of markup + * and skip the remaining steps. The node is a leaf-node. + */ + if (skipEndTag) + return; + /** + * 18. If ns is the HTML namespace, and the node's localName matches the + * string "template", then this is a template element. Append to markup the + * result of XML serializing a DocumentFragment node given the template + * element's template contents (a DocumentFragment), providing inherited + * ns, map, prefix index, and the require well-formed flag. + * + * _Note:_ This allows template content to round-trip, given the rules for + * parsing XHTML documents. + * + * 19. Otherwise, append to markup the result of running the XML + * serialization algorithm on each of node's children, in tree order, + * providing inherited ns, map, prefix index, and the require well-formed + * flag. + */ + if (isHTML && node.localName === "template") { + // TODO: serialize template contents + } + else { + try { + for (var _b = __values(node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + this.level++; + this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed, noDoubleEncoding); + this.level--; + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_2) throw e_2.error; } + } + } + /** + * 20. Append the following to markup, in the order listed: + * 20.1. "" (U+003E GREATER-THAN SIGN). + * 21. Return the value of markup. + */ + this.closeTag(qualifiedName); + this.endElement(qualifiedName); + }; + /** + * Produces an XML serialization of an element node. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeElement = function (node, requireWellFormed, noDoubleEncoding) { + var e_3, _a; + /** + * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node + * + * 1. If the require well-formed flag is set (its value is true), and this + * node's localName attribute contains the character ":" (U+003A COLON) or + * does not match the XML Name production, then throw an exception; the + * serialization of this node would not be a well-formed element. + */ + if (requireWellFormed && (node.localName.indexOf(":") !== -1 || + !algorithm_1.xml_isName(node.localName))) { + throw new Error("Node local name contains invalid characters (well-formed required)."); + } + /** + * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN). + * 3. Let qualified name be an empty string. + * 4. Let skip end tag be a boolean flag with value false. + * 5. Let ignore namespace definition attribute be a boolean flag with value + * false. + * 6. Given prefix map, copy a namespace prefix map and let map be the + * result. + * 7. Let local prefixes map be an empty map. The map has unique Node prefix + * strings as its keys, with corresponding namespaceURI Node values as the + * map's key values (in this map, the null namespace is represented by the + * empty string). + * + * _Note:_ This map is local to each element. It is used to ensure there + * are no conflicting prefixes should a new namespace prefix attribute need + * to be generated. It is also used to enable skipping of duplicate prefix + * definitions when writing an element's attributes: the map allows the + * algorithm to distinguish between a prefix in the namespace prefix map + * that might be locally-defined (to the current Element) and one that is + * not. + * 8. Let local default namespace be the result of recording the namespace + * information for node given map and local prefixes map. + * + * _Note:_ The above step will update map with any found namespace prefix + * definitions, add the found prefix definitions to the local prefixes map + * and return a local default namespace value defined by a default namespace + * attribute if one exists. Otherwise it returns null. + * 9. Let inherited ns be a copy of namespace. + * 10. Let ns be the value of node's namespaceURI attribute. + */ + var skipEndTag = false; + /** 11. If inherited ns is equal to ns, then: */ + /** + * 11.1. If local default namespace is not null, then set ignore + * namespace definition attribute to true. + */ + /** + * 11.2. If ns is the XML namespace, then append to qualified name the + * concatenation of the string "xml:" and the value of node's localName. + * 11.3. Otherwise, append to qualified name the value of node's + * localName. The node's prefix if it exists, is dropped. + */ + var qualifiedName = node.localName; + /** 11.4. Append the value of qualified name to markup. */ + this.beginElement(qualifiedName); + this.openTagBegin(qualifiedName); + /** + * 13. Append to markup the result of the XML serialization of node's + * attributes given map, prefix index, local prefixes map, ignore namespace + * definition attribute flag, and require well-formed flag. + */ + var attributes = this._serializeAttributes(node, requireWellFormed, noDoubleEncoding); + this.attributes(attributes); + /** + * 14. If ns is the HTML namespace, and the node's list of children is + * empty, and the node's localName matches any one of the following void + * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed", + * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta", + * "param", "source", "track", "wbr"; then append the following to markup, + * in the order listed: + * 14.1. " " (U+0020 SPACE); + * 14.2. "/" (U+002F SOLIDUS). + * and set the skip end tag flag to true. + * 15. If ns is not the HTML namespace, and the node's list of children is + * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end + * tag flag to true. + * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup. + */ + if (!node.hasChildNodes()) { + this.openTagEnd(qualifiedName, true, false); + this.endElement(qualifiedName); + skipEndTag = true; + } + else { + this.openTagEnd(qualifiedName, false, false); + } + /** + * 17. If the value of skip end tag is true, then return the value of markup + * and skip the remaining steps. The node is a leaf-node. + */ + if (skipEndTag) + return; + try { + /** + * 18. If ns is the HTML namespace, and the node's localName matches the + * string "template", then this is a template element. Append to markup the + * result of XML serializing a DocumentFragment node given the template + * element's template contents (a DocumentFragment), providing inherited + * ns, map, prefix index, and the require well-formed flag. + * + * _Note:_ This allows template content to round-trip, given the rules for + * parsing XHTML documents. + * + * 19. Otherwise, append to markup the result of running the XML + * serialization algorithm on each of node's children, in tree order, + * providing inherited ns, map, prefix index, and the require well-formed + * flag. + */ + for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + this.level++; + this._serializeNode(childNode, requireWellFormed, noDoubleEncoding); + this.level--; + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_3) throw e_3.error; } + } + /** + * 20. Append the following to markup, in the order listed: + * 20.1. "" (U+003E GREATER-THAN SIGN). + * 21. Return the value of markup. + */ + this.closeTag(qualifiedName); + this.endElement(qualifiedName); + }; + /** + * Produces an XML serialization of a document node. + * + * @param node - node to serialize + * @param namespace - context namespace + * @param prefixMap - namespace prefix map + * @param prefixIndex - generated namespace prefix index + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeDocumentNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) { + var e_4, _a; + /** + * If the require well-formed flag is set (its value is true), and this node + * has no documentElement (the documentElement attribute's value is null), + * then throw an exception; the serialization of this node would not be a + * well-formed document. + */ + if (requireWellFormed && node.documentElement === null) { + throw new Error("Missing document element (well-formed required)."); + } + try { + /** + * Otherwise, run the following steps: + * 1. Let serialized document be an empty string. + * 2. For each child child of node, in tree order, run the XML + * serialization algorithm on the child passing along the provided + * arguments, and append the result to serialized document. + * + * _Note:_ This will serialize any number of ProcessingInstruction and + * Comment nodes both before and after the Document's documentElement node, + * including at most one DocumentType node. (Text nodes are not allowed as + * children of the Document.) + * + * 3. Return the value of serialized document. + */ + for (var _b = __values(node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); + } + } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_4) throw e_4.error; } + } + }; + /** + * Produces an XML serialization of a document node. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeDocument = function (node, requireWellFormed, noDoubleEncoding) { + var e_5, _a; + /** + * If the require well-formed flag is set (its value is true), and this node + * has no documentElement (the documentElement attribute's value is null), + * then throw an exception; the serialization of this node would not be a + * well-formed document. + */ + if (requireWellFormed && node.documentElement === null) { + throw new Error("Missing document element (well-formed required)."); + } + try { + /** + * Otherwise, run the following steps: + * 1. Let serialized document be an empty string. + * 2. For each child child of node, in tree order, run the XML + * serialization algorithm on the child passing along the provided + * arguments, and append the result to serialized document. + * + * _Note:_ This will serialize any number of ProcessingInstruction and + * Comment nodes both before and after the Document's documentElement node, + * including at most one DocumentType node. (Text nodes are not allowed as + * children of the Document.) + * + * 3. Return the value of serialized document. + */ + for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + this._serializeNode(childNode, requireWellFormed, noDoubleEncoding); + } + } + catch (e_5_1) { e_5 = { error: e_5_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_5) throw e_5.error; } + } + }; + /** + * Produces an XML serialization of a comment node. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeComment = function (node, requireWellFormed, noDoubleEncoding) { + /** + * If the require well-formed flag is set (its value is true), and node's + * data contains characters that are not matched by the XML Char production + * or contains "--" (two adjacent U+002D HYPHEN-MINUS characters) or that + * ends with a "-" (U+002D HYPHEN-MINUS) character, then throw an exception; + * the serialization of this node's data would not be well-formed. + */ + if (requireWellFormed && (!algorithm_1.xml_isLegalChar(node.data) || + node.data.indexOf("--") !== -1 || node.data.endsWith("-"))) { + throw new Error("Comment data contains invalid characters (well-formed required)."); + } + /** + * Otherwise, return the concatenation of "". + */ + this.comment(node.data); + }; + /** + * Produces an XML serialization of a text node. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + * @param level - current depth of the XML tree + */ + BaseWriter.prototype._serializeText = function (node, requireWellFormed, noDoubleEncoding) { + /** + * 1. If the require well-formed flag is set (its value is true), and + * node's data contains characters that are not matched by the XML Char + * production, then throw an exception; the serialization of this node's + * data would not be well-formed. + */ + if (requireWellFormed && !algorithm_1.xml_isLegalChar(node.data)) { + throw new Error("Text data contains invalid characters (well-formed required)."); + } + /** + * 2. Let markup be the value of node's data. + * 3. Replace any occurrences of "&" in markup by "&". + * 4. Replace any occurrences of "<" in markup by "<". + * 5. Replace any occurrences of ">" in markup by ">". + * 6. Return the value of markup. + */ + var markup = ""; + if (noDoubleEncoding) { + markup = node.data.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&') + .replace(//g, '>'); + } + else { + for (var i = 0; i < node.data.length; i++) { + var c = node.data[i]; + if (c === "&") + markup += "&"; + else if (c === "<") + markup += "<"; + else if (c === ">") + markup += ">"; + else + markup += c; + } + } + this.text(markup); + }; + /** + * Produces an XML serialization of a document fragment node. + * + * @param node - node to serialize + * @param namespace - context namespace + * @param prefixMap - namespace prefix map + * @param prefixIndex - generated namespace prefix index + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeDocumentFragmentNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) { + var e_6, _a; + try { + /** + * 1. Let markup the empty string. + * 2. For each child child of node, in tree order, run the XML serialization + * algorithm on the child given namespace, prefix map, a reference to prefix + * index, and flag require well-formed. Concatenate the result to markup. + * 3. Return the value of markup. + */ + for (var _b = __values(node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); + } + } + catch (e_6_1) { e_6 = { error: e_6_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_6) throw e_6.error; } + } + }; + /** + * Produces an XML serialization of a document fragment node. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeDocumentFragment = function (node, requireWellFormed, noDoubleEncoding) { + var e_7, _a; + try { + /** + * 1. Let markup the empty string. + * 2. For each child child of node, in tree order, run the XML serialization + * algorithm on the child given namespace, prefix map, a reference to prefix + * index, and flag require well-formed. Concatenate the result to markup. + * 3. Return the value of markup. + */ + for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + this._serializeNode(childNode, requireWellFormed, noDoubleEncoding); + } + } + catch (e_7_1) { e_7 = { error: e_7_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_7) throw e_7.error; } + } + }; + /** + * Produces an XML serialization of a document type node. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeDocumentType = function (node, requireWellFormed, noDoubleEncoding) { + /** + * 1. If the require well-formed flag is true and the node's publicId + * attribute contains characters that are not matched by the XML PubidChar + * production, then throw an exception; the serialization of this node + * would not be a well-formed document type declaration. + */ + if (requireWellFormed && !algorithm_1.xml_isPubidChar(node.publicId)) { + throw new Error("DocType public identifier does not match PubidChar construct (well-formed required)."); + } + /** + * 2. If the require well-formed flag is true and the node's systemId + * attribute contains characters that are not matched by the XML Char + * production or that contains both a """ (U+0022 QUOTATION MARK) and a + * "'" (U+0027 APOSTROPHE), then throw an exception; the serialization + * of this node would not be a well-formed document type declaration. + */ + if (requireWellFormed && + (!algorithm_1.xml_isLegalChar(node.systemId) || + (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) { + throw new Error("DocType system identifier contains invalid characters (well-formed required)."); + } + /** + * 3. Let markup be an empty string. + * 4. Append the string "" (U+003E GREATER-THAN SIGN) to markup. + * 11. Return the value of markup. + */ + this.docType(node.name, node.publicId, node.systemId); + }; + /** + * Produces an XML serialization of a processing instruction node. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeProcessingInstruction = function (node, requireWellFormed, noDoubleEncoding) { + /** + * 1. If the require well-formed flag is set (its value is true), and node's + * target contains a ":" (U+003A COLON) character or is an ASCII + * case-insensitive match for the string "xml", then throw an exception; + * the serialization of this node's target would not be well-formed. + */ + if (requireWellFormed && (node.target.indexOf(":") !== -1 || (/^xml$/i).test(node.target))) { + throw new Error("Processing instruction target contains invalid characters (well-formed required)."); + } + /** + * 2. If the require well-formed flag is set (its value is true), and node's + * data contains characters that are not matched by the XML Char production + * or contains the string "?>" (U+003F QUESTION MARK, + * U+003E GREATER-THAN SIGN), then throw an exception; the serialization of + * this node's data would not be well-formed. + */ + if (requireWellFormed && (!algorithm_1.xml_isLegalChar(node.data) || + node.data.indexOf("?>") !== -1)) { + throw new Error("Processing instruction data contains invalid characters (well-formed required)."); + } + /** + * 3. Let markup be the concatenation of the following, in the order listed: + * 3.1. "" (U+003F QUESTION MARK, U+003E GREATER-THAN SIGN). + * 4. Return the value of markup. + */ + this.instruction(node.target, node.data); + }; + /** + * Produces an XML serialization of a CDATA node. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeCData = function (node, requireWellFormed, noDoubleEncoding) { + if (requireWellFormed && (node.data.indexOf("]]>") !== -1)) { + throw new Error("CDATA contains invalid characters (well-formed required)."); + } + this.cdata(node.data); + }; + /** + * Produces an XML serialization of the attributes of an element node. + * + * @param node - node to serialize + * @param map - namespace prefix map + * @param prefixIndex - generated namespace prefix index + * @param localPrefixesMap - local prefixes map + * @param ignoreNamespaceDefinitionAttribute - whether to ignore namespace + * attributes + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeAttributesNS = function (node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed, noDoubleEncoding) { + var e_8, _a; + /** + * 1. Let result be the empty string. + * 2. Let localname set be a new empty namespace localname set. This + * localname set will contain tuples of unique attribute namespaceURI and + * localName pairs, and is populated as each attr is processed. This set is + * used to [optionally] enforce the well-formed constraint that an element + * cannot have two attributes with the same namespaceURI and localName. + * This can occur when two otherwise identical attributes on the same + * element differ only by their prefix values. + */ + var result = []; + var localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined; + try { + /** + * 3. Loop: For each attribute attr in element's attributes, in the order + * they are specified in the element's attribute list: + */ + for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) { + var attr = _c.value; + // Optimize common case + if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) { + result.push([null, null, attr.localName, + this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]); + continue; + } + /** + * 3.1. If the require well-formed flag is set (its value is true), and the + * localname set contains a tuple whose values match those of a new tuple + * consisting of attr's namespaceURI attribute and localName attribute, + * then throw an exception; the serialization of this attr would fail to + * produce a well-formed element serialization. + */ + if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) { + throw new Error("Element contains duplicate attributes (well-formed required)."); + } + /** + * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and + * localName attribute, and add it to the localname set. + * 3.3. Let attribute namespace be the value of attr's namespaceURI value. + * 3.4. Let candidate prefix be null. + */ + if (requireWellFormed && localNameSet) + localNameSet.set(attr.namespaceURI, attr.localName); + var attributeNamespace = attr.namespaceURI; + var candidatePrefix = null; + /** 3.5. If attribute namespace is not null, then run these sub-steps: */ + if (attributeNamespace !== null) { + /** + * 3.5.1. Let candidate prefix be the result of retrieving a preferred + * prefix string from map given namespace attribute namespace with + * preferred prefix being attr's prefix value. + */ + candidatePrefix = map.get(attr.prefix, attributeNamespace); + /** + * 3.5.2. If the value of attribute namespace is the XMLNS namespace, + * then run these steps: + */ + if (attributeNamespace === infra_1.namespace.XMLNS) { + /** + * 3.5.2.1. If any of the following are true, then stop running these + * steps and goto Loop to visit the next attribute: + * - the attr's value is the XML namespace; + * _Note:_ The XML namespace cannot be redeclared and survive + * round-tripping (unless it defines the prefix "xml"). To avoid this + * problem, this algorithm always prefixes elements in the XML + * namespace with "xml" and drops any related definitions as seen + * in the above condition. + * - the attr's prefix is null and the ignore namespace definition + * attribute flag is true (the Element's default namespace attribute + * should be skipped); + * - the attr's prefix is not null and either + * * the attr's localName is not a key contained in the local + * prefixes map, or + * * the attr's localName is present in the local prefixes map but + * the value of the key does not match attr's value + * and furthermore that the attr's localName (as the prefix to find) + * is found in the namespace prefix map given the namespace consisting + * of the attr's value (the current namespace prefix definition was + * exactly defined previously--on an ancestor element not the current + * element whose attributes are being processed). + */ + if (attr.value === infra_1.namespace.XML || + (attr.prefix === null && ignoreNamespaceDefinitionAttribute) || + (attr.prefix !== null && (!(attr.localName in localPrefixesMap) || + localPrefixesMap[attr.localName] !== attr.value) && + map.has(attr.localName, attr.value))) + continue; + /** + * 3.5.2.2. If the require well-formed flag is set (its value is true), + * and the value of attr's value attribute matches the XMLNS + * namespace, then throw an exception; the serialization of this + * attribute would produce invalid XML because the XMLNS namespace + * is reserved and cannot be applied as an element's namespace via + * XML parsing. + * + * _Note:_ DOM APIs do allow creation of elements in the XMLNS + * namespace but with strict qualifications. + */ + if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) { + throw new Error("XMLNS namespace is reserved (well-formed required)."); + } + /** + * 3.5.2.3. If the require well-formed flag is set (its value is true), + * and the value of attr's value attribute is the empty string, then + * throw an exception; namespace prefix declarations cannot be used + * to undeclare a namespace (use a default namespace declaration + * instead). + */ + if (requireWellFormed && attr.value === '') { + throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required)."); + } + /** + * 3.5.2.4. the attr's prefix matches the string "xmlns", then let + * candidate prefix be the string "xmlns". + */ + if (attr.prefix === 'xmlns') + candidatePrefix = 'xmlns'; + /** + * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace. + * Run these steps: + * + * _Note:_ The (candidatePrefix === null) check is not in the spec. + * We deviate from the spec here. Otherwise a prefix is generated for + * all attributes with namespaces. + */ + } + else if (candidatePrefix === null) { + if (attr.prefix !== null && + (!map.hasPrefix(attr.prefix) || + map.has(attr.prefix, attributeNamespace))) { + /** + * Check if we can use the attribute's own prefix. + * We deviate from the spec here. + * TODO: This is not an efficient way of searching for prefixes. + * Follow developments to the spec. + */ + candidatePrefix = attr.prefix; + } + else { + /** + * 3.5.3.1. Let candidate prefix be the result of generating a prefix + * providing map, attribute namespace, and prefix index as input. + */ + candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex); + } + /** + * 3.5.3.2. Append the following to result, in the order listed: + * 3.5.3.2.1. " " (U+0020 SPACE); + * 3.5.3.2.2. The string "xmlns:"; + * 3.5.3.2.3. The value of candidate prefix; + * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); + * 3.5.3.2.5. The result of serializing an attribute value given + * attribute namespace and the require well-formed flag as input; + * 3.5.3.2.6. """ (U+0022 QUOTATION MARK). + */ + result.push([null, "xmlns", candidatePrefix, + this._serializeAttributeValue(attributeNamespace, requireWellFormed, noDoubleEncoding)]); + } + } + /** + * 3.6. Append a " " (U+0020 SPACE) to result. + * 3.7. If candidate prefix is not null, then append to result the + * concatenation of candidate prefix with ":" (U+003A COLON). + */ + var attrName = ''; + if (candidatePrefix !== null) { + attrName = candidatePrefix; + } + /** + * 3.8. If the require well-formed flag is set (its value is true), and + * this attr's localName attribute contains the character + * ":" (U+003A COLON) or does not match the XML Name production or + * equals "xmlns" and attribute namespace is null, then throw an + * exception; the serialization of this attr would not be a + * well-formed attribute. + */ + if (requireWellFormed && (attr.localName.indexOf(":") !== -1 || + !algorithm_1.xml_isName(attr.localName) || + (attr.localName === "xmlns" && attributeNamespace === null))) { + throw new Error("Attribute local name contains invalid characters (well-formed required)."); + } + /** + * 3.9. Append the following strings to result, in the order listed: + * 3.9.1. The value of attr's localName; + * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); + * 3.9.3. The result of serializing an attribute value given attr's value + * attribute and the require well-formed flag as input; + * 3.9.4. """ (U+0022 QUOTATION MARK). + */ + result.push([attributeNamespace, candidatePrefix, attr.localName, + this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]); + } + } + catch (e_8_1) { e_8 = { error: e_8_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_8) throw e_8.error; } + } + /** + * 4. Return the value of result. + */ + return result; + }; + /** + * Produces an XML serialization of the attributes of an element node. + * + * @param node - node to serialize + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeAttributes = function (node, requireWellFormed, noDoubleEncoding) { + var e_9, _a; + /** + * 1. Let result be the empty string. + * 2. Let localname set be a new empty namespace localname set. This + * localname set will contain tuples of unique attribute namespaceURI and + * localName pairs, and is populated as each attr is processed. This set is + * used to [optionally] enforce the well-formed constraint that an element + * cannot have two attributes with the same namespaceURI and localName. + * This can occur when two otherwise identical attributes on the same + * element differ only by their prefix values. + */ + var result = []; + var localNameSet = requireWellFormed ? {} : undefined; + try { + /** + * 3. Loop: For each attribute attr in element's attributes, in the order + * they are specified in the element's attribute list: + */ + for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) { + var attr = _c.value; + // Optimize common case + if (!requireWellFormed) { + result.push([null, null, attr.localName, + this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]); + continue; + } + /** + * 3.1. If the require well-formed flag is set (its value is true), and the + * localname set contains a tuple whose values match those of a new tuple + * consisting of attr's namespaceURI attribute and localName attribute, + * then throw an exception; the serialization of this attr would fail to + * produce a well-formed element serialization. + */ + if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) { + throw new Error("Element contains duplicate attributes (well-formed required)."); + } + /** + * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and + * localName attribute, and add it to the localname set. + * 3.3. Let attribute namespace be the value of attr's namespaceURI value. + * 3.4. Let candidate prefix be null. + */ + /* istanbul ignore else */ + if (requireWellFormed && localNameSet) + localNameSet[attr.localName] = true; + /** 3.5. If attribute namespace is not null, then run these sub-steps: */ + /** + * 3.6. Append a " " (U+0020 SPACE) to result. + * 3.7. If candidate prefix is not null, then append to result the + * concatenation of candidate prefix with ":" (U+003A COLON). + */ + /** + * 3.8. If the require well-formed flag is set (its value is true), and + * this attr's localName attribute contains the character + * ":" (U+003A COLON) or does not match the XML Name production or + * equals "xmlns" and attribute namespace is null, then throw an + * exception; the serialization of this attr would not be a + * well-formed attribute. + */ + if (requireWellFormed && (attr.localName.indexOf(":") !== -1 || + !algorithm_1.xml_isName(attr.localName))) { + throw new Error("Attribute local name contains invalid characters (well-formed required)."); + } + /** + * 3.9. Append the following strings to result, in the order listed: + * 3.9.1. The value of attr's localName; + * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); + * 3.9.3. The result of serializing an attribute value given attr's value + * attribute and the require well-formed flag as input; + * 3.9.4. """ (U+0022 QUOTATION MARK). + */ + result.push([null, null, attr.localName, + this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]); + } + } + catch (e_9_1) { e_9 = { error: e_9_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_9) throw e_9.error; } + } + /** + * 4. Return the value of result. + */ + return result; + }; + /** + * Records namespace information for the given element and returns the + * default namespace attribute value. + * + * @param node - element node to process + * @param map - namespace prefix map + * @param localPrefixesMap - local prefixes map + */ + BaseWriter.prototype._recordNamespaceInformation = function (node, map, localPrefixesMap) { + var e_10, _a; + /** + * 1. Let default namespace attr value be null. + */ + var defaultNamespaceAttrValue = null; + try { + /** + * 2. Main: For each attribute attr in element's attributes, in the order + * they are specified in the element's attribute list: + */ + for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) { + var attr = _c.value; + /** + * _Note:_ The following conditional steps find namespace prefixes. Only + * attributes in the XMLNS namespace are considered (e.g., attributes made + * to look like namespace declarations via + * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not + * included). + */ + /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */ + var attributeNamespace = attr.namespaceURI; + /** 2.2. Let attribute prefix be the value of attr's prefix. */ + var attributePrefix = attr.prefix; + /** 2.3. If the attribute namespace is the XMLNS namespace, then: */ + if (attributeNamespace === infra_1.namespace.XMLNS) { + /** + * 2.3.1. If attribute prefix is null, then attr is a default namespace + * declaration. Set the default namespace attr value to attr's value and + * stop running these steps, returning to Main to visit the next + * attribute. + */ + if (attributePrefix === null) { + defaultNamespaceAttrValue = attr.value; + continue; + /** + * 2.3.2. Otherwise, the attribute prefix is not null and attr is a + * namespace prefix definition. Run the following steps: + */ + } + else { + /** 2.3.2.1. Let prefix definition be the value of attr's localName. */ + var prefixDefinition = attr.localName; + /** 2.3.2.2. Let namespace definition be the value of attr's value. */ + var namespaceDefinition = attr.value; + /** + * 2.3.2.3. If namespace definition is the XML namespace, then stop + * running these steps, and return to Main to visit the next + * attribute. + * + * _Note:_ XML namespace definitions in prefixes are completely + * ignored (in order to avoid unnecessary work when there might be + * prefix conflicts). XML namespaced elements are always handled + * uniformly by prefixing (and overriding if necessary) the element's + * localname with the reserved "xml" prefix. + */ + if (namespaceDefinition === infra_1.namespace.XML) { + continue; + } + /** + * 2.3.2.4. If namespace definition is the empty string (the + * declarative form of having no namespace), then let namespace + * definition be null instead. + */ + if (namespaceDefinition === '') { + namespaceDefinition = null; + } + /** + * 2.3.2.5. If prefix definition is found in map given the namespace + * namespace definition, then stop running these steps, and return to + * Main to visit the next attribute. + * + * _Note:_ This step avoids adding duplicate prefix definitions for + * the same namespace in the map. This has the side-effect of avoiding + * later serialization of duplicate namespace prefix declarations in + * any descendant nodes. + */ + if (map.has(prefixDefinition, namespaceDefinition)) { + continue; + } + /** + * 2.3.2.6. Add the prefix prefix definition to map given namespace + * namespace definition. + */ + map.set(prefixDefinition, namespaceDefinition); + /** + * 2.3.2.7. Add the value of prefix definition as a new key to the + * local prefixes map, with the namespace definition as the key's + * value replacing the value of null with the empty string if + * applicable. + */ + localPrefixesMap[prefixDefinition] = namespaceDefinition || ''; + } + } + } + } + catch (e_10_1) { e_10 = { error: e_10_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_10) throw e_10.error; } + } + /** + * 3. Return the value of default namespace attr value. + * + * _Note:_ The empty string is a legitimate return value and is not + * converted to null. + */ + return defaultNamespaceAttrValue; + }; + /** + * Generates a new prefix for the given namespace. + * + * @param newNamespace - a namespace to generate prefix for + * @param prefixMap - namespace prefix map + * @param prefixIndex - generated namespace prefix index + */ + BaseWriter.prototype._generatePrefix = function (newNamespace, prefixMap, prefixIndex) { + /** + * 1. Let generated prefix be the concatenation of the string "ns" and the + * current numerical value of prefix index. + * 2. Let the value of prefix index be incremented by one. + * 3. Add to map the generated prefix given the new namespace namespace. + * 4. Return the value of generated prefix. + */ + var generatedPrefix = "ns" + prefixIndex.value.toString(); + prefixIndex.value++; + prefixMap.set(generatedPrefix, newNamespace); + return generatedPrefix; + }; + /** + * Produces an XML serialization of an attribute value. + * + * @param value - attribute value + * @param requireWellFormed - whether to check conformance + */ + BaseWriter.prototype._serializeAttributeValue = function (value, requireWellFormed, noDoubleEncoding) { + /** + * From: https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value + * + * 1. If the require well-formed flag is set (its value is true), and + * attribute value contains characters that are not matched by the XML Char + * production, then throw an exception; the serialization of this attribute + * value would fail to produce a well-formed element serialization. + */ + if (requireWellFormed && value !== null && !algorithm_1.xml_isLegalChar(value)) { + throw new Error("Invalid characters in attribute value."); + } + /** + * 2. If attribute value is null, then return the empty string. + */ + if (value === null) + return ""; + /** + * 3. Otherwise, attribute value is a string. Return the value of attribute + * value, first replacing any occurrences of the following: + * - "&" with "&" + * - """ with """ + * - "<" with "<" + * - ">" with ">" + * NOTE + * This matches behavior present in browsers, and goes above and beyond the + * grammar requirement in the XML specification's AttValue production by + * also replacing ">" characters. + */ + if (noDoubleEncoding) { + return value.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&') + .replace(//g, '>') + .replace(/"/g, '"'); + } + else { + var result = ""; + for (var i = 0; i < value.length; i++) { + var c = value[i]; + if (c === "\"") + result += """; + else if (c === "&") + result += "&"; + else if (c === "<") + result += "<"; + else if (c === ">") + result += ">"; + else + result += c; + } + return result; + } + }; + BaseWriter._VoidElementNames = new Set(['area', 'base', 'basefont', + 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen', + 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']); + return BaseWriter; +}()); +exports.BaseWriter = BaseWriter; +//# sourceMappingURL=BaseWriter.js.map + +/***/ }), +/* 463 */, +/* 464 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var interfaces_1 = __webpack_require__(970); +var DOMException_1 = __webpack_require__(35); +/** + * Applies the filter to the given node and returns the result. + * + * @param traverser - the `NodeIterator` or `TreeWalker` instance + * @param node - the node to filter + */ +function traversal_filter(traverser, node) { + /** + * 1. If traverser’s active flag is set, then throw an "InvalidStateError" + * DOMException. + */ + if (traverser._activeFlag) { + throw new DOMException_1.InvalidStateError(); + } + /** + * 2. Let n be node’s nodeType attribute value − 1. + */ + var n = node._nodeType - 1; + /** + * 3. If the nth bit (where 0 is the least significant bit) of traverser’s + * whatToShow is not set, then return FILTER_SKIP. + */ + var mask = 1 << n; + if ((traverser.whatToShow & mask) === 0) { + return interfaces_1.FilterResult.Skip; + } + /** + * 4. If traverser’s filter is null, then return FILTER_ACCEPT. + */ + if (!traverser.filter) { + return interfaces_1.FilterResult.Accept; + } + /** + * 5. Set traverser’s active flag. + */ + traverser._activeFlag = true; + /** + * 6. Let result be the return value of call a user object’s operation with + * traverser’s filter, "acceptNode", and « node ». If this throws an + * exception, then unset traverser’s active flag and rethrow the exception. + */ + var result = interfaces_1.FilterResult.Reject; + try { + result = traverser.filter.acceptNode(node); + } + catch (err) { + traverser._activeFlag = false; + throw err; + } + /** + * 7. Unset traverser’s active flag. + * 8. Return result. + */ + traverser._activeFlag = false; + return result; +} +exports.traversal_filter = traversal_filter; +//# sourceMappingURL=TraversalAlgorithm.js.map + +/***/ }), +/* 465 */, +/* 466 */, +/* 467 */, +/* 468 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var XMLStringLexer_1 = __webpack_require__(911); +var interfaces_1 = __webpack_require__(172); +var infra_1 = __webpack_require__(23); +var algorithm_1 = __webpack_require__(163); +var LocalNameSet_1 = __webpack_require__(575); +/** + * Represents a parser for XML content. + * + * See: https://html.spec.whatwg.org/#xml-parser + */ +var XMLParserImpl = /** @class */ (function () { + function XMLParserImpl() { + } + /** + * Parses XML content. + * + * @param source - a string containing XML content + */ + XMLParserImpl.prototype.parse = function (source) { + var e_1, _a, e_2, _b; + var lexer = new XMLStringLexer_1.XMLStringLexer(source, { skipWhitespaceOnlyText: true }); + var doc = algorithm_1.create_document(); + var context = doc; + var token = lexer.nextToken(); + while (token.type !== interfaces_1.TokenType.EOF) { + switch (token.type) { + case interfaces_1.TokenType.Declaration: + var declaration = token; + if (declaration.version !== "1.0") { + throw new Error("Invalid xml version: " + declaration.version); + } + break; + case interfaces_1.TokenType.DocType: + var doctype = token; + if (!algorithm_1.xml_isPubidChar(doctype.pubId)) { + throw new Error("DocType public identifier does not match PubidChar construct."); + } + if (!algorithm_1.xml_isLegalChar(doctype.sysId) || + (doctype.sysId.indexOf('"') !== -1 && doctype.sysId.indexOf("'") !== -1)) { + throw new Error("DocType system identifier contains invalid characters."); + } + context.appendChild(doc.implementation.createDocumentType(doctype.name, doctype.pubId, doctype.sysId)); + break; + case interfaces_1.TokenType.CDATA: + var cdata = token; + if (!algorithm_1.xml_isLegalChar(cdata.data) || + cdata.data.indexOf("]]>") !== -1) { + throw new Error("CDATA contains invalid characters."); + } + context.appendChild(doc.createCDATASection(cdata.data)); + break; + case interfaces_1.TokenType.Comment: + var comment = token; + if (!algorithm_1.xml_isLegalChar(comment.data) || + comment.data.indexOf("--") !== -1 || comment.data.endsWith("-")) { + throw new Error("Comment data contains invalid characters."); + } + context.appendChild(doc.createComment(comment.data)); + break; + case interfaces_1.TokenType.PI: + var pi = token; + if (pi.target.indexOf(":") !== -1 || (/^xml$/i).test(pi.target)) { + throw new Error("Processing instruction target contains invalid characters."); + } + if (!algorithm_1.xml_isLegalChar(pi.data) || pi.data.indexOf("?>") !== -1) { + throw new Error("Processing instruction data contains invalid characters."); + } + context.appendChild(doc.createProcessingInstruction(pi.target, pi.data)); + break; + case interfaces_1.TokenType.Text: + var text = token; + if (!algorithm_1.xml_isLegalChar(text.data)) { + throw new Error("Text data contains invalid characters."); + } + context.appendChild(doc.createTextNode(text.data)); + break; + case interfaces_1.TokenType.Element: + var element = token; + // inherit namespace from parent + var _c = __read(algorithm_1.namespace_extractQName(element.name), 2), prefix = _c[0], localName = _c[1]; + if (localName.indexOf(":") !== -1 || !algorithm_1.xml_isName(localName)) { + throw new Error("Node local name contains invalid characters."); + } + if (prefix === "xmlns") { + throw new Error("An element cannot have the 'xmlns' prefix."); + } + var namespace = context.lookupNamespaceURI(prefix); + // override namespace if there is a namespace declaration + // attribute + // also lookup namespace declaration attributes + var nsDeclarations = {}; + try { + for (var _d = (e_1 = void 0, __values(element.attributes)), _e = _d.next(); !_e.done; _e = _d.next()) { + var _f = __read(_e.value, 2), attName = _f[0], attValue = _f[1]; + if (attName === "xmlns") { + namespace = attValue; + } + else { + var _g = __read(algorithm_1.namespace_extractQName(attName), 2), attPrefix = _g[0], attLocalName = _g[1]; + if (attPrefix === "xmlns") { + if (attLocalName === prefix) { + namespace = attValue; + } + nsDeclarations[attLocalName] = attValue; + } + } + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_e && !_e.done && (_a = _d.return)) _a.call(_d); + } + finally { if (e_1) throw e_1.error; } + } + // create the DOM element node + var elementNode = (namespace !== null ? + doc.createElementNS(namespace, element.name) : + doc.createElement(element.name)); + context.appendChild(elementNode); + // assign attributes + var localNameSet = new LocalNameSet_1.LocalNameSet(); + try { + for (var _h = (e_2 = void 0, __values(element.attributes)), _j = _h.next(); !_j.done; _j = _h.next()) { + var _k = __read(_j.value, 2), attName = _k[0], attValue = _k[1]; + var _l = __read(algorithm_1.namespace_extractQName(attName), 2), attPrefix = _l[0], attLocalName = _l[1]; + var attNamespace = null; + if (attPrefix === "xmlns" || (attPrefix === null && attLocalName === "xmlns")) { + // namespace declaration attribute + attNamespace = infra_1.namespace.XMLNS; + } + else { + attNamespace = elementNode.lookupNamespaceURI(attPrefix); + if (attNamespace !== null && elementNode.isDefaultNamespace(attNamespace)) { + attNamespace = null; + } + else if (attNamespace === null && attPrefix !== null) { + attNamespace = nsDeclarations[attPrefix] || null; + } + } + if (localNameSet.has(attNamespace, attLocalName)) { + throw new Error("Element contains duplicate attributes."); + } + localNameSet.set(attNamespace, attLocalName); + if (attNamespace === infra_1.namespace.XMLNS) { + if (attValue === infra_1.namespace.XMLNS) { + throw new Error("XMLNS namespace is reserved."); + } + } + if (attLocalName.indexOf(":") !== -1 || !algorithm_1.xml_isName(attLocalName)) { + throw new Error("Attribute local name contains invalid characters."); + } + if (attPrefix === "xmlns" && attValue === "") { + throw new Error("Empty XML namespace is not allowed."); + } + if (attNamespace !== null) + elementNode.setAttributeNS(attNamespace, attName, attValue); + else + elementNode.setAttribute(attName, attValue); + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_j && !_j.done && (_b = _h.return)) _b.call(_h); + } + finally { if (e_2) throw e_2.error; } + } + if (!element.selfClosing) { + context = elementNode; + } + break; + case interfaces_1.TokenType.ClosingTag: + var closingTag = token; + if (closingTag.name !== context.nodeName) { + throw new Error('Closing tag name does not match opening tag name.'); + } + /* istanbul ignore else */ + if (context._parent) { + context = context._parent; + } + break; + } + token = lexer.nextToken(); + } + return doc; + }; + return XMLParserImpl; +}()); +exports.XMLParserImpl = XMLParserImpl; +//# sourceMappingURL=XMLParserImpl.js.map + +/***/ }), +/* 469 */, +/* 470 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const command_1 = __webpack_require__(431); +const file_command_1 = __webpack_require__(102); +const utils_1 = __webpack_require__(82); +const os = __importStar(__webpack_require__(87)); +const path = __importStar(__webpack_require__(622)); +/** + * The code to exit an action + */ +var ExitCode; +(function (ExitCode) { + /** + * A code indicating that the action was successful + */ + ExitCode[ExitCode["Success"] = 0] = "Success"; + /** + * A code indicating that the action was a failure + */ + ExitCode[ExitCode["Failure"] = 1] = "Failure"; +})(ExitCode = exports.ExitCode || (exports.ExitCode = {})); +//----------------------------------------------------------------------- +// Variables +//----------------------------------------------------------------------- +/** + * Sets env variable for this action and future actions in the job + * @param name the name of the variable to set + * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function exportVariable(name, val) { + const convertedVal = utils_1.toCommandValue(val); + process.env[name] = convertedVal; + const filePath = process.env['GITHUB_ENV'] || ''; + if (filePath) { + const delimiter = '_GitHubActionsFileCommandDelimeter_'; + const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`; + file_command_1.issueCommand('ENV', commandValue); + } + else { + command_1.issueCommand('set-env', { name }, convertedVal); + } +} +exports.exportVariable = exportVariable; +/** + * Registers a secret which will get masked from logs + * @param secret value of the secret + */ +function setSecret(secret) { + command_1.issueCommand('add-mask', {}, secret); +} +exports.setSecret = setSecret; +/** + * Prepends inputPath to the PATH (for this action and future actions) + * @param inputPath + */ +function addPath(inputPath) { + const filePath = process.env['GITHUB_PATH'] || ''; + if (filePath) { + file_command_1.issueCommand('PATH', inputPath); + } + else { + command_1.issueCommand('add-path', {}, inputPath); + } + process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; +} +exports.addPath = addPath; +/** + * Gets the value of an input. The value is also trimmed. + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns string + */ +function getInput(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''; + if (options && options.required && !val) { + throw new Error(`Input required and not supplied: ${name}`); + } + return val.trim(); +} +exports.getInput = getInput; +/** + * Sets the value of an output. + * + * @param name name of the output to set + * @param value value to store. 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) { + command_1.issueCommand('set-output', { name }, value); +} +exports.setOutput = setOutput; +/** + * Enables or disables the echoing of commands into stdout for the rest of the step. + * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set. + * + */ +function setCommandEcho(enabled) { + command_1.issue('echo', enabled ? 'on' : 'off'); +} +exports.setCommandEcho = setCommandEcho; +//----------------------------------------------------------------------- +// Results +//----------------------------------------------------------------------- +/** + * Sets the action status to failed. + * When the action exits it will be with an exit code of 1 + * @param message add error issue message + */ +function setFailed(message) { + process.exitCode = ExitCode.Failure; + error(message); +} +exports.setFailed = setFailed; +//----------------------------------------------------------------------- +// Logging Commands +//----------------------------------------------------------------------- +/** + * Gets whether Actions Step Debug is on or not + */ +function isDebug() { + return process.env['RUNNER_DEBUG'] === '1'; +} +exports.isDebug = isDebug; +/** + * Writes debug message to user log + * @param message debug message + */ +function debug(message) { + command_1.issueCommand('debug', {}, message); +} +exports.debug = debug; +/** + * Adds an error issue + * @param message error issue message. Errors will be converted to string via toString() + */ +function error(message) { + command_1.issue('error', message instanceof Error ? message.toString() : message); +} +exports.error = error; +/** + * Adds an warning issue + * @param message warning issue message. Errors will be converted to string via toString() + */ +function warning(message) { + command_1.issue('warning', message instanceof Error ? message.toString() : message); +} +exports.warning = warning; +/** + * Writes info to log with console.log. + * @param message info message + */ +function info(message) { + process.stdout.write(message + os.EOL); +} +exports.info = info; +/** + * Begin an output group. + * + * Output until the next `groupEnd` will be foldable in this group + * + * @param name The name of the output group + */ +function startGroup(name) { + command_1.issue('group', name); +} +exports.startGroup = startGroup; +/** + * End an output group. + */ +function endGroup() { + command_1.issue('endgroup'); +} +exports.endGroup = endGroup; +/** + * Wrap an asynchronous function call in a group. + * + * Returns the same type as the function itself. + * + * @param name The name of the group + * @param fn The function to wrap in the group + */ +function group(name, fn) { + return __awaiter(this, void 0, void 0, function* () { + startGroup(name); + let result; + try { + result = yield fn(); + } + finally { + endGroup(); + } + return result; + }); +} +exports.group = group; +//----------------------------------------------------------------------- +// Wrapper action state +//----------------------------------------------------------------------- +/** + * Saves state for current action, the state can only be retrieved by this action's post job execution. + * + * @param name name of the state to store + * @param value value to store. 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) { + command_1.issueCommand('save-state', { name }, value); +} +exports.saveState = saveState; +/** + * Gets the value of an state set by this action's main execution. + * + * @param name name of the state to get + * @returns string + */ +function getState(name) { + return process.env[`STATE_${name}`] || ''; +} +exports.getState = getState; +//# sourceMappingURL=core.js.map + +/***/ }), +/* 471 */, +/* 472 */, +/* 473 */, +/* 474 */, +/* 475 */, +/* 476 */, +/* 477 */, +/* 478 */, +/* 479 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var DOMImpl_1 = __webpack_require__(648); +var DOMException_1 = __webpack_require__(35); +var interfaces_1 = __webpack_require__(970); +var util_1 = __webpack_require__(918); +var util_2 = __webpack_require__(592); +var infra_1 = __webpack_require__(23); +var CustomElementAlgorithm_1 = __webpack_require__(344); +var TreeAlgorithm_1 = __webpack_require__(873); +var NodeIteratorAlgorithm_1 = __webpack_require__(272); +var ShadowTreeAlgorithm_1 = __webpack_require__(180); +var MutationObserverAlgorithm_1 = __webpack_require__(151); +var DOMAlgorithm_1 = __webpack_require__(304); +var DocumentAlgorithm_1 = __webpack_require__(493); +/** + * Ensures pre-insertion validity of a node into a parent before a + * child. + * + * @param node - node to insert + * @param parent - parent node to receive node + * @param child - child node to insert node before + */ +function mutation_ensurePreInsertionValidity(node, parent, child) { + var e_1, _a, e_2, _b, e_3, _c, e_4, _d; + var parentNodeType = parent._nodeType; + var nodeNodeType = node._nodeType; + var childNodeType = child ? child._nodeType : null; + /** + * 1. If parent is not a Document, DocumentFragment, or Element node, + * throw a "HierarchyRequestError" DOMException. + */ + if (parentNodeType !== interfaces_1.NodeType.Document && + parentNodeType !== interfaces_1.NodeType.DocumentFragment && + parentNodeType !== interfaces_1.NodeType.Element) + throw new DOMException_1.HierarchyRequestError("Only document, document fragment and element nodes can contain child nodes. Parent node is " + parent.nodeName + "."); + /** + * 2. If node is a host-including inclusive ancestor of parent, throw a + * "HierarchyRequestError" DOMException. + */ + if (TreeAlgorithm_1.tree_isHostIncludingAncestorOf(parent, node, true)) + throw new DOMException_1.HierarchyRequestError("The node to be inserted cannot be an inclusive ancestor of parent node. Node is " + node.nodeName + ", parent node is " + parent.nodeName + "."); + /** + * 3. If child is not null and its parent is not parent, then throw a + * "NotFoundError" DOMException. + */ + if (child !== null && child._parent !== parent) + throw new DOMException_1.NotFoundError("The reference child node cannot be found under parent node. Child node is " + child.nodeName + ", parent node is " + parent.nodeName + "."); + /** + * 4. If node is not a DocumentFragment, DocumentType, Element, Text, + * ProcessingInstruction, or Comment node, throw a "HierarchyRequestError" + * DOMException. + */ + if (nodeNodeType !== interfaces_1.NodeType.DocumentFragment && + nodeNodeType !== interfaces_1.NodeType.DocumentType && + nodeNodeType !== interfaces_1.NodeType.Element && + nodeNodeType !== interfaces_1.NodeType.Text && + nodeNodeType !== interfaces_1.NodeType.ProcessingInstruction && + nodeNodeType !== interfaces_1.NodeType.CData && + nodeNodeType !== interfaces_1.NodeType.Comment) + throw new DOMException_1.HierarchyRequestError("Only document fragment, document type, element, text, processing instruction, cdata section or comment nodes can be inserted. Node is " + node.nodeName + "."); + /** + * 5. If either node is a Text node and parent is a document, or node is a + * doctype and parent is not a document, throw a "HierarchyRequestError" + * DOMException. + */ + if (nodeNodeType === interfaces_1.NodeType.Text && + parentNodeType === interfaces_1.NodeType.Document) + throw new DOMException_1.HierarchyRequestError("Cannot insert a text node as a child of a document node. Node is " + node.nodeName + "."); + if (nodeNodeType === interfaces_1.NodeType.DocumentType && + parentNodeType !== interfaces_1.NodeType.Document) + throw new DOMException_1.HierarchyRequestError("A document type node can only be inserted under a document node. Parent node is " + parent.nodeName + "."); + /** + * 6. If parent is a document, and any of the statements below, switched on + * node, are true, throw a "HierarchyRequestError" DOMException. + * - DocumentFragment node + * If node has more than one element child or has a Text node child. + * Otherwise, if node has one element child and either parent has an element + * child, child is a doctype, or child is not null and a doctype is + * following child. + * - element + * parent has an element child, child is a doctype, or child is not null and + * a doctype is following child. + * - doctype + * parent has a doctype child, child is non-null and an element is preceding + * child, or child is null and parent has an element child. + */ + if (parentNodeType === interfaces_1.NodeType.Document) { + if (nodeNodeType === interfaces_1.NodeType.DocumentFragment) { + var eleCount = 0; + try { + for (var _e = __values(node._children), _f = _e.next(); !_f.done; _f = _e.next()) { + var childNode = _f.value; + if (childNode._nodeType === interfaces_1.NodeType.Element) + eleCount++; + else if (childNode._nodeType === interfaces_1.NodeType.Text) + throw new DOMException_1.HierarchyRequestError("Cannot insert text a node as a child of a document node. Node is " + childNode.nodeName + "."); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_f && !_f.done && (_a = _e.return)) _a.call(_e); + } + finally { if (e_1) throw e_1.error; } + } + if (eleCount > 1) { + throw new DOMException_1.HierarchyRequestError("A document node can only have one document element node. Document fragment to be inserted has " + eleCount + " element nodes."); + } + else if (eleCount === 1) { + try { + for (var _g = __values(parent._children), _h = _g.next(); !_h.done; _h = _g.next()) { + var ele = _h.value; + if (ele._nodeType === interfaces_1.NodeType.Element) + throw new DOMException_1.HierarchyRequestError("The document node already has a document element node."); + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_h && !_h.done && (_b = _g.return)) _b.call(_g); + } + finally { if (e_2) throw e_2.error; } + } + if (child) { + if (childNodeType === interfaces_1.NodeType.DocumentType) + throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node."); + var doctypeChild = child._nextSibling; + while (doctypeChild) { + if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType) + throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node."); + doctypeChild = doctypeChild._nextSibling; + } + } + } + } + else if (nodeNodeType === interfaces_1.NodeType.Element) { + try { + for (var _j = __values(parent._children), _k = _j.next(); !_k.done; _k = _j.next()) { + var ele = _k.value; + if (ele._nodeType === interfaces_1.NodeType.Element) + throw new DOMException_1.HierarchyRequestError("Document already has a document element node. Node is " + node.nodeName + "."); + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (_k && !_k.done && (_c = _j.return)) _c.call(_j); + } + finally { if (e_3) throw e_3.error; } + } + if (child) { + if (childNodeType === interfaces_1.NodeType.DocumentType) + throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node. Node is " + node.nodeName + "."); + var doctypeChild = child._nextSibling; + while (doctypeChild) { + if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType) + throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node. Node is " + node.nodeName + "."); + doctypeChild = doctypeChild._nextSibling; + } + } + } + else if (nodeNodeType === interfaces_1.NodeType.DocumentType) { + try { + for (var _l = __values(parent._children), _m = _l.next(); !_m.done; _m = _l.next()) { + var ele = _m.value; + if (ele._nodeType === interfaces_1.NodeType.DocumentType) + throw new DOMException_1.HierarchyRequestError("Document already has a document type node. Node is " + node.nodeName + "."); + } + } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (_m && !_m.done && (_d = _l.return)) _d.call(_l); + } + finally { if (e_4) throw e_4.error; } + } + if (child) { + var elementChild = child._previousSibling; + while (elementChild) { + if (elementChild._nodeType === interfaces_1.NodeType.Element) + throw new DOMException_1.HierarchyRequestError("Cannot insert a document type node before an element node. Node is " + node.nodeName + "."); + elementChild = elementChild._previousSibling; + } + } + else { + var elementChild = parent._firstChild; + while (elementChild) { + if (elementChild._nodeType === interfaces_1.NodeType.Element) + throw new DOMException_1.HierarchyRequestError("Cannot insert a document type node before an element node. Node is " + node.nodeName + "."); + elementChild = elementChild._nextSibling; + } + } + } + } +} +exports.mutation_ensurePreInsertionValidity = mutation_ensurePreInsertionValidity; +/** + * Ensures pre-insertion validity of a node into a parent before a + * child, then adopts the node to the tree and inserts it. + * + * @param node - node to insert + * @param parent - parent node to receive node + * @param child - child node to insert node before + */ +function mutation_preInsert(node, parent, child) { + /** + * 1. Ensure pre-insertion validity of node into parent before child. + * 2. Let reference child be child. + * 3. If reference child is node, set it to node’s next sibling. + * 4. Adopt node into parent’s node document. + * 5. Insert node into parent before reference child. + * 6. Return node. + */ + mutation_ensurePreInsertionValidity(node, parent, child); + var referenceChild = child; + if (referenceChild === node) + referenceChild = node._nextSibling; + DocumentAlgorithm_1.document_adopt(node, parent._nodeDocument); + mutation_insert(node, parent, referenceChild); + return node; +} +exports.mutation_preInsert = mutation_preInsert; +/** + * Inserts a node into a parent node before the given child node. + * + * @param node - node to insert + * @param parent - parent node to receive node + * @param child - child node to insert node before + * @param suppressObservers - whether to notify observers + */ +function mutation_insert(node, parent, child, suppressObservers) { + var e_5, _a; + // Optimized common case + if (child === null && node._nodeType !== interfaces_1.NodeType.DocumentFragment) { + mutation_insert_single(node, parent, suppressObservers); + return; + } + /** + * 1. Let count be the number of children of node if it is a + * DocumentFragment node, and one otherwise. + */ + var count = (node._nodeType === interfaces_1.NodeType.DocumentFragment ? + node._children.size : 1); + /** + * 2. If child is non-null, then: + */ + if (child !== null) { + /** + * 2.1. For each live range whose start node is parent and start + * offset is greater than child's index, increase its start + * offset by count. + * 2.2. For each live range whose end node is parent and end + * offset is greater than child's index, increase its end + * offset by count. + */ + if (DOMImpl_1.dom.rangeList.size !== 0) { + var index_1 = TreeAlgorithm_1.tree_index(child); + try { + for (var _b = __values(DOMImpl_1.dom.rangeList), _c = _b.next(); !_c.done; _c = _b.next()) { + var range = _c.value; + if (range._start[0] === parent && range._start[1] > index_1) { + range._start[1] += count; + } + if (range._end[0] === parent && range._end[1] > index_1) { + range._end[1] += count; + } + } + } + catch (e_5_1) { e_5 = { error: e_5_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_5) throw e_5.error; } + } + } + } + /** + * 3. Let nodes be node’s children, if node is a DocumentFragment node; + * otherwise « node ». + */ + var nodes = node._nodeType === interfaces_1.NodeType.DocumentFragment ? new (Array.bind.apply(Array, __spread([void 0], node._children)))() : [node]; + /** + * 4. If node is a DocumentFragment node, remove its children with the + * suppress observers flag set. + */ + if (node._nodeType === interfaces_1.NodeType.DocumentFragment) { + while (node._firstChild) { + mutation_remove(node._firstChild, node, true); + } + } + /** + * 5. If node is a DocumentFragment node, then queue a tree mutation record + * for node with « », nodes, null, and null. + */ + if (DOMImpl_1.dom.features.mutationObservers) { + if (node._nodeType === interfaces_1.NodeType.DocumentFragment) { + MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(node, [], nodes, null, null); + } + } + /** + * 6. Let previousSibling be child’s previous sibling or parent’s last + * child if child is null. + */ + var previousSibling = (child ? child._previousSibling : parent._lastChild); + var index = child === null ? -1 : TreeAlgorithm_1.tree_index(child); + /** + * 7. For each node in nodes, in tree order: + */ + for (var i = 0; i < nodes.length; i++) { + var node_1 = nodes[i]; + if (util_1.Guard.isElementNode(node_1)) { + // set document element node + if (util_1.Guard.isDocumentNode(parent)) { + parent._documentElement = node_1; + } + // mark that the document has namespaces + if (!node_1._nodeDocument._hasNamespaces && (node_1._namespace !== null || + node_1._namespacePrefix !== null)) { + node_1._nodeDocument._hasNamespaces = true; + } + } + /** + * 7.1. If child is null, then append node to parent’s children. + * 7.2. Otherwise, insert node into parent’s children before child’s + * index. + */ + node_1._parent = parent; + if (child === null) { + infra_1.set.append(parent._children, node_1); + } + else { + infra_1.set.insert(parent._children, node_1, index); + index++; + } + // assign siblings and children for quick lookups + if (parent._firstChild === null) { + node_1._previousSibling = null; + node_1._nextSibling = null; + parent._firstChild = node_1; + parent._lastChild = node_1; + } + else { + var prev = (child ? child._previousSibling : parent._lastChild); + var next = (child ? child : null); + node_1._previousSibling = prev; + node_1._nextSibling = next; + if (prev) + prev._nextSibling = node_1; + if (next) + next._previousSibling = node_1; + if (!prev) + parent._firstChild = node_1; + if (!next) + parent._lastChild = node_1; + } + /** + * 7.3. If parent is a shadow host and node is a slotable, then + * assign a slot for node. + */ + if (DOMImpl_1.dom.features.slots) { + if (parent._shadowRoot !== null && util_1.Guard.isSlotable(node_1)) { + ShadowTreeAlgorithm_1.shadowTree_assignASlot(node_1); + } + } + /** + * 7.4. If node is a Text node, run the child text content change + * steps for parent. + */ + if (DOMImpl_1.dom.features.steps) { + if (util_1.Guard.isTextNode(node_1)) { + DOMAlgorithm_1.dom_runChildTextContentChangeSteps(parent); + } + } + /** + * 7.5. If parent's root is a shadow root, and parent is a slot + * whose assigned nodes is the empty list, then run signal + * a slot change for parent. + */ + if (DOMImpl_1.dom.features.slots) { + if (util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(parent)) && + util_1.Guard.isSlot(parent) && util_2.isEmpty(parent._assignedNodes)) { + ShadowTreeAlgorithm_1.shadowTree_signalASlotChange(parent); + } + } + /** + * 7.6. Run assign slotables for a tree with node's root. + */ + if (DOMImpl_1.dom.features.slots) { + ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(node_1)); + } + /** + * 7.7. For each shadow-including inclusive descendant + * inclusiveDescendant of node, in shadow-including tree + * order: + */ + var inclusiveDescendant = TreeAlgorithm_1.tree_getFirstDescendantNode(node_1, true, true); + while (inclusiveDescendant !== null) { + /** + * 7.7.1. Run the insertion steps with inclusiveDescendant. + */ + if (DOMImpl_1.dom.features.steps) { + DOMAlgorithm_1.dom_runInsertionSteps(inclusiveDescendant); + } + if (DOMImpl_1.dom.features.customElements) { + /** + * 7.7.2. If inclusiveDescendant is connected, then: + */ + if (util_1.Guard.isElementNode(inclusiveDescendant) && + ShadowTreeAlgorithm_1.shadowTree_isConnected(inclusiveDescendant)) { + if (util_1.Guard.isCustomElementNode(inclusiveDescendant)) { + /** + * 7.7.2.1. If inclusiveDescendant is custom, then enqueue a custom + * element callback reaction with inclusiveDescendant, callback name + * "connectedCallback", and an empty argument list. + */ + CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(inclusiveDescendant, "connectedCallback", []); + } + else { + /** + * 7.7.2.2. Otherwise, try to upgrade inclusiveDescendant. + */ + CustomElementAlgorithm_1.customElement_tryToUpgrade(inclusiveDescendant); + } + } + } + inclusiveDescendant = TreeAlgorithm_1.tree_getNextDescendantNode(node_1, inclusiveDescendant, true, true); + } + } + /** + * 8. If suppress observers flag is unset, then queue a tree mutation record + * for parent with nodes, « », previousSibling, and child. + */ + if (DOMImpl_1.dom.features.mutationObservers) { + if (!suppressObservers) { + MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, nodes, [], previousSibling, child); + } + } +} +exports.mutation_insert = mutation_insert; +/** + * Inserts a node into a parent node. Optimized routine for the common case where + * node is not a document fragment node and it has no child nodes. + * + * @param node - node to insert + * @param parent - parent node to receive node + * @param suppressObservers - whether to notify observers + */ +function mutation_insert_single(node, parent, suppressObservers) { + /** + * 1. Let count be the number of children of node if it is a + * DocumentFragment node, and one otherwise. + * 2. If child is non-null, then: + * 2.1. For each live range whose start node is parent and start + * offset is greater than child's index, increase its start + * offset by count. + * 2.2. For each live range whose end node is parent and end + * offset is greater than child's index, increase its end + * offset by count. + * 3. Let nodes be node’s children, if node is a DocumentFragment node; + * otherwise « node ». + * 4. If node is a DocumentFragment node, remove its children with the + * suppress observers flag set. + * 5. If node is a DocumentFragment node, then queue a tree mutation record + * for node with « », nodes, null, and null. + */ + /** + * 6. Let previousSibling be child’s previous sibling or parent’s last + * child if child is null. + */ + var previousSibling = parent._lastChild; + // set document element node + if (util_1.Guard.isElementNode(node)) { + // set document element node + if (util_1.Guard.isDocumentNode(parent)) { + parent._documentElement = node; + } + // mark that the document has namespaces + if (!node._nodeDocument._hasNamespaces && (node._namespace !== null || + node._namespacePrefix !== null)) { + node._nodeDocument._hasNamespaces = true; + } + } + /** + * 7. For each node in nodes, in tree order: + * 7.1. If child is null, then append node to parent’s children. + * 7.2. Otherwise, insert node into parent’s children before child’s + * index. + */ + node._parent = parent; + parent._children.add(node); + // assign siblings and children for quick lookups + if (parent._firstChild === null) { + node._previousSibling = null; + node._nextSibling = null; + parent._firstChild = node; + parent._lastChild = node; + } + else { + var prev = parent._lastChild; + node._previousSibling = prev; + node._nextSibling = null; + if (prev) + prev._nextSibling = node; + if (!prev) + parent._firstChild = node; + parent._lastChild = node; + } + /** + * 7.3. If parent is a shadow host and node is a slotable, then + * assign a slot for node. + */ + if (DOMImpl_1.dom.features.slots) { + if (parent._shadowRoot !== null && util_1.Guard.isSlotable(node)) { + ShadowTreeAlgorithm_1.shadowTree_assignASlot(node); + } + } + /** + * 7.4. If node is a Text node, run the child text content change + * steps for parent. + */ + if (DOMImpl_1.dom.features.steps) { + if (util_1.Guard.isTextNode(node)) { + DOMAlgorithm_1.dom_runChildTextContentChangeSteps(parent); + } + } + /** + * 7.5. If parent's root is a shadow root, and parent is a slot + * whose assigned nodes is the empty list, then run signal + * a slot change for parent. + */ + if (DOMImpl_1.dom.features.slots) { + if (util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(parent)) && + util_1.Guard.isSlot(parent) && util_2.isEmpty(parent._assignedNodes)) { + ShadowTreeAlgorithm_1.shadowTree_signalASlotChange(parent); + } + } + /** + * 7.6. Run assign slotables for a tree with node's root. + */ + if (DOMImpl_1.dom.features.slots) { + ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(node)); + } + /** + * 7.7. For each shadow-including inclusive descendant + * inclusiveDescendant of node, in shadow-including tree + * order: + * 7.7.1. Run the insertion steps with inclusiveDescendant. + */ + if (DOMImpl_1.dom.features.steps) { + DOMAlgorithm_1.dom_runInsertionSteps(node); + } + if (DOMImpl_1.dom.features.customElements) { + /** + * 7.7.2. If inclusiveDescendant is connected, then: + */ + if (util_1.Guard.isElementNode(node) && + ShadowTreeAlgorithm_1.shadowTree_isConnected(node)) { + if (util_1.Guard.isCustomElementNode(node)) { + /** + * 7.7.2.1. If inclusiveDescendant is custom, then enqueue a custom + * element callback reaction with inclusiveDescendant, callback name + * "connectedCallback", and an empty argument list. + */ + CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(node, "connectedCallback", []); + } + else { + /** + * 7.7.2.2. Otherwise, try to upgrade inclusiveDescendant. + */ + CustomElementAlgorithm_1.customElement_tryToUpgrade(node); + } + } + } + /** + * 8. If suppress observers flag is unset, then queue a tree mutation record + * for parent with nodes, « », previousSibling, and child. + */ + if (DOMImpl_1.dom.features.mutationObservers) { + if (!suppressObservers) { + MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, [node], [], previousSibling, null); + } + } +} +/** + * Appends a node to the children of a parent node. + * + * @param node - a node + * @param parent - the parent to receive node + */ +function mutation_append(node, parent) { + /** + * To append a node to a parent, pre-insert node into parent before null. + */ + return mutation_preInsert(node, parent, null); +} +exports.mutation_append = mutation_append; +/** + * Replaces a node with another node. + * + * @param child - child node to remove + * @param node - node to insert + * @param parent - parent node to receive node + */ +function mutation_replace(child, node, parent) { + var e_6, _a, e_7, _b, e_8, _c, e_9, _d; + /** + * 1. If parent is not a Document, DocumentFragment, or Element node, + * throw a "HierarchyRequestError" DOMException. + */ + if (parent._nodeType !== interfaces_1.NodeType.Document && + parent._nodeType !== interfaces_1.NodeType.DocumentFragment && + parent._nodeType !== interfaces_1.NodeType.Element) + throw new DOMException_1.HierarchyRequestError("Only document, document fragment and element nodes can contain child nodes. Parent node is " + parent.nodeName + "."); + /** + * 2. If node is a host-including inclusive ancestor of parent, throw a + * "HierarchyRequestError" DOMException. + */ + if (TreeAlgorithm_1.tree_isHostIncludingAncestorOf(parent, node, true)) + throw new DOMException_1.HierarchyRequestError("The node to be inserted cannot be an ancestor of parent node. Node is " + node.nodeName + ", parent node is " + parent.nodeName + "."); + /** + * 3. If child’s parent is not parent, then throw a "NotFoundError" + * DOMException. + */ + if (child._parent !== parent) + throw new DOMException_1.NotFoundError("The reference child node cannot be found under parent node. Child node is " + child.nodeName + ", parent node is " + parent.nodeName + "."); + /** + * 4. If node is not a DocumentFragment, DocumentType, Element, Text, + * ProcessingInstruction, or Comment node, throw a "HierarchyRequestError" + * DOMException. + */ + if (node._nodeType !== interfaces_1.NodeType.DocumentFragment && + node._nodeType !== interfaces_1.NodeType.DocumentType && + node._nodeType !== interfaces_1.NodeType.Element && + node._nodeType !== interfaces_1.NodeType.Text && + node._nodeType !== interfaces_1.NodeType.ProcessingInstruction && + node._nodeType !== interfaces_1.NodeType.CData && + node._nodeType !== interfaces_1.NodeType.Comment) + throw new DOMException_1.HierarchyRequestError("Only document fragment, document type, element, text, processing instruction, cdata section or comment nodes can be inserted. Node is " + node.nodeName + "."); + /** + * 5. If either node is a Text node and parent is a document, or node is a + * doctype and parent is not a document, throw a "HierarchyRequestError" + * DOMException. + */ + if (node._nodeType === interfaces_1.NodeType.Text && + parent._nodeType === interfaces_1.NodeType.Document) + throw new DOMException_1.HierarchyRequestError("Cannot insert a text node as a child of a document node. Node is " + node.nodeName + "."); + if (node._nodeType === interfaces_1.NodeType.DocumentType && + parent._nodeType !== interfaces_1.NodeType.Document) + throw new DOMException_1.HierarchyRequestError("A document type node can only be inserted under a document node. Parent node is " + parent.nodeName + "."); + /** + * 6. If parent is a document, and any of the statements below, switched on + * node, are true, throw a "HierarchyRequestError" DOMException. + * - DocumentFragment node + * If node has more than one element child or has a Text node child. + * Otherwise, if node has one element child and either parent has an element + * child that is not child or a doctype is following child. + * - element + * parent has an element child that is not child or a doctype is + * following child. + * - doctype + * parent has a doctype child that is not child, or an element is + * preceding child. + */ + if (parent._nodeType === interfaces_1.NodeType.Document) { + if (node._nodeType === interfaces_1.NodeType.DocumentFragment) { + var eleCount = 0; + try { + for (var _e = __values(node._children), _f = _e.next(); !_f.done; _f = _e.next()) { + var childNode = _f.value; + if (childNode._nodeType === interfaces_1.NodeType.Element) + eleCount++; + else if (childNode._nodeType === interfaces_1.NodeType.Text) + throw new DOMException_1.HierarchyRequestError("Cannot insert text a node as a child of a document node. Node is " + childNode.nodeName + "."); + } + } + catch (e_6_1) { e_6 = { error: e_6_1 }; } + finally { + try { + if (_f && !_f.done && (_a = _e.return)) _a.call(_e); + } + finally { if (e_6) throw e_6.error; } + } + if (eleCount > 1) { + throw new DOMException_1.HierarchyRequestError("A document node can only have one document element node. Document fragment to be inserted has " + eleCount + " element nodes."); + } + else if (eleCount === 1) { + try { + for (var _g = __values(parent._children), _h = _g.next(); !_h.done; _h = _g.next()) { + var ele = _h.value; + if (ele._nodeType === interfaces_1.NodeType.Element && ele !== child) + throw new DOMException_1.HierarchyRequestError("The document node already has a document element node."); + } + } + catch (e_7_1) { e_7 = { error: e_7_1 }; } + finally { + try { + if (_h && !_h.done && (_b = _g.return)) _b.call(_g); + } + finally { if (e_7) throw e_7.error; } + } + var doctypeChild = child._nextSibling; + while (doctypeChild) { + if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType) + throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node."); + doctypeChild = doctypeChild._nextSibling; + } + } + } + else if (node._nodeType === interfaces_1.NodeType.Element) { + try { + for (var _j = __values(parent._children), _k = _j.next(); !_k.done; _k = _j.next()) { + var ele = _k.value; + if (ele._nodeType === interfaces_1.NodeType.Element && ele !== child) + throw new DOMException_1.HierarchyRequestError("Document already has a document element node. Node is " + node.nodeName + "."); + } + } + catch (e_8_1) { e_8 = { error: e_8_1 }; } + finally { + try { + if (_k && !_k.done && (_c = _j.return)) _c.call(_j); + } + finally { if (e_8) throw e_8.error; } + } + var doctypeChild = child._nextSibling; + while (doctypeChild) { + if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType) + throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node. Node is " + node.nodeName + "."); + doctypeChild = doctypeChild._nextSibling; + } + } + else if (node._nodeType === interfaces_1.NodeType.DocumentType) { + try { + for (var _l = __values(parent._children), _m = _l.next(); !_m.done; _m = _l.next()) { + var ele = _m.value; + if (ele._nodeType === interfaces_1.NodeType.DocumentType && ele !== child) + throw new DOMException_1.HierarchyRequestError("Document already has a document type node. Node is " + node.nodeName + "."); + } + } + catch (e_9_1) { e_9 = { error: e_9_1 }; } + finally { + try { + if (_m && !_m.done && (_d = _l.return)) _d.call(_l); + } + finally { if (e_9) throw e_9.error; } + } + var elementChild = child._previousSibling; + while (elementChild) { + if (elementChild._nodeType === interfaces_1.NodeType.Element) + throw new DOMException_1.HierarchyRequestError("Cannot insert a document type node before an element node. Node is " + node.nodeName + "."); + elementChild = elementChild._previousSibling; + } + } + } + /** + * 7. Let reference child be child’s next sibling. + * 8. If reference child is node, set it to node’s next sibling. + * 8. Let previousSibling be child’s previous sibling. + */ + var referenceChild = child._nextSibling; + if (referenceChild === node) + referenceChild = node._nextSibling; + var previousSibling = child._previousSibling; + /** + * 10. Adopt node into parent’s node document. + * 11. Let removedNodes be the empty list. + */ + DocumentAlgorithm_1.document_adopt(node, parent._nodeDocument); + var removedNodes = []; + /** + * 12. If child’s parent is not null, then: + */ + if (child._parent !== null) { + /** + * 12.1. Set removedNodes to [child]. + * 12.2. Remove child from its parent with the suppress observers flag + * set. + */ + removedNodes.push(child); + mutation_remove(child, child._parent, true); + } + /** + * 13. Let nodes be node’s children if node is a DocumentFragment node; + * otherwise [node]. + */ + var nodes = []; + if (node._nodeType === interfaces_1.NodeType.DocumentFragment) { + nodes = Array.from(node._children); + } + else { + nodes.push(node); + } + /** + * 14. Insert node into parent before reference child with the suppress + * observers flag set. + */ + mutation_insert(node, parent, referenceChild, true); + /** + * 15. Queue a tree mutation record for parent with nodes, removedNodes, + * previousSibling, and reference child. + */ + if (DOMImpl_1.dom.features.mutationObservers) { + MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, nodes, removedNodes, previousSibling, referenceChild); + } + /** + * 16. Return child. + */ + return child; +} +exports.mutation_replace = mutation_replace; +/** + * Replaces all nodes of a parent with the given node. + * + * @param node - node to insert + * @param parent - parent node to receive node + */ +function mutation_replaceAll(node, parent) { + var e_10, _a; + /** + * 1. If node is not null, adopt node into parent’s node document. + */ + if (node !== null) { + DocumentAlgorithm_1.document_adopt(node, parent._nodeDocument); + } + /** + * 2. Let removedNodes be parent’s children. + */ + var removedNodes = Array.from(parent._children); + /** + * 3. Let addedNodes be the empty list. + * 4. If node is DocumentFragment node, then set addedNodes to node’s + * children. + * 5. Otherwise, if node is non-null, set addedNodes to [node]. + */ + var addedNodes = []; + if (node && node._nodeType === interfaces_1.NodeType.DocumentFragment) { + addedNodes = Array.from(node._children); + } + else if (node !== null) { + addedNodes.push(node); + } + try { + /** + * 6. Remove all parent’s children, in tree order, with the suppress + * observers flag set. + */ + for (var removedNodes_1 = __values(removedNodes), removedNodes_1_1 = removedNodes_1.next(); !removedNodes_1_1.done; removedNodes_1_1 = removedNodes_1.next()) { + var childNode = removedNodes_1_1.value; + mutation_remove(childNode, parent, true); + } + } + catch (e_10_1) { e_10 = { error: e_10_1 }; } + finally { + try { + if (removedNodes_1_1 && !removedNodes_1_1.done && (_a = removedNodes_1.return)) _a.call(removedNodes_1); + } + finally { if (e_10) throw e_10.error; } + } + /** + * 7. If node is not null, then insert node into parent before null with the + * suppress observers flag set. + */ + if (node !== null) { + mutation_insert(node, parent, null, true); + } + /** + * 8. Queue a tree mutation record for parent with addedNodes, removedNodes, + * null, and null. + */ + if (DOMImpl_1.dom.features.mutationObservers) { + MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, addedNodes, removedNodes, null, null); + } +} +exports.mutation_replaceAll = mutation_replaceAll; +/** + * Ensures pre-removal validity of a child node from a parent, then + * removes it. + * + * @param child - child node to remove + * @param parent - parent node + */ +function mutation_preRemove(child, parent) { + /** + * 1. If child’s parent is not parent, then throw a "NotFoundError" + * DOMException. + * 2. Remove child from parent. + * 3. Return child. + */ + if (child._parent !== parent) + throw new DOMException_1.NotFoundError("The child node cannot be found under parent node. Child node is " + child.nodeName + ", parent node is " + parent.nodeName + "."); + mutation_remove(child, parent); + return child; +} +exports.mutation_preRemove = mutation_preRemove; +/** + * Removes a child node from its parent. + * + * @param node - node to remove + * @param parent - parent node + * @param suppressObservers - whether to notify observers + */ +function mutation_remove(node, parent, suppressObservers) { + var e_11, _a, e_12, _b, e_13, _c, e_14, _d; + if (DOMImpl_1.dom.rangeList.size !== 0) { + /** + * 1. Let index be node’s index. + */ + var index = TreeAlgorithm_1.tree_index(node); + try { + /** + * 2. For each live range whose start node is an inclusive descendant of + * node, set its start to (parent, index). + * 3. For each live range whose end node is an inclusive descendant of + * node, set its end to (parent, index). + */ + for (var _e = __values(DOMImpl_1.dom.rangeList), _f = _e.next(); !_f.done; _f = _e.next()) { + var range = _f.value; + if (TreeAlgorithm_1.tree_isDescendantOf(node, range._start[0], true)) { + range._start = [parent, index]; + } + if (TreeAlgorithm_1.tree_isDescendantOf(node, range._end[0], true)) { + range._end = [parent, index]; + } + if (range._start[0] === parent && range._start[1] > index) { + range._start[1]--; + } + if (range._end[0] === parent && range._end[1] > index) { + range._end[1]--; + } + } + } + catch (e_11_1) { e_11 = { error: e_11_1 }; } + finally { + try { + if (_f && !_f.done && (_a = _e.return)) _a.call(_e); + } + finally { if (e_11) throw e_11.error; } + } + try { + /** + * 4. For each live range whose start node is parent and start offset is + * greater than index, decrease its start offset by 1. + * 5. For each live range whose end node is parent and end offset is greater + * than index, decrease its end offset by 1. + */ + for (var _g = __values(DOMImpl_1.dom.rangeList), _h = _g.next(); !_h.done; _h = _g.next()) { + var range = _h.value; + if (range._start[0] === parent && range._start[1] > index) { + range._start[1] -= 1; + } + if (range._end[0] === parent && range._end[1] > index) { + range._end[1] -= 1; + } + } + } + catch (e_12_1) { e_12 = { error: e_12_1 }; } + finally { + try { + if (_h && !_h.done && (_b = _g.return)) _b.call(_g); + } + finally { if (e_12) throw e_12.error; } + } + } + /** + * 6. For each NodeIterator object iterator whose root’s node document is + * node’s node document, run the NodeIterator pre-removing steps given node + * and iterator. + */ + if (DOMImpl_1.dom.features.steps) { + try { + for (var _j = __values(NodeIteratorAlgorithm_1.nodeIterator_iteratorList()), _k = _j.next(); !_k.done; _k = _j.next()) { + var iterator = _k.value; + if (iterator._root._nodeDocument === node._nodeDocument) { + DOMAlgorithm_1.dom_runNodeIteratorPreRemovingSteps(iterator, node); + } + } + } + catch (e_13_1) { e_13 = { error: e_13_1 }; } + finally { + try { + if (_k && !_k.done && (_c = _j.return)) _c.call(_j); + } + finally { if (e_13) throw e_13.error; } + } + } + /** + * 7. Let oldPreviousSibling be node’s previous sibling. + * 8. Let oldNextSibling be node’s next sibling. + */ + var oldPreviousSibling = node._previousSibling; + var oldNextSibling = node._nextSibling; + // set document element node + if (util_1.Guard.isDocumentNode(parent) && util_1.Guard.isElementNode(node)) { + parent._documentElement = null; + } + /** + * 9. Remove node from its parent’s children. + */ + node._parent = null; + parent._children.delete(node); + // assign siblings and children for quick lookups + var prev = node._previousSibling; + var next = node._nextSibling; + node._previousSibling = null; + node._nextSibling = null; + if (prev) + prev._nextSibling = next; + if (next) + next._previousSibling = prev; + if (!prev) + parent._firstChild = next; + if (!next) + parent._lastChild = prev; + /** + * 10. If node is assigned, then run assign slotables for node’s assigned + * slot. + */ + if (DOMImpl_1.dom.features.slots) { + if (util_1.Guard.isSlotable(node) && node._assignedSlot !== null && ShadowTreeAlgorithm_1.shadowTree_isAssigned(node)) { + ShadowTreeAlgorithm_1.shadowTree_assignSlotables(node._assignedSlot); + } + } + /** + * 11. If parent’s root is a shadow root, and parent is a slot whose + * assigned nodes is the empty list, then run signal a slot change for + * parent. + */ + if (DOMImpl_1.dom.features.slots) { + if (util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(parent)) && + util_1.Guard.isSlot(parent) && util_2.isEmpty(parent._assignedNodes)) { + ShadowTreeAlgorithm_1.shadowTree_signalASlotChange(parent); + } + } + /** + * 12. If node has an inclusive descendant that is a slot, then: + * 12.1. Run assign slotables for a tree with parent's root. + * 12.2. Run assign slotables for a tree with node. + */ + if (DOMImpl_1.dom.features.slots) { + var descendant_1 = TreeAlgorithm_1.tree_getFirstDescendantNode(node, true, false, function (e) { return util_1.Guard.isSlot(e); }); + if (descendant_1 !== null) { + ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(parent)); + ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(node); + } + } + /** + * 13. Run the removing steps with node and parent. + */ + if (DOMImpl_1.dom.features.steps) { + DOMAlgorithm_1.dom_runRemovingSteps(node, parent); + } + /** + * 14. If node is custom, then enqueue a custom element callback + * reaction with node, callback name "disconnectedCallback", + * and an empty argument list. + */ + if (DOMImpl_1.dom.features.customElements) { + if (util_1.Guard.isCustomElementNode(node)) { + CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(node, "disconnectedCallback", []); + } + } + /** + * 15. For each shadow-including descendant descendant of node, + * in shadow-including tree order, then: + */ + var descendant = TreeAlgorithm_1.tree_getFirstDescendantNode(node, false, true); + while (descendant !== null) { + /** + * 15.1. Run the removing steps with descendant. + */ + if (DOMImpl_1.dom.features.steps) { + DOMAlgorithm_1.dom_runRemovingSteps(descendant, node); + } + /** + * 15.2. If descendant is custom, then enqueue a custom element + * callback reaction with descendant, callback name + * "disconnectedCallback", and an empty argument list. + */ + if (DOMImpl_1.dom.features.customElements) { + if (util_1.Guard.isCustomElementNode(descendant)) { + CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(descendant, "disconnectedCallback", []); + } + } + descendant = TreeAlgorithm_1.tree_getNextDescendantNode(node, descendant, false, true); + } + /** + * 16. For each inclusive ancestor inclusiveAncestor of parent, and + * then for each registered of inclusiveAncestor's registered + * observer list, if registered's options's subtree is true, + * then append a new transient registered observer whose + * observer is registered's observer, options is registered's + * options, and source is registered to node's registered + * observer list. + */ + if (DOMImpl_1.dom.features.mutationObservers) { + var inclusiveAncestor = TreeAlgorithm_1.tree_getFirstAncestorNode(parent, true); + while (inclusiveAncestor !== null) { + try { + for (var _l = (e_14 = void 0, __values(inclusiveAncestor._registeredObserverList)), _m = _l.next(); !_m.done; _m = _l.next()) { + var registered = _m.value; + if (registered.options.subtree) { + node._registeredObserverList.push({ + observer: registered.observer, + options: registered.options, + source: registered + }); + } + } + } + catch (e_14_1) { e_14 = { error: e_14_1 }; } + finally { + try { + if (_m && !_m.done && (_d = _l.return)) _d.call(_l); + } + finally { if (e_14) throw e_14.error; } + } + inclusiveAncestor = TreeAlgorithm_1.tree_getNextAncestorNode(parent, inclusiveAncestor, true); + } + } + /** + * 17. If suppress observers flag is unset, then queue a tree mutation + * record for parent with « », « node », oldPreviousSibling, and + * oldNextSibling. + */ + if (DOMImpl_1.dom.features.mutationObservers) { + if (!suppressObservers) { + MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, [], [node], oldPreviousSibling, oldNextSibling); + } + } + /** + * 18. If node is a Text node, then run the child text content change steps + * for parent. + */ + if (DOMImpl_1.dom.features.steps) { + if (util_1.Guard.isTextNode(node)) { + DOMAlgorithm_1.dom_runChildTextContentChangeSteps(parent); + } + } +} +exports.mutation_remove = mutation_remove; +//# sourceMappingURL=MutationAlgorithm.js.map + +/***/ }), +/* 480 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) +const validRange = (range, options) => { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range(range, options).range || '*' + } catch (er) { + return null + } +} +module.exports = validRange + + +/***/ }), +/* 481 */, +/* 482 */, +/* 483 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var DOMException_1 = __webpack_require__(35); +/** + * Matches elements with the given selectors. + * + * @param selectors - selectors + * @param node - the node to match against + */ +function selectors_scopeMatchASelectorsString(selectors, node) { + /** + * TODO: Selectors + * 1. Let s be the result of parse a selector selectors. [SELECTORS4] + * 2. If s is failure, then throw a "SyntaxError" DOMException. + * 3. Return the result of match a selector against a tree with s and node’s + * root using scoping root node. [SELECTORS4]. + */ + throw new DOMException_1.NotSupportedError(); +} +exports.selectors_scopeMatchASelectorsString = selectors_scopeMatchASelectorsString; +//# sourceMappingURL=SelectorsAlgorithm.js.map + +/***/ }), +/* 484 */, +/* 485 */, +/* 486 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const gt = (a, b, loose) => compare(a, b, loose) > 0 +module.exports = gt + + +/***/ }), +/* 487 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var interfaces_1 = __webpack_require__(970); +/** + * Represents an object which can be used to iterate through the nodes + * of a subtree. + */ +var TraverserImpl = /** @class */ (function () { + /** + * Initializes a new instance of `Traverser`. + * + * @param root - root node + */ + function TraverserImpl(root) { + this._activeFlag = false; + this._root = root; + this._whatToShow = interfaces_1.WhatToShow.All; + this._filter = null; + } + Object.defineProperty(TraverserImpl.prototype, "root", { + /** @inheritdoc */ + get: function () { return this._root; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TraverserImpl.prototype, "whatToShow", { + /** @inheritdoc */ + get: function () { return this._whatToShow; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TraverserImpl.prototype, "filter", { + /** @inheritdoc */ + get: function () { return this._filter; }, + enumerable: true, + configurable: true + }); + return TraverserImpl; +}()); +exports.TraverserImpl = TraverserImpl; +//# sourceMappingURL=TraverserImpl.js.map + +/***/ }), +/* 488 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var DOMImpl_1 = __webpack_require__(648); +var interfaces_1 = __webpack_require__(970); +var DOMException_1 = __webpack_require__(35); +var NodeImpl_1 = __webpack_require__(935); +var util_1 = __webpack_require__(918); +var util_2 = __webpack_require__(592); +var infra_1 = __webpack_require__(23); +var URLAlgorithm_1 = __webpack_require__(813); +var algorithm_1 = __webpack_require__(163); +var WebIDLAlgorithm_1 = __webpack_require__(495); +/** + * Represents a document node. + */ +var DocumentImpl = /** @class */ (function (_super) { + __extends(DocumentImpl, _super); + /** + * Initializes a new instance of `Document`. + */ + function DocumentImpl() { + var _this = _super.call(this) || this; + _this._children = new Set(); + _this._encoding = { + name: "UTF-8", + labels: ["unicode-1-1-utf-8", "utf-8", "utf8"] + }; + _this._contentType = 'application/xml'; + _this._URL = { + scheme: "about", + username: "", + password: "", + host: null, + port: null, + path: ["blank"], + query: null, + fragment: null, + _cannotBeABaseURLFlag: true, + _blobURLEntry: null + }; + _this._origin = null; + _this._type = "xml"; + _this._mode = "no-quirks"; + _this._documentElement = null; + _this._hasNamespaces = false; + _this._nodeDocumentOverwrite = null; + return _this; + } + Object.defineProperty(DocumentImpl.prototype, "_nodeDocument", { + get: function () { return this._nodeDocumentOverwrite || this; }, + set: function (val) { this._nodeDocumentOverwrite = val; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "implementation", { + /** @inheritdoc */ + get: function () { + /** + * The implementation attribute’s getter must return the DOMImplementation + * object that is associated with the document. + */ + return this._implementation || (this._implementation = algorithm_1.create_domImplementation(this)); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "URL", { + /** @inheritdoc */ + get: function () { + /** + * The URL attribute’s getter and documentURI attribute’s getter must return + * the URL, serialized. + * See: https://url.spec.whatwg.org/#concept-url-serializer + */ + return URLAlgorithm_1.urlSerializer(this._URL); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "documentURI", { + /** @inheritdoc */ + get: function () { return this.URL; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "origin", { + /** @inheritdoc */ + get: function () { + return "null"; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "compatMode", { + /** @inheritdoc */ + get: function () { + /** + * The compatMode attribute’s getter must return "BackCompat" if context + * object’s mode is "quirks", and "CSS1Compat" otherwise. + */ + return this._mode === "quirks" ? "BackCompat" : "CSS1Compat"; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "characterSet", { + /** @inheritdoc */ + get: function () { + /** + * The characterSet attribute’s getter, charset attribute’s getter, and + * inputEncoding attribute’s getter, must return context object’s + * encoding’s name. + */ + return this._encoding.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "charset", { + /** @inheritdoc */ + get: function () { return this._encoding.name; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "inputEncoding", { + /** @inheritdoc */ + get: function () { return this._encoding.name; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "contentType", { + /** @inheritdoc */ + get: function () { + /** + * The contentType attribute’s getter must return the content type. + */ + return this._contentType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "doctype", { + /** @inheritdoc */ + get: function () { + var e_1, _a; + try { + /** + * The doctype attribute’s getter must return the child of the document + * that is a doctype, and null otherwise. + */ + for (var _b = __values(this._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var child = _c.value; + if (util_1.Guard.isDocumentTypeNode(child)) + return child; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + return null; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "documentElement", { + /** @inheritdoc */ + get: function () { + /** + * The documentElement attribute’s getter must return the document element. + */ + return this._documentElement; + }, + enumerable: true, + configurable: true + }); + /** @inheritdoc */ + DocumentImpl.prototype.getElementsByTagName = function (qualifiedName) { + /** + * The getElementsByTagName(qualifiedName) method, when invoked, must return + * the list of elements with qualified name qualifiedName for the context object. + */ + return algorithm_1.node_listOfElementsWithQualifiedName(qualifiedName, this); + }; + /** @inheritdoc */ + DocumentImpl.prototype.getElementsByTagNameNS = function (namespace, localName) { + /** + * The getElementsByTagNameNS(namespace, localName) method, when invoked, + * must return the list of elements with namespace namespace and local name + * localName for the context object. + */ + return algorithm_1.node_listOfElementsWithNamespace(namespace, localName, this); + }; + /** @inheritdoc */ + DocumentImpl.prototype.getElementsByClassName = function (classNames) { + /** + * The getElementsByClassName(classNames) method, when invoked, must return + * the list of elements with class names classNames for the context object. + */ + return algorithm_1.node_listOfElementsWithClassNames(classNames, this); + }; + /** @inheritdoc */ + DocumentImpl.prototype.createElement = function (localName, options) { + /** + * 1. If localName does not match the Name production, then throw an + * "InvalidCharacterError" DOMException. + * 2. If the context object is an HTML document, then set localName to + * localName in ASCII lowercase. + * 3. Let is be null. + * 4. If options is a dictionary and options’s is is present, then set is + * to it. + * 5. Let namespace be the HTML namespace, if the context object is an + * HTML document or context object’s content type is + * "application/xhtml+xml", and null otherwise. + * 6. Return the result of creating an element given the context object, + * localName, namespace, null, is, and with the synchronous custom elements + * flag set. + */ + if (!algorithm_1.xml_isName(localName)) + throw new DOMException_1.InvalidCharacterError(); + if (this._type === "html") + localName = localName.toLowerCase(); + var is = null; + if (options !== undefined) { + if (util_2.isString(options)) { + is = options; + } + else { + is = options.is; + } + } + var namespace = (this._type === "html" || this._contentType === "application/xhtml+xml") ? + infra_1.namespace.HTML : null; + return algorithm_1.element_createAnElement(this, localName, namespace, null, is, true); + }; + /** @inheritdoc */ + DocumentImpl.prototype.createElementNS = function (namespace, qualifiedName, options) { + /** + * The createElementNS(namespace, qualifiedName, options) method, when + * invoked, must return the result of running the internal createElementNS + * steps, given context object, namespace, qualifiedName, and options. + */ + return algorithm_1.document_internalCreateElementNS(this, namespace, qualifiedName, options); + }; + /** @inheritdoc */ + DocumentImpl.prototype.createDocumentFragment = function () { + /** + * The createDocumentFragment() method, when invoked, must return a new + * DocumentFragment node with its node document set to the context object. + */ + return algorithm_1.create_documentFragment(this); + }; + /** @inheritdoc */ + DocumentImpl.prototype.createTextNode = function (data) { + /** + * The createTextNode(data) method, when invoked, must return a new Text + * node with its data set to data and node document set to the context object. + */ + return algorithm_1.create_text(this, data); + }; + /** @inheritdoc */ + DocumentImpl.prototype.createCDATASection = function (data) { + /** + * 1. If context object is an HTML document, then throw a + * "NotSupportedError" DOMException. + * 2. If data contains the string "]]>", then throw an + * "InvalidCharacterError" DOMException. + * 3. Return a new CDATASection node with its data set to data and node + * document set to the context object. + */ + if (this._type === "html") + throw new DOMException_1.NotSupportedError(); + if (data.indexOf(']]>') !== -1) + throw new DOMException_1.InvalidCharacterError(); + return algorithm_1.create_cdataSection(this, data); + }; + /** @inheritdoc */ + DocumentImpl.prototype.createComment = function (data) { + /** + * The createComment(data) method, when invoked, must return a new Comment + * node with its data set to data and node document set to the context object. + */ + return algorithm_1.create_comment(this, data); + }; + /** @inheritdoc */ + DocumentImpl.prototype.createProcessingInstruction = function (target, data) { + /** + * 1. If target does not match the Name production, then throw an + * "InvalidCharacterError" DOMException. + * 2. If data contains the string "?>", then throw an + * "InvalidCharacterError" DOMException. + * 3. Return a new ProcessingInstruction node, with target set to target, + * data set to data, and node document set to the context object. + */ + if (!algorithm_1.xml_isName(target)) + throw new DOMException_1.InvalidCharacterError(); + if (data.indexOf("?>") !== -1) + throw new DOMException_1.InvalidCharacterError(); + return algorithm_1.create_processingInstruction(this, target, data); + }; + /** @inheritdoc */ + DocumentImpl.prototype.importNode = function (node, deep) { + if (deep === void 0) { deep = false; } + /** + * 1. If node is a document or shadow root, then throw a "NotSupportedError" DOMException. + */ + if (util_1.Guard.isDocumentNode(node) || util_1.Guard.isShadowRoot(node)) + throw new DOMException_1.NotSupportedError(); + /** + * 2. Return a clone of node, with context object and the clone children flag set if deep is true. + */ + return algorithm_1.node_clone(node, this, deep); + }; + /** @inheritdoc */ + DocumentImpl.prototype.adoptNode = function (node) { + /** + * 1. If node is a document, then throw a "NotSupportedError" DOMException. + */ + if (util_1.Guard.isDocumentNode(node)) + throw new DOMException_1.NotSupportedError(); + /** + * 2. If node is a shadow root, then throw a "HierarchyRequestError" DOMException. + */ + if (util_1.Guard.isShadowRoot(node)) + throw new DOMException_1.HierarchyRequestError(); + /** + * 3. Adopt node into the context object. + * 4. Return node. + */ + algorithm_1.document_adopt(node, this); + return node; + }; + /** @inheritdoc */ + DocumentImpl.prototype.createAttribute = function (localName) { + /** + * 1. If localName does not match the Name production in XML, then throw + * an "InvalidCharacterError" DOMException. + * 2. If the context object is an HTML document, then set localName to + * localName in ASCII lowercase. + * 3. Return a new attribute whose local name is localName and node document + * is context object. + */ + if (!algorithm_1.xml_isName(localName)) + throw new DOMException_1.InvalidCharacterError(); + if (this._type === "html") { + localName = localName.toLowerCase(); + } + var attr = algorithm_1.create_attr(this, localName); + return attr; + }; + /** @inheritdoc */ + DocumentImpl.prototype.createAttributeNS = function (namespace, qualifiedName) { + /** + * 1. Let namespace, prefix, and localName be the result of passing + * namespace and qualifiedName to validate and extract. + * 2. Return a new attribute whose namespace is namespace, namespace prefix + * is prefix, local name is localName, and node document is context object. + */ + var _a = __read(algorithm_1.namespace_validateAndExtract(namespace, qualifiedName), 3), ns = _a[0], prefix = _a[1], localName = _a[2]; + var attr = algorithm_1.create_attr(this, localName); + attr._namespace = ns; + attr._namespacePrefix = prefix; + return attr; + }; + /** @inheritdoc */ + DocumentImpl.prototype.createEvent = function (eventInterface) { + return algorithm_1.event_createLegacyEvent(eventInterface); + }; + /** @inheritdoc */ + DocumentImpl.prototype.createRange = function () { + /** + * The createRange() method, when invoked, must return a new live range + * with (context object, 0) as its start and end. + */ + var range = algorithm_1.create_range(); + range._start = [this, 0]; + range._end = [this, 0]; + return range; + }; + /** @inheritdoc */ + DocumentImpl.prototype.createNodeIterator = function (root, whatToShow, filter) { + if (whatToShow === void 0) { whatToShow = interfaces_1.WhatToShow.All; } + if (filter === void 0) { filter = null; } + /** + * 1. Let iterator be a new NodeIterator object. + * 2. Set iterator’s root and iterator’s reference to root. + * 3. Set iterator’s pointer before reference to true. + * 4. Set iterator’s whatToShow to whatToShow. + * 5. Set iterator’s filter to filter. + * 6. Return iterator. + */ + var iterator = algorithm_1.create_nodeIterator(root, root, true); + iterator._whatToShow = whatToShow; + iterator._iteratorCollection = algorithm_1.create_nodeList(root); + if (util_2.isFunction(filter)) { + iterator._filter = algorithm_1.create_nodeFilter(); + iterator._filter.acceptNode = filter; + } + else { + iterator._filter = filter; + } + return iterator; + }; + /** @inheritdoc */ + DocumentImpl.prototype.createTreeWalker = function (root, whatToShow, filter) { + if (whatToShow === void 0) { whatToShow = interfaces_1.WhatToShow.All; } + if (filter === void 0) { filter = null; } + /** + * 1. Let walker be a new TreeWalker object. + * 2. Set walker’s root and walker’s current to root. + * 3. Set walker’s whatToShow to whatToShow. + * 4. Set walker’s filter to filter. + * 5. Return walker. + */ + var walker = algorithm_1.create_treeWalker(root, root); + walker._whatToShow = whatToShow; + if (util_2.isFunction(filter)) { + walker._filter = algorithm_1.create_nodeFilter(); + walker._filter.acceptNode = filter; + } + else { + walker._filter = filter; + } + return walker; + }; + /** + * Gets the parent event target for the given event. + * + * @param event - an event + */ + DocumentImpl.prototype._getTheParent = function (event) { + /** + * TODO: Implement realms + * A document’s get the parent algorithm, given an event, returns null if + * event’s type attribute value is "load" or document does not have a + * browsing context, and the document’s relevant global object otherwise. + */ + if (event._type === "load") { + return null; + } + else { + return DOMImpl_1.dom.window; + } + }; + // MIXIN: NonElementParentNode + /* istanbul ignore next */ + DocumentImpl.prototype.getElementById = function (elementId) { throw new Error("Mixin: NonElementParentNode not implemented."); }; + Object.defineProperty(DocumentImpl.prototype, "children", { + // MIXIN: DocumentOrShadowRoot + // No elements + // MIXIN: ParentNode + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "firstElementChild", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "lastElementChild", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentImpl.prototype, "childElementCount", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + /* istanbul ignore next */ + DocumentImpl.prototype.prepend = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ParentNode not implemented."); + }; + /* istanbul ignore next */ + DocumentImpl.prototype.append = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ParentNode not implemented."); + }; + /* istanbul ignore next */ + DocumentImpl.prototype.querySelector = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); }; + /* istanbul ignore next */ + DocumentImpl.prototype.querySelectorAll = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); }; + return DocumentImpl; +}(NodeImpl_1.NodeImpl)); +exports.DocumentImpl = DocumentImpl; +/** + * Initialize prototype properties + */ +WebIDLAlgorithm_1.idl_defineConst(DocumentImpl.prototype, "_nodeType", interfaces_1.NodeType.Document); +//# sourceMappingURL=DocumentImpl.js.map + +/***/ }), +/* 489 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const patch = (a, loose) => new SemVer(a, loose).patch +module.exports = patch + + +/***/ }), +/* 490 */, +/* 491 */, +/* 492 */, +/* 493 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var DOMImpl_1 = __webpack_require__(648); +var util_1 = __webpack_require__(918); +var util_2 = __webpack_require__(592); +var ElementImpl_1 = __webpack_require__(695); +var CustomElementAlgorithm_1 = __webpack_require__(344); +var TreeAlgorithm_1 = __webpack_require__(873); +var NamespaceAlgorithm_1 = __webpack_require__(664); +var DOMAlgorithm_1 = __webpack_require__(304); +var ElementAlgorithm_1 = __webpack_require__(33); +var MutationAlgorithm_1 = __webpack_require__(479); +/** + * Returns an element interface for the given name and namespace. + * + * @param name - element name + * @param namespace - namespace + */ +function document_elementInterface(name, namespace) { + return ElementImpl_1.ElementImpl; +} +exports.document_elementInterface = document_elementInterface; +/** + * Creates a new element node. + * See: https://dom.spec.whatwg.org/#internal-createelementns-steps + * + * @param document - owner document + * @param namespace - element namespace + * @param qualifiedName - qualified name + * @param options - element options + */ +function document_internalCreateElementNS(document, namespace, qualifiedName, options) { + /** + * 1. Let namespace, prefix, and localName be the result of passing + * namespace and qualifiedName to validate and extract. + * 2. Let is be null. + * 3. If options is a dictionary and options’s is is present, then set + * is to it. + * 4. Return the result of creating an element given document, localName, + * namespace, prefix, is, and with the synchronous custom elements flag set. + */ + var _a = __read(NamespaceAlgorithm_1.namespace_validateAndExtract(namespace, qualifiedName), 3), ns = _a[0], prefix = _a[1], localName = _a[2]; + var is = null; + if (options !== undefined) { + if (util_2.isString(options)) { + is = options; + } + else { + is = options.is; + } + } + return ElementAlgorithm_1.element_createAnElement(document, localName, ns, prefix, is, true); +} +exports.document_internalCreateElementNS = document_internalCreateElementNS; +/** + * Removes `node` and its subtree from its document and changes + * its owner document to `document` so that it can be inserted + * into `document`. + * + * @param node - the node to move + * @param document - document to receive the node and its subtree + */ +function document_adopt(node, document) { + var e_1, _a; + // Optimize for common case of inserting a fresh node + if (node._nodeDocument === document && node._parent === null) { + return; + } + /** + * 1. Let oldDocument be node’s node document. + * 2. If node’s parent is not null, remove node from its parent. + */ + var oldDocument = node._nodeDocument; + if (node._parent) + MutationAlgorithm_1.mutation_remove(node, node._parent); + /** + * 3. If document is not oldDocument, then: + */ + if (document !== oldDocument) { + /** + * 3.1. For each inclusiveDescendant in node’s shadow-including inclusive + * descendants: + */ + var inclusiveDescendant = TreeAlgorithm_1.tree_getFirstDescendantNode(node, true, true); + while (inclusiveDescendant !== null) { + /** + * 3.1.1. Set inclusiveDescendant’s node document to document. + * 3.1.2. If inclusiveDescendant is an element, then set the node + * document of each attribute in inclusiveDescendant’s attribute list + * to document. + */ + inclusiveDescendant._nodeDocument = document; + if (util_1.Guard.isElementNode(inclusiveDescendant)) { + try { + for (var _b = (e_1 = void 0, __values(inclusiveDescendant._attributeList._asArray())), _c = _b.next(); !_c.done; _c = _b.next()) { + var attr = _c.value; + attr._nodeDocument = document; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + } + /** + * 3.2. For each inclusiveDescendant in node's shadow-including + * inclusive descendants that is custom, enqueue a custom + * element callback reaction with inclusiveDescendant, + * callback name "adoptedCallback", and an argument list + * containing oldDocument and document. + */ + if (DOMImpl_1.dom.features.customElements) { + if (util_1.Guard.isElementNode(inclusiveDescendant) && + inclusiveDescendant._customElementState === "custom") { + CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(inclusiveDescendant, "adoptedCallback", [oldDocument, document]); + } + } + /** + * 3.3. For each inclusiveDescendant in node’s shadow-including + * inclusive descendants, in shadow-including tree order, run the + * adopting steps with inclusiveDescendant and oldDocument. + */ + if (DOMImpl_1.dom.features.steps) { + DOMAlgorithm_1.dom_runAdoptingSteps(inclusiveDescendant, oldDocument); + } + inclusiveDescendant = TreeAlgorithm_1.tree_getNextDescendantNode(node, inclusiveDescendant, true, true); + } + } +} +exports.document_adopt = document_adopt; +//# sourceMappingURL=DocumentAlgorithm.js.map + +/***/ }), +/* 494 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +var rng = __webpack_require__(58); +var bytesToUuid = __webpack_require__(722); + +function v4(options, buf, offset) { + var i = buf && offset || 0; + + if (typeof(options) == 'string') { + buf = options === 'binary' ? new Array(16) : null; + options = null; + } + options = options || {}; + + var rnds = options.random || (options.rng || rng)(); + + // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` + rnds[6] = (rnds[6] & 0x0f) | 0x40; + rnds[8] = (rnds[8] & 0x3f) | 0x80; + + // Copy bytes to buffer, if provided + if (buf) { + for (var ii = 0; ii < 16; ++ii) { + buf[i + ii] = rnds[ii]; + } + } + + return buf || bytesToUuid(rnds); +} + +module.exports = v4; + + +/***/ }), +/* 495 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Defines a WebIDL `Const` property on the given object. + * + * @param o - object on which to add the property + * @param name - property name + * @param value - property value + */ +function idl_defineConst(o, name, value) { + Object.defineProperty(o, name, { writable: false, enumerable: true, configurable: false, value: value }); +} +exports.idl_defineConst = idl_defineConst; +//# sourceMappingURL=WebIDLAlgorithm.js.map + +/***/ }), +/* 496 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var util_1 = __webpack_require__(592); +/** + * Adds the given item to the end of the set. + * + * @param set - a set + * @param item - an item + */ +function append(set, item) { + set.add(item); +} +exports.append = append; +/** + * Extends a set by appending all items from another set. + * + * @param setA - a list to extend + * @param setB - a list containing items to append to `setA` + */ +function extend(setA, setB) { + setB.forEach(setA.add, setA); +} +exports.extend = extend; +/** + * Inserts the given item to the start of the set. + * + * @param set - a set + * @param item - an item + */ +function prepend(set, item) { + var cloned = new Set(set); + set.clear(); + set.add(item); + cloned.forEach(set.add, set); +} +exports.prepend = prepend; +/** + * Replaces the given item or all items matching condition with a new item. + * + * @param set - a set + * @param conditionOrItem - an item to replace or a condition matching items + * to replace + * @param item - an item + */ +function replace(set, conditionOrItem, newItem) { + var e_1, _a; + var newSet = new Set(); + try { + for (var set_1 = __values(set), set_1_1 = set_1.next(); !set_1_1.done; set_1_1 = set_1.next()) { + var oldItem = set_1_1.value; + if (util_1.isFunction(conditionOrItem)) { + if (!!conditionOrItem.call(null, oldItem)) { + newSet.add(newItem); + } + else { + newSet.add(oldItem); + } + } + else if (oldItem === conditionOrItem) { + newSet.add(newItem); + } + else { + newSet.add(oldItem); + } + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (set_1_1 && !set_1_1.done && (_a = set_1.return)) _a.call(set_1); + } + finally { if (e_1) throw e_1.error; } + } + set.clear(); + newSet.forEach(set.add, set); +} +exports.replace = replace; +/** + * Inserts the given item before the given index. + * + * @param set - a set + * @param item - an item + */ +function insert(set, item, index) { + var e_2, _a; + var newSet = new Set(); + var i = 0; + try { + for (var set_2 = __values(set), set_2_1 = set_2.next(); !set_2_1.done; set_2_1 = set_2.next()) { + var oldItem = set_2_1.value; + if (i === index) + newSet.add(item); + newSet.add(oldItem); + i++; + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (set_2_1 && !set_2_1.done && (_a = set_2.return)) _a.call(set_2); + } + finally { if (e_2) throw e_2.error; } + } + set.clear(); + newSet.forEach(set.add, set); +} +exports.insert = insert; +/** + * Removes the given item or all items matching condition. + * + * @param set - a set + * @param conditionOrItem - an item to remove or a condition matching items + * to remove + */ +function remove(set, conditionOrItem) { + var e_3, _a, e_4, _b; + if (!util_1.isFunction(conditionOrItem)) { + set.delete(conditionOrItem); + } + else { + var toRemove = []; + try { + for (var set_3 = __values(set), set_3_1 = set_3.next(); !set_3_1.done; set_3_1 = set_3.next()) { + var item = set_3_1.value; + if (!!conditionOrItem.call(null, item)) { + toRemove.push(item); + } + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (set_3_1 && !set_3_1.done && (_a = set_3.return)) _a.call(set_3); + } + finally { if (e_3) throw e_3.error; } + } + try { + for (var toRemove_1 = __values(toRemove), toRemove_1_1 = toRemove_1.next(); !toRemove_1_1.done; toRemove_1_1 = toRemove_1.next()) { + var oldItem = toRemove_1_1.value; + set.delete(oldItem); + } + } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (toRemove_1_1 && !toRemove_1_1.done && (_b = toRemove_1.return)) _b.call(toRemove_1); + } + finally { if (e_4) throw e_4.error; } + } + } +} +exports.remove = remove; +/** + * Removes all items from the set. + */ +function empty(set) { + set.clear(); +} +exports.empty = empty; +/** + * Determines if the set contains the given item or any items matching + * condition. + * + * @param set - a set + * @param conditionOrItem - an item to a condition to match + */ +function contains(set, conditionOrItem) { + var e_5, _a; + if (!util_1.isFunction(conditionOrItem)) { + return set.has(conditionOrItem); + } + else { + try { + for (var set_4 = __values(set), set_4_1 = set_4.next(); !set_4_1.done; set_4_1 = set_4.next()) { + var oldItem = set_4_1.value; + if (!!conditionOrItem.call(null, oldItem)) { + return true; + } + } + } + catch (e_5_1) { e_5 = { error: e_5_1 }; } + finally { + try { + if (set_4_1 && !set_4_1.done && (_a = set_4.return)) _a.call(set_4); + } + finally { if (e_5) throw e_5.error; } + } + } + return false; +} +exports.contains = contains; +/** + * Returns the count of items in the set matching the given condition. + * + * @param set - a set + * @param condition - an optional condition to match + */ +function size(set, condition) { + var e_6, _a; + if (condition === undefined) { + return set.size; + } + else { + var count = 0; + try { + for (var set_5 = __values(set), set_5_1 = set_5.next(); !set_5_1.done; set_5_1 = set_5.next()) { + var item = set_5_1.value; + if (!!condition.call(null, item)) { + count++; + } + } + } + catch (e_6_1) { e_6 = { error: e_6_1 }; } + finally { + try { + if (set_5_1 && !set_5_1.done && (_a = set_5.return)) _a.call(set_5); + } + finally { if (e_6) throw e_6.error; } + } + return count; + } +} +exports.size = size; +/** + * Determines if the set is empty. + * + * @param set - a set + */ +function isEmpty(set) { + return set.size === 0; +} +exports.isEmpty = isEmpty; +/** + * Returns an iterator for the items of the set. + * + * @param set - a set + * @param condition - an optional condition to match + */ +function forEach(set, condition) { + var set_6, set_6_1, item, e_7_1; + var e_7, _a; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + if (!(condition === undefined)) return [3 /*break*/, 2]; + return [5 /*yield**/, __values(set)]; + case 1: + _b.sent(); + return [3 /*break*/, 9]; + case 2: + _b.trys.push([2, 7, 8, 9]); + set_6 = __values(set), set_6_1 = set_6.next(); + _b.label = 3; + case 3: + if (!!set_6_1.done) return [3 /*break*/, 6]; + item = set_6_1.value; + if (!!!condition.call(null, item)) return [3 /*break*/, 5]; + return [4 /*yield*/, item]; + case 4: + _b.sent(); + _b.label = 5; + case 5: + set_6_1 = set_6.next(); + return [3 /*break*/, 3]; + case 6: return [3 /*break*/, 9]; + case 7: + e_7_1 = _b.sent(); + e_7 = { error: e_7_1 }; + return [3 /*break*/, 9]; + case 8: + try { + if (set_6_1 && !set_6_1.done && (_a = set_6.return)) _a.call(set_6); + } + finally { if (e_7) throw e_7.error; } + return [7 /*endfinally*/]; + case 9: return [2 /*return*/]; + } + }); +} +exports.forEach = forEach; +/** + * Creates and returns a shallow clone of set. + * + * @param set - a set + */ +function clone(set) { + return new Set(set); +} +exports.clone = clone; +/** + * Returns a new set containing items from the set sorted in ascending + * order. + * + * @param set - a set + * @param lessThanAlgo - a function that returns `true` if its first argument + * is less than its second argument, and `false` otherwise. + */ +function sortInAscendingOrder(set, lessThanAlgo) { + var list = new (Array.bind.apply(Array, __spread([void 0], set)))(); + list.sort(function (itemA, itemB) { + return lessThanAlgo.call(null, itemA, itemB) ? -1 : 1; + }); + return new Set(list); +} +exports.sortInAscendingOrder = sortInAscendingOrder; +/** + * Returns a new set containing items from the set sorted in descending + * order. + * + * @param set - a set + * @param lessThanAlgo - a function that returns `true` if its first argument + * is less than its second argument, and `false` otherwise. + */ +function sortInDescendingOrder(set, lessThanAlgo) { + var list = new (Array.bind.apply(Array, __spread([void 0], set)))(); + list.sort(function (itemA, itemB) { + return lessThanAlgo.call(null, itemA, itemB) ? 1 : -1; + }); + return new Set(list); +} +exports.sortInDescendingOrder = sortInDescendingOrder; +/** + * Determines if a set is a subset of another set. + * + * @param subset - a set + * @param superset - a superset possibly containing all items from `subset`. + */ +function isSubsetOf(subset, superset) { + var e_8, _a; + try { + for (var subset_1 = __values(subset), subset_1_1 = subset_1.next(); !subset_1_1.done; subset_1_1 = subset_1.next()) { + var item = subset_1_1.value; + if (!superset.has(item)) + return false; + } + } + catch (e_8_1) { e_8 = { error: e_8_1 }; } + finally { + try { + if (subset_1_1 && !subset_1_1.done && (_a = subset_1.return)) _a.call(subset_1); + } + finally { if (e_8) throw e_8.error; } + } + return true; +} +exports.isSubsetOf = isSubsetOf; +/** + * Determines if a set is a superset of another set. + * + * @param superset - a set + * @param subset - a subset possibly contained within `superset`. + */ +function isSupersetOf(superset, subset) { + return isSubsetOf(subset, superset); +} +exports.isSupersetOf = isSupersetOf; +/** + * Returns a new set with items that are contained in both sets. + * + * @param setA - a set + * @param setB - a set + */ +function intersection(setA, setB) { + var e_9, _a; + var newSet = new Set(); + try { + for (var setA_1 = __values(setA), setA_1_1 = setA_1.next(); !setA_1_1.done; setA_1_1 = setA_1.next()) { + var item = setA_1_1.value; + if (setB.has(item)) + newSet.add(item); + } + } + catch (e_9_1) { e_9 = { error: e_9_1 }; } + finally { + try { + if (setA_1_1 && !setA_1_1.done && (_a = setA_1.return)) _a.call(setA_1); + } + finally { if (e_9) throw e_9.error; } + } + return newSet; +} +exports.intersection = intersection; +/** + * Returns a new set with items from both sets. + * + * @param setA - a set + * @param setB - a set + */ +function union(setA, setB) { + var newSet = new Set(setA); + setB.forEach(newSet.add, newSet); + return newSet; +} +exports.union = union; +/** + * Returns a set of integers from `n` to `m` inclusive. + * + * @param n - starting number + * @param m - ending number + */ +function range(n, m) { + var newSet = new Set(); + for (var i = n; i <= m; i++) { + newSet.add(i); + } + return newSet; +} +exports.range = range; +//# sourceMappingURL=Set.js.map + +/***/ }), +/* 497 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var BaseCBWriter_1 = __webpack_require__(512); +/** + * Serializes XML nodes. + */ +var YAMLCBWriter = /** @class */ (function (_super) { + __extends(YAMLCBWriter, _super); + /** + * Initializes a new instance of `BaseCBWriter`. + * + * @param builderOptions - XML builder options + */ + function YAMLCBWriter(builderOptions) { + var _this = _super.call(this, builderOptions) || this; + _this._rootWritten = false; + _this._additionalLevel = 0; + if (builderOptions.indent.length < 2) { + throw new Error("YAML indententation string must be at least two characters long."); + } + if (builderOptions.offset < 0) { + throw new Error("YAML offset should be zero or a positive number."); + } + return _this; + } + /** @inheritdoc */ + YAMLCBWriter.prototype.frontMatter = function () { + return this._beginLine() + "---"; + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.declaration = function (version, encoding, standalone) { + return ""; + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.docType = function (name, publicId, systemId) { + return ""; + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.comment = function (data) { + // "!": "hello" + return this._beginLine() + + this._key(this._builderOptions.convert.comment) + " " + + this._val(data); + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.text = function (data) { + // "#": "hello" + return this._beginLine() + + this._key(this._builderOptions.convert.text) + " " + + this._val(data); + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.instruction = function (target, data) { + // "?": "target hello" + return this._beginLine() + + this._key(this._builderOptions.convert.ins) + " " + + this._val(data ? target + " " + data : target); + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.cdata = function (data) { + // "$": "hello" + return this._beginLine() + + this._key(this._builderOptions.convert.cdata) + " " + + this._val(data); + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.attribute = function (name, value) { + // "@name": "val" + this._additionalLevel++; + var str = this._beginLine() + + this._key(this._builderOptions.convert.att + name) + " " + + this._val(value); + this._additionalLevel--; + return str; + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.openTagBegin = function (name) { + // "node": + // "#": + // - + var str = this._beginLine() + this._key(name); + if (!this._rootWritten) { + this._rootWritten = true; + } + this.hasData = true; + this._additionalLevel++; + str += this._beginLine(true) + this._key(this._builderOptions.convert.text); + return str; + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) { + if (selfClosing) { + return " " + this._val(""); + } + return ""; + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.closeTag = function (name) { + this._additionalLevel--; + return ""; + }; + /** @inheritdoc */ + YAMLCBWriter.prototype.beginElement = function (name) { }; + /** @inheritdoc */ + YAMLCBWriter.prototype.endElement = function (name) { }; + /** + * Produces characters to be prepended to a line of string in pretty-print + * mode. + */ + YAMLCBWriter.prototype._beginLine = function (suppressArray) { + if (suppressArray === void 0) { suppressArray = false; } + return (this.hasData ? this._writerOptions.newline : "") + + this._indent(this._writerOptions.offset + this.level, suppressArray); + }; + /** + * Produces an indentation string. + * + * @param level - depth of the tree + * @param suppressArray - whether the suppress array marker + */ + YAMLCBWriter.prototype._indent = function (level, suppressArray) { + if (level + this._additionalLevel <= 0) { + return ""; + } + else { + var chars = this._writerOptions.indent.repeat(level + this._additionalLevel); + if (!suppressArray && this._rootWritten) { + return chars.substr(0, chars.length - 2) + '-' + chars.substr(-1, 1); + } + return chars; + } + }; + /** + * Produces a YAML key string delimited with double quotes. + */ + YAMLCBWriter.prototype._key = function (key) { + return "\"" + key + "\":"; + }; + /** + * Produces a YAML value string delimited with double quotes. + */ + YAMLCBWriter.prototype._val = function (val) { + return JSON.stringify(val); + }; + return YAMLCBWriter; +}(BaseCBWriter_1.BaseCBWriter)); +exports.YAMLCBWriter = YAMLCBWriter; +//# sourceMappingURL=YAMLCBWriter.js.map + +/***/ }), +/* 498 */, +/* 499 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const parse = __webpack_require__(830) +const {re, t} = __webpack_require__(976) + +const coerce = (version, options) => { + if (version instanceof SemVer) { + return version + } + + if (typeof version === 'number') { + version = String(version) + } + + if (typeof version !== 'string') { + return null + } + + options = options || {} + + let match = null + if (!options.rtl) { + match = version.match(re[t.COERCE]) + } else { + // Find the right-most coercible string that does not share + // a terminus with a more left-ward coercible string. + // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' + // + // Walk through the string checking with a /g regexp + // Manually set the index so as to pick up overlapping matches. + // Stop when we get a match that ends at the string end, since no + // coercible string can be more right-ward without the same terminus. + let next + while ((next = re[t.COERCERTL].exec(version)) && + (!match || match.index + match[0].length !== version.length) + ) { + if (!match || + next.index + next[0].length !== match.index + match[0].length) { + match = next + } + re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length + } + // leave it in a clean state + re[t.COERCERTL].lastIndex = -1 + } + + if (match === null) + return null + + return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options) +} +module.exports = coerce + + +/***/ }), +/* 500 */, +/* 501 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Appends the given item to the queue. + * + * @param list - a list + * @param item - an item + */ +function enqueue(list, item) { + list.push(item); +} +exports.enqueue = enqueue; +/** + * Removes and returns an item from the queue. + * + * @param list - a list + */ +function dequeue(list) { + return list.shift() || null; +} +exports.dequeue = dequeue; +//# sourceMappingURL=Queue.js.map + +/***/ }), +/* 502 */, +/* 503 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const parse = __webpack_require__(830) +const clean = (version, options) => { + const s = parse(version.trim().replace(/^[=v]+/, ''), options) + return s ? s.version : null +} +module.exports = clean + + +/***/ }), +/* 504 */, +/* 505 */, +/* 506 */, +/* 507 */, +/* 508 */, +/* 509 */, +/* 510 */, +/* 511 */, +/* 512 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Pre-serializes XML nodes. + */ +var BaseCBWriter = /** @class */ (function () { + /** + * Initializes a new instance of `BaseCBWriter`. + * + * @param builderOptions - XML builder options + */ + function BaseCBWriter(builderOptions) { + /** + * Gets the current depth of the XML tree. + */ + this.level = 0; + this._builderOptions = builderOptions; + this._writerOptions = builderOptions; + } + return BaseCBWriter; +}()); +exports.BaseCBWriter = BaseCBWriter; +//# sourceMappingURL=BaseCBWriter.js.map + +/***/ }), +/* 513 */, +/* 514 */, +/* 515 */, +/* 516 */, +/* 517 */, +/* 518 */, +/* 519 */, +/* 520 */, +/* 521 */, +/* 522 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var util_1 = __webpack_require__(592); +/** + * Parses the given byte sequence representing a JSON string into an object. + * + * @param bytes - a byte sequence + */ +function parseJSONFromBytes(bytes) { + /** + * 1. Let jsonText be the result of running UTF-8 decode on bytes. [ENCODING] + * 2. Return ? Call(%JSONParse%, undefined, « jsonText »). + */ + var jsonText = util_1.utf8Decode(bytes); + return JSON.parse.call(undefined, jsonText); +} +exports.parseJSONFromBytes = parseJSONFromBytes; +/** + * Serialize the given JavaScript value into a byte sequence. + * + * @param value - a JavaScript value + */ +function serializeJSONToBytes(value) { + /** + * 1. Let jsonString be ? Call(%JSONStringify%, undefined, « value »). + * 2. Return the result of running UTF-8 encode on jsonString. [ENCODING] + */ + var jsonString = JSON.stringify.call(undefined, value); + return util_1.utf8Encode(jsonString); +} +exports.serializeJSONToBytes = serializeJSONToBytes; +/** + * Parses the given JSON string into a Realm-independent JavaScript value. + * + * @param jsonText - a JSON string + */ +function parseJSONIntoInfraValues(jsonText) { + /** + * 1. Let jsValue be ? Call(%JSONParse%, undefined, « jsonText »). + * 2. Return the result of converting a JSON-derived JavaScript value to an + * Infra value, given jsValue. + */ + var jsValue = JSON.parse.call(undefined, jsonText); + return convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue); +} +exports.parseJSONIntoInfraValues = parseJSONIntoInfraValues; +/** + * Parses the value into a Realm-independent JavaScript value. + * + * @param jsValue - a JavaScript value + */ +function convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue) { + var e_1, _a; + /** + * 1. If Type(jsValue) is Null, String, or Number, then return jsValue. + */ + if (jsValue === null || util_1.isString(jsValue) || util_1.isNumber(jsValue)) + return jsValue; + /** + * 2. If IsArray(jsValue) is true, then: + * 2.1. Let result be an empty list. + * 2.2. Let length be ! ToLength(! Get(jsValue, "length")). + * 2.3. For each index of the range 0 to length − 1, inclusive: + * 2.3.1. Let indexName be ! ToString(index). + * 2.3.2. Let jsValueAtIndex be ! Get(jsValue, indexName). + * 2.3.3. Let infraValueAtIndex be the result of converting a JSON-derived + * JavaScript value to an Infra value, given jsValueAtIndex. + * 2.3.4. Append infraValueAtIndex to result. + * 2.8. Return result. + */ + if (util_1.isArray(jsValue)) { + var result = new Array(); + try { + for (var jsValue_1 = __values(jsValue), jsValue_1_1 = jsValue_1.next(); !jsValue_1_1.done; jsValue_1_1 = jsValue_1.next()) { + var jsValueAtIndex = jsValue_1_1.value; + result.push(convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtIndex)); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (jsValue_1_1 && !jsValue_1_1.done && (_a = jsValue_1.return)) _a.call(jsValue_1); + } + finally { if (e_1) throw e_1.error; } + } + return result; + } + else if (util_1.isObject(jsValue)) { + /** + * 3. Let result be an empty ordered map. + * 4. For each key of ! jsValue.[[OwnPropertyKeys]](): + * 4.1. Let jsValueAtKey be ! Get(jsValue, key). + * 4.2. Let infraValueAtKey be the result of converting a JSON-derived + * JavaScript value to an Infra value, given jsValueAtKey. + * 4.3. Set result[key] to infraValueAtKey. + * 5. Return result. + */ + var result = new Map(); + for (var key in jsValue) { + /* istanbul ignore else */ + if (jsValue.hasOwnProperty(key)) { + var jsValueAtKey = jsValue[key]; + result.set(key, convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtKey)); + } + } + return result; + } + /* istanbul ignore next */ + return jsValue; +} +exports.convertAJSONDerivedJavaScriptValueToAnInfraValue = convertAJSONDerivedJavaScriptValueToAnInfraValue; +//# sourceMappingURL=JSON.js.map + +/***/ }), +/* 523 */, +/* 524 */ +/***/ (function(__unusedmodule, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Represents a cache for storing order between equal objects. + * + * This cache is used when an algorithm compares two objects and finds them to + * be equal but still needs to establish an order between those two objects. + * When two such objects `a` and `b` are passed to the `check` method, a random + * number is generated with `Math.random()`. If the random number is less than + * `0.5` it is assumed that `a < b` otherwise `a > b`. The random number along + * with `a` and `b` is stored in the cache, so that subsequent checks result + * in the same consistent result. + * + * The cache has a size limit which is defined on initialization. + */ +var CompareCache = /** @class */ (function () { + /** + * Initializes a new instance of `CompareCache`. + * + * @param limit - maximum number of items to keep in the cache. When the limit + * is exceeded the first item is removed from the cache. + */ + function CompareCache(limit) { + if (limit === void 0) { limit = 1000; } + this._items = new Map(); + this._limit = limit; + } + /** + * Compares and caches the given objects. Returns `true` if `objA < objB` and + * `false` otherwise. + * + * @param objA - an item to compare + * @param objB - an item to compare + */ + CompareCache.prototype.check = function (objA, objB) { + if (this._items.get(objA) === objB) + return true; + else if (this._items.get(objB) === objA) + return false; + var result = (Math.random() < 0.5); + if (result) { + this._items.set(objA, objB); + } + else { + this._items.set(objB, objA); + } + if (this._items.size > this._limit) { + var it_1 = this._items.keys().next(); + /* istanbul ignore else */ + if (!it_1.done) { + this._items.delete(it_1.value); + } + } + return result; + }; + return CompareCache; +}()); +exports.CompareCache = CompareCache; +//# sourceMappingURL=CompareCache.js.map + +/***/ }), +/* 525 */, +/* 526 */, +/* 527 */, +/* 528 */, +/* 529 */, +/* 530 */, +/* 531 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +// Determine if version is greater than all the versions possible in the range. +const outside = __webpack_require__(881) +const gtr = (version, range, options) => outside(version, range, '>', options) +module.exports = gtr + + +/***/ }), +/* 532 */, +/* 533 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var Guard_1 = __webpack_require__(783); +/** + * Contains type casts for DOM objects. + */ +var Cast = /** @class */ (function () { + function Cast() { + } + /** + * Casts the given object to a `Node`. + * + * @param a - the object to cast + */ + Cast.asNode = function (a) { + if (Guard_1.Guard.isNode(a)) { + return a; + } + else { + throw new Error("Invalid object. Node expected."); + } + }; + return Cast; +}()); +exports.Cast = Cast; +//# sourceMappingURL=Cast.js.map + +/***/ }), +/* 534 */, +/* 535 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var XMLBuilderImpl_1 = __webpack_require__(595); +exports.XMLBuilderImpl = XMLBuilderImpl_1.XMLBuilderImpl; +var XMLBuilderCBImpl_1 = __webpack_require__(551); +exports.XMLBuilderCBImpl = XMLBuilderCBImpl_1.XMLBuilderCBImpl; +var BuilderFunctions_1 = __webpack_require__(961); +exports.builder = BuilderFunctions_1.builder; +exports.create = BuilderFunctions_1.create; +exports.fragment = BuilderFunctions_1.fragment; +exports.convert = BuilderFunctions_1.convert; +var BuilderFunctionsCB_1 = __webpack_require__(295); +exports.createCB = BuilderFunctionsCB_1.createCB; +exports.fragmentCB = BuilderFunctionsCB_1.fragmentCB; +//# sourceMappingURL=index.js.map + +/***/ }), +/* 536 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const ANY = Symbol('SemVer ANY') +// hoisted class for cyclic dependency +class Comparator { + static get ANY () { + return ANY + } + constructor (comp, options) { + options = parseOptions(options) + + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp + } else { + comp = comp.value + } + } + + debug('comparator', comp, options) + this.options = options + this.loose = !!options.loose + this.parse(comp) + + if (this.semver === ANY) { + this.value = '' + } else { + this.value = this.operator + this.semver.version + } + + debug('comp', this) + } + + parse (comp) { + const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] + const m = comp.match(r) + + if (!m) { + throw new TypeError(`Invalid comparator: ${comp}`) + } + + this.operator = m[1] !== undefined ? m[1] : '' + if (this.operator === '=') { + this.operator = '' + } + + // if it literally is just '>' or '' then allow anything. + if (!m[2]) { + this.semver = ANY + } else { + this.semver = new SemVer(m[2], this.options.loose) + } + } + + toString () { + return this.value + } + + test (version) { + debug('Comparator.test', version, this.options.loose) + + if (this.semver === ANY || version === ANY) { + return true + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + return cmp(version, this.operator, this.semver, this.options) + } + + intersects (comp, options) { + if (!(comp instanceof Comparator)) { + throw new TypeError('a Comparator is required') + } + + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (this.operator === '') { + if (this.value === '') { + return true + } + return new Range(comp.value, options).test(this.value) + } else if (comp.operator === '') { + if (comp.value === '') { + return true + } + return new Range(this.value, options).test(comp.semver) + } + + const sameDirectionIncreasing = + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '>=' || comp.operator === '>') + const sameDirectionDecreasing = + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '<=' || comp.operator === '<') + const sameSemVer = this.semver.version === comp.semver.version + const differentDirectionsInclusive = + (this.operator === '>=' || this.operator === '<=') && + (comp.operator === '>=' || comp.operator === '<=') + const oppositeDirectionsLessThan = + cmp(this.semver, '<', comp.semver, options) && + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '<=' || comp.operator === '<') + const oppositeDirectionsGreaterThan = + cmp(this.semver, '>', comp.semver, options) && + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '>=' || comp.operator === '>') + + return ( + sameDirectionIncreasing || + sameDirectionDecreasing || + (sameSemVer && differentDirectionsInclusive) || + oppositeDirectionsLessThan || + oppositeDirectionsGreaterThan + ) + } +} + +module.exports = Comparator + +const parseOptions = __webpack_require__(143) +const {re, t} = __webpack_require__(976) +const cmp = __webpack_require__(752) +const debug = __webpack_require__(548) +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) + + +/***/ }), +/* 537 */, +/* 538 */, +/* 539 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +const http = __webpack_require__(605); +const https = __webpack_require__(34); +const pm = __webpack_require__(950); +let tunnel; +var HttpCodes; +(function (HttpCodes) { + HttpCodes[HttpCodes["OK"] = 200] = "OK"; + HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; + HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; + HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; + HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; + HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; + HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; + HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; + HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; + HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; + HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; +})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); +var Headers; +(function (Headers) { + Headers["Accept"] = "accept"; + Headers["ContentType"] = "content-type"; +})(Headers = exports.Headers || (exports.Headers = {})); +var MediaTypes; +(function (MediaTypes) { + MediaTypes["ApplicationJson"] = "application/json"; +})(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {})); +/** + * Returns the proxy URL, depending upon the supplied url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ +function getProxyUrl(serverUrl) { + let proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ''; +} +exports.getProxyUrl = getProxyUrl; +const HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect +]; +const HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout +]; +const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; +const ExponentialBackoffCeiling = 10; +const ExponentialBackoffTimeSlice = 5; +class HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = 'HttpClientError'; + this.statusCode = statusCode; + Object.setPrototypeOf(this, HttpClientError.prototype); + } +} +exports.HttpClientError = HttpClientError; +class HttpClientResponse { + constructor(message) { + this.message = message; + } + readBody() { + return new Promise(async (resolve, reject) => { + let output = Buffer.alloc(0); + this.message.on('data', (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on('end', () => { + resolve(output.toString()); + }); + }); + } +} +exports.HttpClientResponse = HttpClientResponse; +function isHttps(requestUrl) { + let parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === 'https:'; +} +exports.isHttps = isHttps; +class HttpClient { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + } + get(requestUrl, additionalHeaders) { + return this.request('GET', requestUrl, null, additionalHeaders || {}); + } + del(requestUrl, additionalHeaders) { + return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + } + post(requestUrl, data, additionalHeaders) { + return this.request('POST', requestUrl, data, additionalHeaders || {}); + } + patch(requestUrl, data, additionalHeaders) { + return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + } + put(requestUrl, data, additionalHeaders) { + return this.request('PUT', requestUrl, data, additionalHeaders || {}); + } + head(requestUrl, additionalHeaders) { + return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return this.request(verb, requestUrl, stream, additionalHeaders); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + async getJson(requestUrl, additionalHeaders = {}) { + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + let res = await this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async postJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async putJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async patchJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + async request(verb, requestUrl, data, headers) { + if (this._disposed) { + throw new Error('Client has already been disposed.'); + } + let parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + // Only perform retries on reads since writes may not be idempotent. + let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1 + ? this._maxRetries + 1 + : 1; + let numTries = 0; + let response; + while (numTries < maxTries) { + response = await this.requestRaw(info, data); + // Check if it's an authentication challenge + if (response && + response.message && + response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (let i = 0; i < this.handlers.length; i++) { + if (this.handlers[i].canHandleAuthentication(response)) { + authenticationHandler = this.handlers[i]; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } + else { + // We have received an unauthorized response but have no handlers to handle it. + // Let the response return to the caller. + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 && + this._allowRedirects && + redirectsRemaining > 0) { + const redirectUrl = response.message.headers['location']; + if (!redirectUrl) { + // if there's no location to redirect to, we won't + break; + } + let parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol == 'https:' && + parsedUrl.protocol != parsedRedirectUrl.protocol && + !this._allowRedirectDowngrade) { + throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); + } + // we need to finish reading the response before reassigning response + // which will leak the open socket. + await response.readBody(); + // strip authorization header if redirected to a different hostname + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (let header in headers) { + // header names are case insensitive + if (header.toLowerCase() === 'authorization') { + delete headers[header]; + } + } + } + // let's make the request with the new redirectUrl + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = await this.requestRaw(info, data); + redirectsRemaining--; + } + if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) { + // If not a retry code, return immediately instead of retrying + return response; + } + numTries += 1; + if (numTries < maxTries) { + await response.readBody(); + await this._performExponentialBackoff(numTries); + } + } + return response; + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return new Promise((resolve, reject) => { + let callbackForResult = function (err, res) { + if (err) { + reject(err); + } + resolve(res); + }; + this.requestRawWithCallback(info, data, callbackForResult); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + let socket; + if (typeof data === 'string') { + info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); + } + let callbackCalled = false; + let handleResult = (err, res) => { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + }; + let req = info.httpModule.request(info.options, (msg) => { + let res = new HttpClientResponse(msg); + handleResult(null, res); + }); + req.on('socket', sock => { + socket = sock; + }); + // If we ever get disconnected, we want the socket to timeout eventually + req.setTimeout(this._socketTimeout || 3 * 60000, () => { + if (socket) { + socket.end(); + } + handleResult(new Error('Request timeout: ' + info.options.path), null); + }); + req.on('error', function (err) { + // err has statusCode property + // res should have headers + handleResult(err, null); + }); + if (data && typeof data === 'string') { + req.write(data, 'utf8'); + } + if (data && typeof data !== 'string') { + data.on('close', function () { + req.end(); + }); + data.pipe(req); + } + else { + req.end(); + } + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + let parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + _prepareRequest(method, requestUrl, headers) { + const info = {}; + info.parsedUrl = requestUrl; + const usingSsl = info.parsedUrl.protocol === 'https:'; + info.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info.options = {}; + info.options.host = info.parsedUrl.hostname; + info.options.port = info.parsedUrl.port + ? parseInt(info.parsedUrl.port) + : defaultPort; + info.options.path = + (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); + info.options.method = method; + info.options.headers = this._mergeHeaders(headers); + if (this.userAgent != null) { + info.options.headers['user-agent'] = this.userAgent; + } + info.options.agent = this._getAgent(info.parsedUrl); + // gives handlers an opportunity to participate + if (this.handlers) { + this.handlers.forEach(handler => { + handler.prepareRequest(info.options); + }); + } + return info; + } + _mergeHeaders(headers) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers)); + } + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + let proxyUrl = pm.getProxyUrl(parsedUrl); + let useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (this._keepAlive && !useProxy) { + agent = this._agent; + } + // if agent is already assigned use that agent. + if (!!agent) { + return agent; + } + const usingSsl = parsedUrl.protocol === 'https:'; + let maxSockets = 100; + if (!!this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + if (useProxy) { + // If using proxy, need tunnel + if (!tunnel) { + tunnel = __webpack_require__(856); + } + const agentOptions = { + maxSockets: maxSockets, + keepAlive: this._keepAlive, + proxy: { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`, + host: proxyUrl.hostname, + port: proxyUrl.port + } + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === 'https:'; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } + else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + // if reusing agent across request and tunneling agent isn't assigned create a new agent + if (this._keepAlive && !agent) { + const options = { keepAlive: this._keepAlive, maxSockets: maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + // if not using private agent and tunnel agent isn't setup then use global agent + if (!agent) { + agent = usingSsl ? https.globalAgent : http.globalAgent; + } + if (usingSsl && this._ignoreSslError) { + // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process + // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options + // we have to cast it to any and change it directly + agent.options = Object.assign(agent.options || {}, { + rejectUnauthorized: false + }); + } + return agent; + } + _performExponentialBackoff(retryNumber) { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise(resolve => setTimeout(() => resolve(), ms)); + } + static dateTimeDeserializer(key, value) { + if (typeof value === 'string') { + let a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + async _processResponse(res, options) { + return new Promise(async (resolve, reject) => { + const statusCode = res.message.statusCode; + const response = { + statusCode: statusCode, + result: null, + headers: {} + }; + // not found leads to null obj returned + if (statusCode == HttpCodes.NotFound) { + resolve(response); + } + let obj; + let contents; + // get the result from the body + try { + contents = await res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, HttpClient.dateTimeDeserializer); + } + else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } + catch (err) { + // Invalid resource (contents not json); leaving result obj null + } + // note that 3xx redirects are handled by the http layer. + if (statusCode > 299) { + let msg; + // if exception/error in body, attempt to get better error + if (obj && obj.message) { + msg = obj.message; + } + else if (contents && contents.length > 0) { + // it may be the case that the exception is in the body message as string + msg = contents; + } + else { + msg = 'Failed request: (' + statusCode + ')'; + } + let err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } + else { + resolve(response); + } + }); + } +} +exports.HttpClient = HttpClient; + + +/***/ }), +/* 540 */, +/* 541 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var DOMImpl_1 = __webpack_require__(648); +var util_1 = __webpack_require__(918); +var infra_1 = __webpack_require__(23); +var CreateAlgorithm_1 = __webpack_require__(86); +var OrderedSetAlgorithm_1 = __webpack_require__(146); +var DOMAlgorithm_1 = __webpack_require__(304); +var MutationAlgorithm_1 = __webpack_require__(479); +var ElementAlgorithm_1 = __webpack_require__(33); +/** + * Replaces the contents of the given node with a single text node. + * + * @param string - node contents + * @param parent - a node + */ +function node_stringReplaceAll(str, parent) { + /** + * 1. Let node be null. + * 2. If string is not the empty string, then set node to a new Text node + * whose data is string and node document is parent’s node document. + * 3. Replace all with node within parent. + */ + var node = null; + if (str !== '') { + node = CreateAlgorithm_1.create_text(parent._nodeDocument, str); + } + MutationAlgorithm_1.mutation_replaceAll(node, parent); +} +exports.node_stringReplaceAll = node_stringReplaceAll; +/** + * Clones a node. + * + * @param node - a node to clone + * @param document - the document to own the cloned node + * @param cloneChildrenFlag - whether to clone node's children + */ +function node_clone(node, document, cloneChildrenFlag) { + var e_1, _a, e_2, _b; + if (document === void 0) { document = null; } + if (cloneChildrenFlag === void 0) { cloneChildrenFlag = false; } + /** + * 1. If document is not given, let document be node’s node document. + */ + if (document === null) + document = node._nodeDocument; + var copy; + if (util_1.Guard.isElementNode(node)) { + /** + * 2. If node is an element, then: + * 2.1. Let copy be the result of creating an element, given document, + * node’s local name, node’s namespace, node’s namespace prefix, + * and node’s is value, with the synchronous custom elements flag unset. + * 2.2. For each attribute in node’s attribute list: + * 2.2.1. Let copyAttribute be a clone of attribute. + * 2.2.2. Append copyAttribute to copy. + */ + copy = ElementAlgorithm_1.element_createAnElement(document, node._localName, node._namespace, node._namespacePrefix, node._is, false); + try { + for (var _c = __values(node._attributeList), _d = _c.next(); !_d.done; _d = _c.next()) { + var attribute = _d.value; + var copyAttribute = node_clone(attribute, document); + ElementAlgorithm_1.element_append(copyAttribute, copy); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_d && !_d.done && (_a = _c.return)) _a.call(_c); + } + finally { if (e_1) throw e_1.error; } + } + } + else { + /** + * 3. Otherwise, let copy be a node that implements the same interfaces as + * node, and fulfills these additional requirements, switching on node: + * - Document + * Set copy’s encoding, content type, URL, origin, type, and mode, to those + * of node. + * - DocumentType + * Set copy’s name, public ID, and system ID, to those of node. + * - Attr + * Set copy’s namespace, namespace prefix, local name, and value, to + * those of node. + * - Text + * - Comment + * Set copy’s data, to that of node. + * - ProcessingInstruction + * Set copy’s target and data to those of node. + * - Any other node + */ + if (util_1.Guard.isDocumentNode(node)) { + var doc = CreateAlgorithm_1.create_document(); + doc._encoding = node._encoding; + doc._contentType = node._contentType; + doc._URL = node._URL; + doc._origin = node._origin; + doc._type = node._type; + doc._mode = node._mode; + copy = doc; + } + else if (util_1.Guard.isDocumentTypeNode(node)) { + var doctype = CreateAlgorithm_1.create_documentType(document, node._name, node._publicId, node._systemId); + copy = doctype; + } + else if (util_1.Guard.isAttrNode(node)) { + var attr = CreateAlgorithm_1.create_attr(document, node.localName); + attr._namespace = node._namespace; + attr._namespacePrefix = node._namespacePrefix; + attr._value = node._value; + copy = attr; + } + else if (util_1.Guard.isExclusiveTextNode(node)) { + copy = CreateAlgorithm_1.create_text(document, node._data); + } + else if (util_1.Guard.isCDATASectionNode(node)) { + copy = CreateAlgorithm_1.create_cdataSection(document, node._data); + } + else if (util_1.Guard.isCommentNode(node)) { + copy = CreateAlgorithm_1.create_comment(document, node._data); + } + else if (util_1.Guard.isProcessingInstructionNode(node)) { + copy = CreateAlgorithm_1.create_processingInstruction(document, node._target, node._data); + } + else if (util_1.Guard.isDocumentFragmentNode(node)) { + copy = CreateAlgorithm_1.create_documentFragment(document); + } + else { + copy = Object.create(node); + } + } + /** + * 4. Set copy’s node document and document to copy, if copy is a document, + * and set copy’s node document to document otherwise. + */ + if (util_1.Guard.isDocumentNode(copy)) { + copy._nodeDocument = copy; + document = copy; + } + else { + copy._nodeDocument = document; + } + /** + * 5. Run any cloning steps defined for node in other applicable + * specifications and pass copy, node, document and the clone children flag + * if set, as parameters. + */ + if (DOMImpl_1.dom.features.steps) { + DOMAlgorithm_1.dom_runCloningSteps(copy, node, document, cloneChildrenFlag); + } + /** + * 6. If the clone children flag is set, clone all the children of node and + * append them to copy, with document as specified and the clone children + * flag being set. + */ + if (cloneChildrenFlag) { + try { + for (var _e = __values(node._children), _f = _e.next(); !_f.done; _f = _e.next()) { + var child = _f.value; + var childCopy = node_clone(child, document, true); + MutationAlgorithm_1.mutation_append(childCopy, copy); + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_f && !_f.done && (_b = _e.return)) _b.call(_e); + } + finally { if (e_2) throw e_2.error; } + } + } + /** + * 7. Return copy. + */ + return copy; +} +exports.node_clone = node_clone; +/** + * Determines if two nodes can be considered equal. + * + * @param a - node to compare + * @param b - node to compare + */ +function node_equals(a, b) { + var e_3, _a, e_4, _b; + /** + * 1. A and B’s nodeType attribute value is identical. + */ + if (a._nodeType !== b._nodeType) + return false; + /** + * 2. The following are also equal, depending on A: + * - DocumentType + * Its name, public ID, and system ID. + * - Element + * Its namespace, namespace prefix, local name, and its attribute list’s size. + * - Attr + * Its namespace, local name, and value. + * - ProcessingInstruction + * Its target and data. + * - Text + * - Comment + * Its data. + */ + if (util_1.Guard.isDocumentTypeNode(a) && util_1.Guard.isDocumentTypeNode(b)) { + if (a._name !== b._name || a._publicId !== b._publicId || + a._systemId !== b._systemId) + return false; + } + else if (util_1.Guard.isElementNode(a) && util_1.Guard.isElementNode(b)) { + if (a._namespace !== b._namespace || a._namespacePrefix !== b._namespacePrefix || + a._localName !== b._localName || + a._attributeList.length !== b._attributeList.length) + return false; + } + else if (util_1.Guard.isAttrNode(a) && util_1.Guard.isAttrNode(b)) { + if (a._namespace !== b._namespace || a._localName !== b._localName || + a._value !== b._value) + return false; + } + else if (util_1.Guard.isProcessingInstructionNode(a) && util_1.Guard.isProcessingInstructionNode(b)) { + if (a._target !== b._target || a._data !== b._data) + return false; + } + else if (util_1.Guard.isCharacterDataNode(a) && util_1.Guard.isCharacterDataNode(b)) { + if (a._data !== b._data) + return false; + } + /** + * 3. If A is an element, each attribute in its attribute list has an attribute + * that equals an attribute in B’s attribute list. + */ + if (util_1.Guard.isElementNode(a) && util_1.Guard.isElementNode(b)) { + var attrMap = {}; + try { + for (var _c = __values(a._attributeList), _d = _c.next(); !_d.done; _d = _c.next()) { + var attrA = _d.value; + attrMap[attrA._localName] = attrA; + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (_d && !_d.done && (_a = _c.return)) _a.call(_c); + } + finally { if (e_3) throw e_3.error; } + } + try { + for (var _e = __values(b._attributeList), _f = _e.next(); !_f.done; _f = _e.next()) { + var attrB = _f.value; + var attrA = attrMap[attrB._localName]; + if (!attrA) + return false; + if (!node_equals(attrA, attrB)) + return false; + } + } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (_f && !_f.done && (_b = _e.return)) _b.call(_e); + } + finally { if (e_4) throw e_4.error; } + } + } + /** + * 4. A and B have the same number of children. + * 5. Each child of A equals the child of B at the identical index. + */ + if (a._children.size !== b._children.size) + return false; + var itA = a._children[Symbol.iterator](); + var itB = b._children[Symbol.iterator](); + var resultA = itA.next(); + var resultB = itB.next(); + while (!resultA.done && !resultB.done) { + var child1 = resultA.value; + var child2 = resultB.value; + if (!node_equals(child1, child2)) + return false; + resultA = itA.next(); + resultB = itB.next(); + } + return true; +} +exports.node_equals = node_equals; +/** + * Returns a collection of elements with the given qualified name which are + * descendants of the given root node. + * See: https://dom.spec.whatwg.org/#concept-getelementsbytagname + * + * @param qualifiedName - qualified name + * @param root - root node + */ +function node_listOfElementsWithQualifiedName(qualifiedName, root) { + /** + * 1. If qualifiedName is "*" (U+002A), return a HTMLCollection rooted at + * root, whose filter matches only descendant elements. + * 2. Otherwise, if root’s node document is an HTML document, return a + * HTMLCollection rooted at root, whose filter matches the following + * descendant elements: + * 2.1. Whose namespace is the HTML namespace and whose qualified name is + * qualifiedName, in ASCII lowercase. + * 2.2. Whose namespace is not the HTML namespace and whose qualified name + * is qualifiedName. + * 3. Otherwise, return a HTMLCollection rooted at root, whose filter + * matches descendant elements whose qualified name is qualifiedName. + */ + if (qualifiedName === "*") { + return CreateAlgorithm_1.create_htmlCollection(root); + } + else if (root._nodeDocument._type === "html") { + return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { + if (ele._namespace === infra_1.namespace.HTML && + ele._qualifiedName === qualifiedName.toLowerCase()) { + return true; + } + else if (ele._namespace !== infra_1.namespace.HTML && + ele._qualifiedName === qualifiedName) { + return true; + } + else { + return false; + } + }); + } + else { + return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { + return (ele._qualifiedName === qualifiedName); + }); + } +} +exports.node_listOfElementsWithQualifiedName = node_listOfElementsWithQualifiedName; +/** + * Returns a collection of elements with the given namespace which are + * descendants of the given root node. + * See: https://dom.spec.whatwg.org/#concept-getelementsbytagnamens + * + * @param namespace - element namespace + * @param localName - local name + * @param root - root node + */ +function node_listOfElementsWithNamespace(namespace, localName, root) { + /** + * 1. If namespace is the empty string, set it to null. + * 2. If both namespace and localName are "*" (U+002A), return a + * HTMLCollection rooted at root, whose filter matches descendant elements. + * 3. Otherwise, if namespace is "*" (U+002A), return a HTMLCollection + * rooted at root, whose filter matches descendant elements whose local + * name is localName. + * 4. Otherwise, if localName is "*" (U+002A), return a HTMLCollection + * rooted at root, whose filter matches descendant elements whose + * namespace is namespace. + * 5. Otherwise, return a HTMLCollection rooted at root, whose filter + * matches descendant elements whose namespace is namespace and local + * name is localName. + */ + if (namespace === '') + namespace = null; + if (namespace === "*" && localName === "*") { + return CreateAlgorithm_1.create_htmlCollection(root); + } + else if (namespace === "*") { + return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { + return (ele._localName === localName); + }); + } + else if (localName === "*") { + return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { + return (ele._namespace === namespace); + }); + } + else { + return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { + return (ele._localName === localName && ele._namespace === namespace); + }); + } +} +exports.node_listOfElementsWithNamespace = node_listOfElementsWithNamespace; +/** + * Returns a collection of elements with the given class names which are + * descendants of the given root node. + * See: https://dom.spec.whatwg.org/#concept-getelementsbyclassname + * + * @param namespace - element namespace + * @param localName - local name + * @param root - root node + */ +function node_listOfElementsWithClassNames(classNames, root) { + /** + * 1. Let classes be the result of running the ordered set parser + * on classNames. + * 2. If classes is the empty set, return an empty HTMLCollection. + * 3. Return a HTMLCollection rooted at root, whose filter matches + * descendant elements that have all their classes in classes. + * The comparisons for the classes must be done in an ASCII case-insensitive + * manner if root’s node document’s mode is "quirks", and in a + * case-sensitive manner otherwise. + */ + var classes = OrderedSetAlgorithm_1.orderedSet_parse(classNames); + if (classes.size === 0) { + return CreateAlgorithm_1.create_htmlCollection(root, function () { return false; }); + } + var caseSensitive = (root._nodeDocument._mode !== "quirks"); + return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { + var eleClasses = ele.classList; + return OrderedSetAlgorithm_1.orderedSet_contains(eleClasses._tokenSet, classes, caseSensitive); + }); +} +exports.node_listOfElementsWithClassNames = node_listOfElementsWithClassNames; +/** + * Searches for a namespace prefix associated with the given namespace + * starting from the given element through its ancestors. + * + * @param element - an element node to start searching at + * @param namespace - namespace to search for + */ +function node_locateANamespacePrefix(element, namespace) { + /** + * 1. If element’s namespace is namespace and its namespace prefix is not + * null, then return its namespace prefix. + */ + if (element._namespace === namespace && element._namespacePrefix !== null) { + return element._namespacePrefix; + } + /** + * 2. If element has an attribute whose namespace prefix is "xmlns" and + * value is namespace, then return element’s first such attribute’s + * local name. + */ + for (var i = 0; i < element._attributeList.length; i++) { + var attr = element._attributeList[i]; + if (attr._namespacePrefix === "xmlns" && attr._value === namespace) { + return attr._localName; + } + } + /** + * 3. If element’s parent element is not null, then return the result of + * running locate a namespace prefix on that element using namespace. + */ + if (element._parent && util_1.Guard.isElementNode(element._parent)) { + return node_locateANamespacePrefix(element._parent, namespace); + } + /** + * 4. Return null. + */ + return null; +} +exports.node_locateANamespacePrefix = node_locateANamespacePrefix; +/** + * Searches for a namespace associated with the given namespace prefix + * starting from the given node through its ancestors. + * + * @param node - a node to start searching at + * @param prefix - namespace prefix to search for + */ +function node_locateANamespace(node, prefix) { + if (util_1.Guard.isElementNode(node)) { + /** + * 1. If its namespace is not null and its namespace prefix is prefix, + * then return namespace. + */ + if (node._namespace !== null && node._namespacePrefix === prefix) { + return node._namespace; + } + /** + * 2. If it has an attribute whose namespace is the XMLNS namespace, + * namespace prefix is "xmlns", and local name is prefix, or if prefix + * is null and it has an attribute whose namespace is the XMLNS namespace, + * namespace prefix is null, and local name is "xmlns", then return its + * value if it is not the empty string, and null otherwise. + */ + for (var i = 0; i < node._attributeList.length; i++) { + var attr = node._attributeList[i]; + if (attr._namespace === infra_1.namespace.XMLNS && + attr._namespacePrefix === "xmlns" && + attr._localName === prefix) { + return attr._value || null; + } + if (prefix === null && attr._namespace === infra_1.namespace.XMLNS && + attr._namespacePrefix === null && attr._localName === "xmlns") { + return attr._value || null; + } + } + /** + * 3. If its parent element is null, then return null. + */ + if (node.parentElement === null) + return null; + /** + * 4. Return the result of running locate a namespace on its parent + * element using prefix. + */ + return node_locateANamespace(node.parentElement, prefix); + } + else if (util_1.Guard.isDocumentNode(node)) { + /** + * 1. If its document element is null, then return null. + * 2. Return the result of running locate a namespace on its document + * element using prefix. + */ + if (node.documentElement === null) + return null; + return node_locateANamespace(node.documentElement, prefix); + } + else if (util_1.Guard.isDocumentTypeNode(node) || util_1.Guard.isDocumentFragmentNode(node)) { + return null; + } + else if (util_1.Guard.isAttrNode(node)) { + /** + * 1. If its element is null, then return null. + * 2. Return the result of running locate a namespace on its element + * using prefix. + */ + if (node._element === null) + return null; + return node_locateANamespace(node._element, prefix); + } + else { + /** + * 1. If its parent element is null, then return null. + * 2. Return the result of running locate a namespace on its parent + * element using prefix. + */ + if (!node._parent || !util_1.Guard.isElementNode(node._parent)) + return null; + return node_locateANamespace(node._parent, prefix); + } +} +exports.node_locateANamespace = node_locateANamespace; +//# sourceMappingURL=NodeAlgorithm.js.map + +/***/ }), +/* 542 */, +/* 543 */, +/* 544 */, +/* 545 */, +/* 546 */, +/* 547 */, +/* 548 */ +/***/ (function(module) { + +const debug = ( + typeof process === 'object' && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG) +) ? (...args) => console.error('SEMVER', ...args) + : () => {} + +module.exports = debug + + +/***/ }), +/* 549 */, +/* 550 */ /***/ (function(module, exports) { exports = module.exports = SemVer @@ -12511,8950 +25612,69 @@ function coerce (version, options) { /***/ }), - -/***/ 286: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents the state of the URL parser. - */ -var ParserState; -(function (ParserState) { - ParserState[ParserState["SchemeStart"] = 0] = "SchemeStart"; - ParserState[ParserState["Scheme"] = 1] = "Scheme"; - ParserState[ParserState["NoScheme"] = 2] = "NoScheme"; - ParserState[ParserState["SpecialRelativeOrAuthority"] = 3] = "SpecialRelativeOrAuthority"; - ParserState[ParserState["PathOrAuthority"] = 4] = "PathOrAuthority"; - ParserState[ParserState["Relative"] = 5] = "Relative"; - ParserState[ParserState["RelativeSlash"] = 6] = "RelativeSlash"; - ParserState[ParserState["SpecialAuthoritySlashes"] = 7] = "SpecialAuthoritySlashes"; - ParserState[ParserState["SpecialAuthorityIgnoreSlashes"] = 8] = "SpecialAuthorityIgnoreSlashes"; - ParserState[ParserState["Authority"] = 9] = "Authority"; - ParserState[ParserState["Host"] = 10] = "Host"; - ParserState[ParserState["Hostname"] = 11] = "Hostname"; - ParserState[ParserState["Port"] = 12] = "Port"; - ParserState[ParserState["File"] = 13] = "File"; - ParserState[ParserState["FileSlash"] = 14] = "FileSlash"; - ParserState[ParserState["FileHost"] = 15] = "FileHost"; - ParserState[ParserState["PathStart"] = 16] = "PathStart"; - ParserState[ParserState["Path"] = 17] = "Path"; - ParserState[ParserState["CannotBeABaseURLPath"] = 18] = "CannotBeABaseURLPath"; - ParserState[ParserState["Query"] = 19] = "Query"; - ParserState[ParserState["Fragment"] = 20] = "Fragment"; -})(ParserState = exports.ParserState || (exports.ParserState = {})); -exports.OpaqueOrigin = ["", "", null, null]; -//# sourceMappingURL=interfaces.js.map - -/***/ }), - -/***/ 290: +/* 551 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; -Object.defineProperty(exports, "__esModule", { value: true }); -const _1 = __webpack_require__(113); -const infra_1 = __webpack_require__(23); -const algorithm_1 = __webpack_require__(163); -const WebIDLAlgorithm_1 = __webpack_require__(495); -/** - * Represents an object providing methods which are not dependent on - * any particular document. - */ -class DOMImplementationImpl { - /** - * Initializes a new instance of `DOMImplementation`. - * - * @param document - the associated document - */ - constructor(document) { - this._associatedDocument = document || _1.dom.window.document; - } - /** @inheritdoc */ - createDocumentType(qualifiedName, publicId, systemId) { - /** - * 1. Validate qualifiedName. - * 2. Return a new doctype, with qualifiedName as its name, publicId as its - * public ID, and systemId as its system ID, and with its node document set - * to the associated document of the context object. - */ - algorithm_1.namespace_validate(qualifiedName); - return algorithm_1.create_documentType(this._associatedDocument, qualifiedName, publicId, systemId); - } - /** @inheritdoc */ - createDocument(namespace, qualifiedName, doctype = null) { - /** - * 1. Let document be a new XMLDocument. - */ - const document = algorithm_1.create_xmlDocument(); - /** - * 2. Let element be null. - * 3. If qualifiedName is not the empty string, then set element to - * the result of running the internal createElementNS steps, given document, - * namespace, qualifiedName, and an empty dictionary. - */ - let element = null; - if (qualifiedName) { - element = algorithm_1.document_internalCreateElementNS(document, namespace, qualifiedName); - } - /** - * 4. If doctype is non-null, append doctype to document. - * 5. If element is non-null, append element to document. - */ - if (doctype) - document.appendChild(doctype); - if (element) - document.appendChild(element); - /** - * 6. document’s origin is context object’s associated document’s origin. - */ - document._origin = this._associatedDocument._origin; - /** - * 7. document’s content type is determined by namespace: - * - HTML namespace - * application/xhtml+xml - * - SVG namespace - * image/svg+xml - * - Any other namespace - * application/xml - */ - if (namespace === infra_1.namespace.HTML) - document._contentType = "application/xhtml+xml"; - else if (namespace === infra_1.namespace.SVG) - document._contentType = "image/svg+xml"; - else - document._contentType = "application/xml"; - /** - * 8. Return document. - */ - return document; - } - /** @inheritdoc */ - createHTMLDocument(title) { - /** - * 1. Let doc be a new document that is an HTML document. - * 2. Set doc’s content type to "text/html". - */ - const doc = algorithm_1.create_document(); - doc._type = "html"; - doc._contentType = "text/html"; - /** - * 3. Append a new doctype, with "html" as its name and with its node - * document set to doc, to doc. - */ - doc.appendChild(algorithm_1.create_documentType(doc, "html", "", "")); - /** - * 4. Append the result of creating an element given doc, html, and the - * HTML namespace, to doc. - */ - const htmlElement = algorithm_1.element_createAnElement(doc, "html", infra_1.namespace.HTML); - doc.appendChild(htmlElement); - /** - * 5. Append the result of creating an element given doc, head, and the - * HTML namespace, to the html element created earlier. - */ - const headElement = algorithm_1.element_createAnElement(doc, "head", infra_1.namespace.HTML); - htmlElement.appendChild(headElement); - /** - * 6. If title is given: - * 6.1. Append the result of creating an element given doc, title, and - * the HTML namespace, to the head element created earlier. - * 6.2. Append a new Text node, with its data set to title (which could - * be the empty string) and its node document set to doc, to the title - * element created earlier. - */ - if (title !== undefined) { - const titleElement = algorithm_1.element_createAnElement(doc, "title", infra_1.namespace.HTML); - headElement.appendChild(titleElement); - const textElement = algorithm_1.create_text(doc, title); - titleElement.appendChild(textElement); - } - /** - * 7. Append the result of creating an element given doc, body, and the - * HTML namespace, to the html element created earlier. - */ - const bodyElement = algorithm_1.element_createAnElement(doc, "body", infra_1.namespace.HTML); - htmlElement.appendChild(bodyElement); - /** - * 8. doc’s origin is context object’s associated document’s origin. - */ - doc._origin = this._associatedDocument._origin; - /** - * 9. Return doc. - */ - return doc; - } - /** @inheritdoc */ - hasFeature() { return true; } - /** - * Creates a new `DOMImplementation`. - * - * @param document - owner document - */ - static _create(document) { - return new DOMImplementationImpl(document); - } -} -exports.DOMImplementationImpl = DOMImplementationImpl; -WebIDLAlgorithm_1.idl_defineConst(DOMImplementationImpl.prototype, "_ID", "@oozcitak/dom"); -//# sourceMappingURL=DOMImplementationImpl.js.map - -/***/ }), - -/***/ 304: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const TreeAlgorithm_1 = __webpack_require__(873); -const util_1 = __webpack_require__(918); -const ShadowTreeAlgorithm_1 = __webpack_require__(180); -const supportedTokens = new Map(); -/** - * Runs removing steps for node. - * - * @param removedNode - removed node - * @param oldParent - old parent node - */ -function dom_runRemovingSteps(removedNode, oldParent) { - // No steps defined -} -exports.dom_runRemovingSteps = dom_runRemovingSteps; -/** - * Runs cloning steps for node. - * - * @param copy - node clone - * @param node - node - * @param document - document to own the cloned node - * @param cloneChildrenFlag - whether child nodes are cloned - */ -function dom_runCloningSteps(copy, node, document, cloneChildrenFlag) { - // No steps defined -} -exports.dom_runCloningSteps = dom_runCloningSteps; -/** - * Runs adopting steps for node. - * - * @param node - node - * @param oldDocument - old document - */ -function dom_runAdoptingSteps(node, oldDocument) { - // No steps defined -} -exports.dom_runAdoptingSteps = dom_runAdoptingSteps; -/** - * Runs attribute change steps for an element node. - * - * @param element - element node owning the attribute - * @param localName - attribute's local name - * @param oldValue - attribute's old value - * @param value - attribute's new value - * @param namespace - attribute's namespace - */ -function dom_runAttributeChangeSteps(element, localName, oldValue, value, namespace) { - // run default steps - if (dom_1.dom.features.slots) { - updateASlotablesName.call(element, element, localName, oldValue, value, namespace); - updateASlotsName.call(element, element, localName, oldValue, value, namespace); - } - updateAnElementID.call(element, element, localName, value, namespace); - // run custom steps - for (const step of element._attributeChangeSteps) { - step.call(element, element, localName, oldValue, value, namespace); - } -} -exports.dom_runAttributeChangeSteps = dom_runAttributeChangeSteps; -/** - * Runs insertion steps for a node. - * - * @param insertedNode - inserted node - */ -function dom_runInsertionSteps(insertedNode) { - // No steps defined -} -exports.dom_runInsertionSteps = dom_runInsertionSteps; -/** - * Runs pre-removing steps for a node iterator and node. - * - * @param nodeIterator - a node iterator - * @param toBeRemoved - node to be removed - */ -function dom_runNodeIteratorPreRemovingSteps(nodeIterator, toBeRemoved) { - removeNodeIterator.call(nodeIterator, nodeIterator, toBeRemoved); -} -exports.dom_runNodeIteratorPreRemovingSteps = dom_runNodeIteratorPreRemovingSteps; -/** - * Determines if there are any supported tokens defined for the given - * attribute name. - * - * @param attributeName - an attribute name - */ -function dom_hasSupportedTokens(attributeName) { - return supportedTokens.has(attributeName); -} -exports.dom_hasSupportedTokens = dom_hasSupportedTokens; -/** - * Returns the set of supported tokens defined for the given attribute name. - * - * @param attributeName - an attribute name - */ -function dom_getSupportedTokens(attributeName) { - return supportedTokens.get(attributeName) || new Set(); -} -exports.dom_getSupportedTokens = dom_getSupportedTokens; -/** - * Runs event construction steps. - * - * @param event - an event - */ -function dom_runEventConstructingSteps(event) { - // No steps defined -} -exports.dom_runEventConstructingSteps = dom_runEventConstructingSteps; -/** - * Runs child text content change steps for a parent node. - * - * @param parent - parent node with text node child nodes - */ -function dom_runChildTextContentChangeSteps(parent) { - // No steps defined -} -exports.dom_runChildTextContentChangeSteps = dom_runChildTextContentChangeSteps; -/** - * Defines pre-removing steps for a node iterator. - */ -function removeNodeIterator(nodeIterator, toBeRemovedNode) { - /** - * 1. If toBeRemovedNode is not an inclusive ancestor of nodeIterator’s - * reference, or toBeRemovedNode is nodeIterator’s root, then return. - */ - if (toBeRemovedNode === nodeIterator._root || - !TreeAlgorithm_1.tree_isAncestorOf(nodeIterator._reference, toBeRemovedNode, true)) { - return; - } - /** - * 2. If nodeIterator’s pointer before reference is true, then: - */ - if (nodeIterator._pointerBeforeReference) { - /** - * 2.1. Let next be toBeRemovedNode’s first following node that is an - * inclusive descendant of nodeIterator’s root and is not an inclusive - * descendant of toBeRemovedNode, and null if there is no such node. - */ - while (true) { - const nextNode = TreeAlgorithm_1.tree_getFollowingNode(nodeIterator._root, toBeRemovedNode); - if (nextNode !== null && - TreeAlgorithm_1.tree_isDescendantOf(nodeIterator._root, nextNode, true) && - !TreeAlgorithm_1.tree_isDescendantOf(toBeRemovedNode, nextNode, true)) { - /** - * 2.2. If next is non-null, then set nodeIterator’s reference to next - * and return. - */ - nodeIterator._reference = nextNode; - return; - } - else if (nextNode === null) { - /** - * 2.3. Otherwise, set nodeIterator’s pointer before reference to false. - */ - nodeIterator._pointerBeforeReference = false; - return; - } - } - } - /** - * 3. Set nodeIterator’s reference to toBeRemovedNode’s parent, if - * toBeRemovedNode’s previous sibling is null, and to the inclusive - * descendant of toBeRemovedNode’s previous sibling that appears last in - * tree order otherwise. - */ - if (toBeRemovedNode._previousSibling === null) { - if (toBeRemovedNode._parent !== null) { - nodeIterator._reference = toBeRemovedNode._parent; - } - } - else { - let referenceNode = toBeRemovedNode._previousSibling; - let childNode = TreeAlgorithm_1.tree_getFirstDescendantNode(toBeRemovedNode._previousSibling, true, false); - while (childNode !== null) { - if (childNode !== null) { - referenceNode = childNode; - } - // loop through to get the last descendant node - childNode = TreeAlgorithm_1.tree_getNextDescendantNode(toBeRemovedNode._previousSibling, childNode, true, false); - } - nodeIterator._reference = referenceNode; - } -} -/** - * Defines attribute change steps to update a slot’s name. - */ -function updateASlotsName(element, localName, oldValue, value, namespace) { - /** - * 1. If element is a slot, localName is name, and namespace is null, then: - * 1.1. If value is oldValue, then return. - * 1.2. If value is null and oldValue is the empty string, then return. - * 1.3. If value is the empty string and oldValue is null, then return. - * 1.4. If value is null or the empty string, then set element’s name to the - * empty string. - * 1.5. Otherwise, set element’s name to value. - * 1.6. Run assign slotables for a tree with element’s root. - */ - if (util_1.Guard.isSlot(element) && localName === "name" && namespace === null) { - if (value === oldValue) - return; - if (value === null && oldValue === '') - return; - if (value === '' && oldValue === null) - return; - if ((value === null || value === '')) { - element._name = ''; - } - else { - element._name = value; - } - ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(element)); - } -} -/** - * Defines attribute change steps to update a slotable’s name. - */ -function updateASlotablesName(element, localName, oldValue, value, namespace) { - /** - * 1. If localName is slot and namespace is null, then: - * 1.1. If value is oldValue, then return. - * 1.2. If value is null and oldValue is the empty string, then return. - * 1.3. If value is the empty string and oldValue is null, then return. - * 1.4. If value is null or the empty string, then set element’s name to - * the empty string. - * 1.5. Otherwise, set element’s name to value. - * 1.6. If element is assigned, then run assign slotables for element’s - * assigned slot. - * 1.7. Run assign a slot for element. - */ - if (util_1.Guard.isSlotable(element) && localName === "slot" && namespace === null) { - if (value === oldValue) - return; - if (value === null && oldValue === '') - return; - if (value === '' && oldValue === null) - return; - if ((value === null || value === '')) { - element._name = ''; - } - else { - element._name = value; - } - if (ShadowTreeAlgorithm_1.shadowTree_isAssigned(element)) { - ShadowTreeAlgorithm_1.shadowTree_assignSlotables(element._assignedSlot); - } - ShadowTreeAlgorithm_1.shadowTree_assignASlot(element); - } -} -/** - * Defines attribute change steps to update an element's ID. - */ -function updateAnElementID(element, localName, value, namespace) { - /** - * 1. If localName is id, namespace is null, and value is null or the empty - * string, then unset element’s ID. - * 2. Otherwise, if localName is id, namespace is null, then set element’s - * ID to value. - */ - if (localName === "id" && namespace === null) { - if (!value) - element._uniqueIdentifier = undefined; - else - element._uniqueIdentifier = value; - } -} -//# sourceMappingURL=DOMAlgorithm.js.map - -/***/ }), - -/***/ 307: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const base64 = __importStar(__webpack_require__(347)); -exports.base64 = base64; -const byte = __importStar(__webpack_require__(15)); -exports.byte = byte; -const byteSequence = __importStar(__webpack_require__(425)); -exports.byteSequence = byteSequence; -const codePoint = __importStar(__webpack_require__(780)); -exports.codePoint = codePoint; -const json = __importStar(__webpack_require__(859)); -exports.json = json; -const list = __importStar(__webpack_require__(174)); -exports.list = list; -const map = __importStar(__webpack_require__(486)); -exports.map = map; -const namespace = __importStar(__webpack_require__(609)); -exports.namespace = namespace; -const queue = __importStar(__webpack_require__(429)); -exports.queue = queue; -const set = __importStar(__webpack_require__(693)); -exports.set = set; -const stack = __importStar(__webpack_require__(183)); -exports.stack = stack; -const string = __importStar(__webpack_require__(665)); -exports.string = string; -//# sourceMappingURL=index.js.map - -/***/ }), - -/***/ 319: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents a set of objects with a size limit. - */ -class FixedSizeSet { - /** - * Initializes a new instance of `FixedSizeSet`. - * - * @param limit - maximum number of items to keep in the set. When the limit - * is exceeded the first item is removed from the set. - */ - constructor(limit = 1000) { - this._items = new Set(); - this._limit = limit; - } - /** - * Adds a new item to the set. - * - * @param item - an item - */ - add(item) { - this._items.add(item); - if (this._items.size > this._limit) { - const it = this._items.values().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - return this; - } - /** - * Removes an item from the set. - * - * @param item - an item - */ - delete(item) { - return this._items.delete(item); - } - /** - * Determines if an item is in the set. - * - * @param item - an item - */ - has(item) { - return this._items.has(item); - } - /** - * Removes all items from the set. - */ - clear() { - this._items.clear(); - } - /** - * Gets the number of items in the set. - */ - get size() { return this._items.size; } - /** - * Applies the given callback function to all elements of the set. - */ - forEach(callback, thisArg) { - this._items.forEach(e => callback.call(thisArg, e, e, this)); - } - /** - * Iterates through the items in the set. - */ - *keys() { - yield* this._items.keys(); - } - /** - * Iterates through the items in the set. - */ - *values() { - yield* this._items.values(); - } - /** - * Iterates through the items in the set. - */ - *entries() { - yield* this._items.entries(); - } - /** - * Iterates through the items in the set. - */ - *[Symbol.iterator]() { - yield* this._items; - } - /** - * Returns the string tag of the set. - */ - get [Symbol.toStringTag]() { - return "FixedSizeSet"; - } -} -exports.FixedSizeSet = FixedSizeSet; -//# sourceMappingURL=FixedSizeSet.js.map - -/***/ }), - -/***/ 322: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const path = __importStar(__webpack_require__(622)); -function getTempDir() { - let tempDirectory = process.env.RUNNER_TEMP; - if (tempDirectory === undefined) { - let baseLocation; - if (isWindows()) { - // On windows use the USERPROFILE env variable - baseLocation = process.env['USERPROFILE'] - ? process.env['USERPROFILE'] - : 'C:\\'; - } - else { - if (process.platform === 'darwin') { - baseLocation = '/Users'; - } - else { - baseLocation = '/home'; - } - } - tempDirectory = path.join(baseLocation, 'actions', 'temp'); - } - return tempDirectory; -} -exports.getTempDir = getTempDir; -function isWindows() { - return process.platform === 'win32'; -} -exports.isWindows = isWindows; - - -/***/ }), - -/***/ 326: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents an object cache with a size limit. - */ -class ObjectCache { - /** - * Initializes a new instance of `ObjectCache`. - * - * @param limit - maximum number of items to keep in the cache. When the limit - * is exceeded the first item is removed from the cache. - */ - constructor(limit = 1000) { - this._items = new Set(); - this._limit = limit; - } - /** - * Adds a new item to the cache. - * - * @param item - an item - */ - add(item) { - this._items.add(item); - if (this._items.size > this._limit) { - const it = this._items.values().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - } - /** - * Removes an item from the cache. - * - * @param item - an item - */ - remove(item) { - this._items.delete(item); - } - /** - * Removes all items from the cache. - */ - clear() { - this._items.clear(); - } - /** - * Gets the number of items in the cache. - */ - get length() { return this._items.size; } - /** - * Iterates through the items in the cache. - */ - *entries() { - yield* this; - } - /** - * Iterates through the items in the cache. - */ - *[Symbol.iterator]() { - yield* this._items; - } -} -exports.ObjectCache = ObjectCache; -//# sourceMappingURL=ObjectCache.js.map - -/***/ }), - -/***/ 331: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const fs = __importStar(__webpack_require__(747)); -const os = __importStar(__webpack_require__(87)); -const path = __importStar(__webpack_require__(622)); -const core = __importStar(__webpack_require__(470)); -const io = __importStar(__webpack_require__(1)); -const xmlbuilder2_1 = __webpack_require__(255); -const constants = __importStar(__webpack_require__(694)); -exports.M2_DIR = '.m2'; -exports.SETTINGS_FILE = 'settings.xml'; -function configAuthentication(id, username, password, gpgPassphrase = undefined) { - return __awaiter(this, void 0, void 0, function* () { - console.log(`creating ${exports.SETTINGS_FILE} with server-id: ${id};`, 'environment variables:', `username=\$${username},`, `password=\$${password},`, `and gpg-passphrase=${gpgPassphrase ? '$' + gpgPassphrase : null}`); - // when an alternate m2 location is specified use only that location (no .m2 directory) - // otherwise use the home/.m2/ path - const settingsDirectory = path.join(core.getInput(constants.INPUT_SETTINGS_PATH) || os.homedir(), core.getInput(constants.INPUT_SETTINGS_PATH) ? '' : exports.M2_DIR); - yield io.mkdirP(settingsDirectory); - core.debug(`created directory ${settingsDirectory}`); - yield write(settingsDirectory, generate(id, username, password, gpgPassphrase)); - }); -} -exports.configAuthentication = configAuthentication; -// only exported for testing purposes -function generate(id, username, password, gpgPassphrase = undefined) { - const xmlObj = { - settings: { - '@xmlns': 'http://maven.apache.org/SETTINGS/1.0.0', - '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance', - '@xsi:schemaLocation': 'http://maven.apache.org/SETTINGS/1.0.0 https://maven.apache.org/xsd/settings-1.0.0.xsd', - servers: { - server: [ - { - id: id, - username: `\${env.${username}}`, - password: `\${env.${password}}` - } - ] - } +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; } }; - if (gpgPassphrase) { - const gpgServer = { - id: 'gpg.passphrase', - passphrase: `\${env.${gpgPassphrase}}` - }; - xmlObj.settings.servers.server.push(gpgServer); - } - return xmlbuilder2_1.create(xmlObj).end({ headless: true, prettyPrint: true, width: 80 }); -} -exports.generate = generate; -function write(directory, settings) { - return __awaiter(this, void 0, void 0, function* () { - const location = path.join(directory, exports.SETTINGS_FILE); - if (fs.existsSync(location)) { - console.warn(`overwriting existing file ${location}`); - } - else { - console.log(`writing ${location}`); - } - return fs.writeFileSync(location, settings, { - encoding: 'utf-8', - flag: 'w' - }); - }); -} - - -/***/ }), - -/***/ 337: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -var FixedSizeSet_1 = __webpack_require__(844); -exports.FixedSizeSet = FixedSizeSet_1.FixedSizeSet; -var ObjectCache_1 = __webpack_require__(995); -exports.ObjectCache = ObjectCache_1.ObjectCache; -var CompareCache_1 = __webpack_require__(879); -exports.CompareCache = CompareCache_1.CompareCache; -var Lazy_1 = __webpack_require__(798); -exports.Lazy = Lazy_1.Lazy; -/** - * Applies the mixin to a given class. - * - * @param baseClass - class to receive the mixin - * @param mixinClass - mixin class - * @param overrides - an array with names of function overrides. Base class - * functions whose names are in this array will be kept by prepending an - * underscore to their names. - */ -function applyMixin(baseClass, mixinClass, ...overrides) { - Object.getOwnPropertyNames(mixinClass.prototype).forEach(name => { - if (overrides.includes(name)) { - const orgPropDesc = Object.getOwnPropertyDescriptor(baseClass.prototype, name); - /* istanbul ignore else */ - if (orgPropDesc) { - Object.defineProperty(baseClass.prototype, "_" + name, orgPropDesc); - } - } - const propDesc = Object.getOwnPropertyDescriptor(mixinClass.prototype, name); - /* istanbul ignore else */ - if (propDesc) { - Object.defineProperty(baseClass.prototype, name, propDesc); - } - }); -} -exports.applyMixin = applyMixin; -/** - * Applies default values to the given object. - * - * @param obj - an object - * @param defaults - an object with default values - * @param overwrite - if set to `true` defaults object always overwrites object - * values, whether they are `undefined` or not. - */ -function applyDefaults(obj, defaults, overwrite = false) { - const result = clone(obj || {}); - forEachObject(defaults, (key, val) => { - if (isObject(val)) { - result[key] = applyDefaults(result[key], val); - } - else if (overwrite || result[key] === undefined) { - result[key] = val; - } - }); - return result; -} -exports.applyDefaults = applyDefaults; -/** - * Iterates over items of an array or set. - * - * @param arr - array or set to iterate - * @param callback - a callback function which receives each array item as its - * single argument - * @param thisArg - the value of this inside callback - */ -function forEachArray(arr, callback, thisArg) { - arr.forEach(callback, thisArg); -} -exports.forEachArray = forEachArray; -/** - * Iterates over key/value pairs of a map or object. - * - * @param obj - map or object to iterate - * @param callback - a callback function which receives object key as its first - * argument and object value as its second argument - * @param thisArg - the value of this inside callback - */ -function forEachObject(obj, callback, thisArg) { - if (isMap(obj)) { - obj.forEach((value, key) => callback.call(thisArg, key, value)); - } - else { - for (const key in obj) { - /* istanbul ignore else */ - if (obj.hasOwnProperty(key)) { - callback.call(thisArg, key, obj[key]); - } - } - } -} -exports.forEachObject = forEachObject; -/** - * Returns the number of entries in an array or set. - * - * @param arr - array or set - */ -function arrayLength(obj) { - if (isSet(obj)) { - return obj.size; - } - else { - return obj.length; - } -} -exports.arrayLength = arrayLength; -/** - * Returns the number of entries in a map or object. - * - * @param obj - map or object - */ -function objectLength(obj) { - if (isMap(obj)) { - return obj.size; - } - else { - return Object.keys(obj).length; - } -} -exports.objectLength = objectLength; -/** - * Gets the value of a key from a map or object. - * - * @param obj - map or object - * @param key - the key to retrieve - */ -function getObjectValue(obj, key) { - if (isMap(obj)) { - return obj.get(key); - } - else { - return obj[key]; - } -} -exports.getObjectValue = getObjectValue; -/** - * Removes a property from a map or object. - * - * @param obj - map or object - * @param key - the key to remove - */ -function removeObjectValue(obj, key) { - if (isMap(obj)) { - obj.delete(key); - } - else { - delete obj[key]; - } -} -exports.removeObjectValue = removeObjectValue; -/** - * Deep clones the given object. - * - * @param obj - an object - */ -function clone(obj) { - if (isFunction(obj)) { - return obj; - } - else if (isArray(obj)) { - const result = []; - for (const item of obj) { - result.push(clone(item)); - } - return result; - } - else if (isObject(obj)) { - const result = {}; - for (const key in obj) { - /* istanbul ignore next */ - if (obj.hasOwnProperty(key)) { - const val = obj[key]; - result[key] = clone(val); - } - } - return result; - } - else { - return obj; - } -} -exports.clone = clone; -/** - * Type guard for boolean types - * - * @param x - a variable to type check - */ -function isBoolean(x) { - return typeof x === "boolean"; -} -exports.isBoolean = isBoolean; -/** - * Type guard for numeric types - * - * @param x - a variable to type check - */ -function isNumber(x) { - return typeof x === "number"; -} -exports.isNumber = isNumber; -/** - * Type guard for strings - * - * @param x - a variable to type check - */ -function isString(x) { - return typeof x === "string"; -} -exports.isString = isString; -/** - * Type guard for function objects - * - * @param x - a variable to type check - */ -function isFunction(x) { - return !!x && Object.prototype.toString.call(x) === '[object Function]'; -} -exports.isFunction = isFunction; -/** - * Type guard for JS objects - * - * _Note:_ Functions are objects too - * - * @param x - a variable to type check - */ -function isObject(x) { - const type = typeof x; - return !!x && (type === 'function' || type === 'object'); -} -exports.isObject = isObject; -/** - * Type guard for arrays - * - * @param x - a variable to type check - */ -function isArray(x) { - return Array.isArray(x); -} -exports.isArray = isArray; -/** - * Type guard for sets. - * - * @param x - a variable to check - */ -function isSet(x) { - return x instanceof Set; -} -exports.isSet = isSet; -/** - * Type guard for maps. - * - * @param x - a variable to check - */ -function isMap(x) { - return x instanceof Map; -} -exports.isMap = isMap; -/** - * Determines if `x` is an empty Array or an Object with no own properties. - * - * @param x - a variable to check - */ -function isEmpty(x) { - if (isArray(x)) { - return !x.length; - } - else if (isSet(x)) { - return !x.size; - } - else if (isMap(x)) { - return !x.size; - } - else if (isObject(x)) { - for (const key in x) { - if (x.hasOwnProperty(key)) { - return false; - } - } - return true; - } - return false; -} -exports.isEmpty = isEmpty; -/** - * Determines if `x` is a plain Object. - * - * @param x - a variable to check - */ -function isPlainObject(x) { - if (isObject(x)) { - const proto = Object.getPrototypeOf(x); - const ctor = proto.constructor; - return proto && ctor && - (typeof ctor === 'function') && (ctor instanceof ctor) && - (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object)); - } - return false; -} -exports.isPlainObject = isPlainObject; -/** - * Determines if `x` is an iterable Object. - * - * @param x - a variable to check - */ -function isIterable(x) { - return x && (typeof x[Symbol.iterator] === 'function'); -} -exports.isIterable = isIterable; -/** - * Gets the primitive value of an object. - */ -function getValue(obj) { - if (isFunction(obj.valueOf)) { - return obj.valueOf(); - } - else { - return obj; - } -} -exports.getValue = getValue; -/** - * UTF-8 encodes the given string. - * - * @param input - a string - */ -function utf8Encode(input) { - const bytes = new Uint8Array(input.length * 4); - let byteIndex = 0; - for (let i = 0; i < input.length; i++) { - let char = input.charCodeAt(i); - if (char < 128) { - bytes[byteIndex++] = char; - continue; - } - else if (char < 2048) { - bytes[byteIndex++] = char >> 6 | 192; - } - else { - if (char > 0xd7ff && char < 0xdc00) { - if (++i >= input.length) { - throw new Error("Incomplete surrogate pair."); - } - const c2 = input.charCodeAt(i); - if (c2 < 0xdc00 || c2 > 0xdfff) { - throw new Error("Invalid surrogate character."); - } - char = 0x10000 + ((char & 0x03ff) << 10) + (c2 & 0x03ff); - bytes[byteIndex++] = char >> 18 | 240; - bytes[byteIndex++] = char >> 12 & 63 | 128; - } - else { - bytes[byteIndex++] = char >> 12 | 224; - } - bytes[byteIndex++] = char >> 6 & 63 | 128; - } - bytes[byteIndex++] = char & 63 | 128; - } - return bytes.subarray(0, byteIndex); -} -exports.utf8Encode = utf8Encode; -/** - * UTF-8 decodes the given byte sequence into a string. - * - * @param bytes - a byte sequence - */ -function utf8Decode(bytes) { - let result = ""; - let i = 0; - while (i < bytes.length) { - var c = bytes[i++]; - if (c > 127) { - if (c > 191 && c < 224) { - if (i >= bytes.length) { - throw new Error("Incomplete 2-byte sequence."); - } - c = (c & 31) << 6 | bytes[i++] & 63; - } - else if (c > 223 && c < 240) { - if (i + 1 >= bytes.length) { - throw new Error("Incomplete 3-byte sequence."); - } - c = (c & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63; - } - else if (c > 239 && c < 248) { - if (i + 2 >= bytes.length) { - throw new Error("Incomplete 4-byte sequence."); - } - c = (c & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63; - } - else { - throw new Error("Unknown multi-byte start."); - } - } - if (c <= 0xffff) { - result += String.fromCharCode(c); - } - else if (c <= 0x10ffff) { - c -= 0x10000; - result += String.fromCharCode(c >> 10 | 0xd800); - result += String.fromCharCode(c & 0x3FF | 0xdc00); - } - else { - throw new Error("Code point exceeds UTF-16 limit."); - } - } - return result; -} -exports.utf8Decode = utf8Decode; -//# sourceMappingURL=index.js.map - -/***/ }), - -/***/ 344: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const PotentialCustomElementName = /[a-z]([\0-\t\x2D\._a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*-([\0-\t\x2D\._a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*/; -const NamesWithHyphen = new Set(['annotation-xml', 'color-profile', - 'font-face', 'font-face-src', 'font-face-uri', 'font-face-format', - 'font-face-name', 'missing-glyph']); -const ElementNames = new Set(['article', 'aside', 'blockquote', - 'body', 'div', 'footer', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', - 'header', 'main', 'nav', 'p', 'section', 'span']); -const VoidElementNames = new Set(['area', 'base', 'basefont', - 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen', - 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']); -const ShadowHostNames = new Set(['article', 'aside', 'blockquote', 'body', - 'div', 'footer', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'main', - 'nav', 'p', 'section', 'span']); -/** - * Determines if the given string is a valid custom element name. - * - * @param name - a name string - */ -function customElement_isValidCustomElementName(name) { - if (!PotentialCustomElementName.test(name)) - return false; - if (NamesWithHyphen.has(name)) - return false; - return true; -} -exports.customElement_isValidCustomElementName = customElement_isValidCustomElementName; -/** - * Determines if the given string is a valid element name. - * - * @param name - a name string - */ -function customElement_isValidElementName(name) { - return (ElementNames.has(name)); -} -exports.customElement_isValidElementName = customElement_isValidElementName; -/** - * Determines if the given string is a void element name. - * - * @param name - a name string - */ -function customElement_isVoidElementName(name) { - return (VoidElementNames.has(name)); -} -exports.customElement_isVoidElementName = customElement_isVoidElementName; -/** - * Determines if the given string is a valid shadow host element name. - * - * @param name - a name string - */ -function customElement_isValidShadowHostName(name) { - return (ShadowHostNames.has(name)); -} -exports.customElement_isValidShadowHostName = customElement_isValidShadowHostName; -/** - * Enqueues an upgrade reaction for a custom element. - * - * @param element - a custom element - * @param definition - a custom element definition - */ -function customElement_enqueueACustomElementUpgradeReaction(element, definition) { - // TODO: Implement in HTML DOM -} -exports.customElement_enqueueACustomElementUpgradeReaction = customElement_enqueueACustomElementUpgradeReaction; -/** - * Enqueues a callback reaction for a custom element. - * - * @param element - a custom element - * @param callbackName - name of the callback - * @param args - callback arguments - */ -function customElement_enqueueACustomElementCallbackReaction(element, callbackName, args) { - // TODO: Implement in HTML DOM -} -exports.customElement_enqueueACustomElementCallbackReaction = customElement_enqueueACustomElementCallbackReaction; -/** - * Upgrade a custom element. - * - * @param element - a custom element - */ -function customElement_upgrade(definition, element) { - // TODO: Implement in HTML DOM -} -exports.customElement_upgrade = customElement_upgrade; -/** - * Tries to upgrade a custom element. - * - * @param element - a custom element - */ -function customElement_tryToUpgrade(element) { - // TODO: Implement in HTML DOM -} -exports.customElement_tryToUpgrade = customElement_tryToUpgrade; -/** - * Looks up a custom element definition. - * - * @param document - a document - * @param namespace - element namespace - * @param localName - element local name - * @param is - an `is` value - */ -function customElement_lookUpACustomElementDefinition(document, namespace, localName, is) { - // TODO: Implement in HTML DOM - return null; -} -exports.customElement_lookUpACustomElementDefinition = customElement_lookUpACustomElementDefinition; -//# sourceMappingURL=CustomElementAlgorithm.js.map - -/***/ }), - -/***/ 347: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const CodePoints_1 = __webpack_require__(780); -/** - * Base-64 encodes the given string. - * - * @param input - a string - */ -function forgivingBase64Encode(input) { - /** - * To forgiving-base64 encode given a byte sequence data, apply the base64 - * algorithm defined in section 4 of RFC 4648 to data and return the result. - * [RFC4648] - */ - return Buffer.from(input).toString('base64'); -} -exports.forgivingBase64Encode = forgivingBase64Encode; -/** - * Decodes a base-64 string. - * - * @param input - a string - */ -function forgivingBase64Decode(input) { - if (input === "") - return ""; - /** - * 1. Remove all ASCII whitespace from data. - */ - input = input.replace(CodePoints_1.ASCIIWhiteSpace, ''); - /** - * 2. If data’s length divides by 4 leaving no remainder, then: - * 2.1. If data ends with one or two U+003D (=) code points, then remove them from data. - */ - if (input.length % 4 === 0) { - if (input.endsWith("==")) { - input = input.substr(0, input.length - 2); - } - else if (input.endsWith("=")) { - input = input.substr(0, input.length - 1); - } - } - /** - * 3. If data’s length divides by 4 leaving a remainder of 1, then return failure. - */ - if (input.length % 4 === 1) - return null; - /** - * 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(input)) - return null; - /** - * 5. Let output be an empty byte sequence. - * 6. Let buffer be an empty buffer that can have bits appended to it. - * 7. Let position be a position variable for data, initially pointing at the - * start of data. - * 8. While position does not point past the end of data: - * 8.1. Find the code point pointed to by position in the second column of - * Table 1: The Base 64 Alphabet of RFC 4648. Let n be the number given in the - * first cell of the same row. [RFC4648] - * 8.2. Append the six bits corresponding to n, most significant bit first, - * to buffer. - * 8.3. If buffer has accumulated 24 bits, interpret them as three 8-bit - * big-endian numbers. Append three bytes with values equal to those numbers - * to output, in the same order, and then empty buffer. - * 8.4. Advance position by 1. - * 9. If buffer is not empty, it contains either 12 or 18 bits. If it contains - * 12 bits, then discard the last four and interpret the remaining eight as an - * 8-bit big-endian number. If it contains 18 bits, then discard the last two - * and interpret the remaining 16 as two 8-bit big-endian numbers. Append the - * one or two bytes with values equal to those one or two numbers to output, - * in the same order. - * 10. Return output. - */ - return Buffer.from(input, 'base64').toString('utf8'); -} -exports.forgivingBase64Decode = forgivingBase64Decode; -//# sourceMappingURL=Base64.js.map - -/***/ }), - -/***/ 350: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const TreeAlgorithm_1 = __webpack_require__(873); -/** - * Defines the position of a boundary point relative to another. - * - * @param bp - a boundary point - * @param relativeTo - a boundary point to compare to - */ -function boundaryPoint_position(bp, relativeTo) { - const nodeA = bp[0]; - const offsetA = bp[1]; - const nodeB = relativeTo[0]; - const offsetB = relativeTo[1]; - /** - * 1. Assert: nodeA and nodeB have the same root. - */ - console.assert(TreeAlgorithm_1.tree_rootNode(nodeA) === TreeAlgorithm_1.tree_rootNode(nodeB), "Boundary points must share the same root node."); - /** - * 2. If nodeA is nodeB, then return equal if offsetA is offsetB, before - * if offsetA is less than offsetB, and after if offsetA is greater than - * offsetB. - */ - if (nodeA === nodeB) { - if (offsetA === offsetB) { - return interfaces_1.BoundaryPosition.Equal; - } - else if (offsetA < offsetB) { - return interfaces_1.BoundaryPosition.Before; - } - else { - return interfaces_1.BoundaryPosition.After; - } - } - /** - * 3. If nodeA is following nodeB, then if the position of (nodeB, offsetB) - * relative to (nodeA, offsetA) is before, return after, and if it is after, - * return before. - */ - if (TreeAlgorithm_1.tree_isFollowing(nodeB, nodeA)) { - const pos = boundaryPoint_position([nodeB, offsetB], [nodeA, offsetA]); - if (pos === interfaces_1.BoundaryPosition.Before) { - return interfaces_1.BoundaryPosition.After; - } - else if (pos === interfaces_1.BoundaryPosition.After) { - return interfaces_1.BoundaryPosition.Before; - } - } - /** - * 4. If nodeA is an ancestor of nodeB: - */ - if (TreeAlgorithm_1.tree_isAncestorOf(nodeB, nodeA)) { - /** - * 4.1. Let child be nodeB. - * 4.2. While child is not a child of nodeA, set child to its parent. - * 4.3. If child’s index is less than offsetA, then return after. - */ - let child = nodeB; - while (!TreeAlgorithm_1.tree_isChildOf(nodeA, child)) { - /* istanbul ignore else */ - if (child._parent !== null) { - child = child._parent; - } - } - if (TreeAlgorithm_1.tree_index(child) < offsetA) { - return interfaces_1.BoundaryPosition.After; - } - } - /** - * 5. Return before. - */ - return interfaces_1.BoundaryPosition.Before; -} -exports.boundaryPoint_position = boundaryPoint_position; -//# sourceMappingURL=BoundaryPointAlgorithm.js.map - -/***/ }), - -/***/ 357: -/***/ (function(module) { - -module.exports = require("assert"); - -/***/ }), - -/***/ 392: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * A namespace prefix map is a map that associates namespaceURI and namespace - * prefix lists, where namespaceURI values are the map's unique keys (which can - * include the null value representing no namespace), and ordered lists of - * associated prefix values are the map's key values. The namespace prefix map - * will be populated by previously seen namespaceURIs and all their previously - * encountered prefix associations for a given node and its ancestors. - * - * _Note:_ The last seen prefix for a given namespaceURI is at the end of its - * respective list. The list is searched to find potentially matching prefixes, - * and if no matches are found for the given namespaceURI, then the last prefix - * in the list is used. See copy a namespace prefix map and retrieve a preferred - * prefix string for additional details. - * - * See: https://w3c.github.io/DOM-Parsing/#the-namespace-prefix-map - */ -class NamespacePrefixMap { - constructor() { - this._items = {}; - this._nullItems = []; - } - /** - * Creates a copy of the map. - */ - copy() { - /** - * To copy a namespace prefix map map means to copy the map's keys into a - * new empty namespace prefix map, and to copy each of the values in the - * namespace prefix list associated with each keys' value into a new list - * which should be associated with the respective key in the new map. - */ - const mapCopy = new NamespacePrefixMap(); - for (const key in this._items) { - mapCopy._items[key] = this._items[key].slice(0); - } - mapCopy._nullItems = this._nullItems.slice(0); - return mapCopy; - } - /** - * Retrieves a preferred prefix string from the namespace prefix map. - * - * @param preferredPrefix - preferred prefix string - * @param ns - namespace - */ - get(preferredPrefix, ns) { - /** - * 1. Let candidates list be the result of retrieving a list from map where - * there exists a key in map that matches the value of ns or if there is no - * such key, then stop running these steps, and return the null value. - */ - const candidatesList = ns === null ? this._nullItems : (this._items[ns] || null); - if (candidatesList === null) { - return null; - } - /** - * 2. Otherwise, for each prefix value prefix in candidates list, iterating - * from beginning to end: - * - * _Note:_ There will always be at least one prefix value in the list. - */ - let prefix = null; - for (let i = 0; i < candidatesList.length; i++) { - prefix = candidatesList[i]; - /** - * 2.1. If prefix matches preferred prefix, then stop running these steps - * and return prefix. - */ - if (prefix === preferredPrefix) { - return prefix; - } - } - /** - * 2.2. If prefix is the last item in the candidates list, then stop - * running these steps and return prefix. - */ - return prefix; - } - /** - * Checks if a prefix string is found in the namespace prefix map associated - * with the given namespace. - * - * @param prefix - prefix string - * @param ns - namespace - */ - has(prefix, ns) { - /** - * 1. Let candidates list be the result of retrieving a list from map where - * there exists a key in map that matches the value of ns or if there is - * no such key, then stop running these steps, and return false. - */ - const candidatesList = ns === null ? this._nullItems : (this._items[ns] || null); - if (candidatesList === null) { - return false; - } - /** - * 2. If the value of prefix occurs at least once in candidates list, - * return true, otherwise return false. - */ - return (candidatesList.indexOf(prefix) !== -1); - } - /** - * Checks if a prefix string is found in the namespace prefix map. - * - * @param prefix - prefix string - */ - hasPrefix(prefix) { - if (this._nullItems.indexOf(prefix) !== -1) - return true; - for (const key in this._items) { - if (this._items[key].indexOf(prefix) !== -1) - return true; - } - return false; - } - /** - * Adds a prefix string associated with a namespace to the prefix map. - * - * @param prefix - prefix string - * @param ns - namespace - */ - set(prefix, ns) { - /** - * 1. Let candidates list be the result of retrieving a list from map where - * there exists a key in map that matches the value of ns or if there is - * no such key, then let candidates list be null. - */ - const candidatesList = ns === null ? this._nullItems : (this._items[ns] || null); - /** - * 2. If candidates list is null, then create a new list with prefix as the - * only item in the list, and associate that list with a new key ns in map. - * 3. Otherwise, append prefix to the end of candidates list. - * - * _Note:_ The steps in retrieve a preferred prefix string use the list to - * track the most recently used (MRU) prefix associated with a given - * namespace, which will be the prefix at the end of the list. This list - * may contain duplicates of the same prefix value seen earlier - * (and that's OK). - */ - if (ns !== null && candidatesList === null) { - this._items[ns] = [prefix]; - } - else { - candidatesList.push(prefix); - } - } -} -exports.NamespacePrefixMap = NamespacePrefixMap; -//# sourceMappingURL=NamespacePrefixMap.js.map - -/***/ }), - -/***/ 413: -/***/ (function(module, __unusedexports, __webpack_require__) { - -module.exports = __webpack_require__(141); - - -/***/ }), - -/***/ 417: -/***/ (function(module) { - -module.exports = require("crypto"); - -/***/ }), - -/***/ 419: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(592); -const interfaces_1 = __webpack_require__(970); -const BaseWriter_1 = __webpack_require__(462); -/** - * Serializes XML nodes into objects and arrays. - */ -class ObjectWriter extends BaseWriter_1.BaseWriter { - /** - * Produces an XML serialization of the given node. - * - * @param node - node to serialize - * @param writerOptions - serialization options - */ - serialize(node, writerOptions) { - const options = util_1.applyDefaults(writerOptions, { - format: "object", - wellFormed: false, - noDoubleEncoding: false, - group: false - }); - this._currentList = []; - this._currentIndex = 0; - this._listRegister = [this._currentList]; - /** - * First pass, serialize nodes - * This creates a list of nodes grouped under node types while preserving - * insertion order. For example: - * [ - * root: [ - * node: [ - * { "@" : { "att1": "val1", "att2": "val2" } - * { "#": "node text" } - * { childNode: [] } - * { "#": "more text" } - * ], - * node: [ - * { "@" : { "att": "val" } - * { "#": [ "text line1", "text line2" ] } - * ] - * ] - * ] - */ - this.serializeNode(node, options.wellFormed, options.noDoubleEncoding); - /** - * Second pass, process node lists. Above example becomes: - * { - * root: { - * node: [ - * { - * "@att1": "val1", - * "@att2": "val2", - * "#1": "node text", - * childNode: {}, - * "#2": "more text" - * }, - * { - * "@att": "val", - * "#": [ "text line1", "text line2" ] - * } - * ] - * } - * } - */ - return this._process(this._currentList, options); - } - _process(items, options) { - if (items.length === 0) - return {}; - // determine if there are non-unique element names - const namesSeen = {}; - let hasNonUniqueNames = false; - let textCount = 0; - let commentCount = 0; - let instructionCount = 0; - let cdataCount = 0; - for (let i = 0; i < items.length; i++) { - const item = items[i]; - const key = Object.keys(item)[0]; - switch (key) { - case "@": - continue; - case "#": - textCount++; - break; - case "!": - commentCount++; - break; - case "?": - instructionCount++; - break; - case "$": - cdataCount++; - break; - default: - if (namesSeen[key]) { - hasNonUniqueNames = true; - } - else { - namesSeen[key] = true; - } - break; - } - } - const defAttrKey = this._getAttrKey(); - const defTextKey = this._getNodeKey(interfaces_1.NodeType.Text); - const defCommentKey = this._getNodeKey(interfaces_1.NodeType.Comment); - const defInstructionKey = this._getNodeKey(interfaces_1.NodeType.ProcessingInstruction); - const defCdataKey = this._getNodeKey(interfaces_1.NodeType.CData); - if (textCount === 1 && items.length === 1 && util_1.isString(items[0]["#"])) { - // special case of an element node with a single text node - return items[0]["#"]; - } - else if (hasNonUniqueNames) { - // list contains element nodes with non-unique names - // return an array with mixed content notation - const result = []; - const obj = { [defTextKey]: result }; - for (let i = 0; i < items.length; i++) { - const item = items[i]; - const key = Object.keys(item)[0]; - switch (key) { - case "@": - const attrs = item["@"]; - const attrKeys = Object.keys(attrs); - if (attrKeys.length === 1) { - result.push({ [defAttrKey + attrKeys[0]]: attrs[attrKeys[0]] }); - } - else { - result.push({ [defAttrKey]: item["@"] }); - } - break; - case "#": - result.push({ [defTextKey]: item["#"] }); - break; - case "!": - result.push({ [defCommentKey]: item["!"] }); - break; - case "?": - result.push({ [defInstructionKey]: item["?"] }); - break; - case "$": - result.push({ [defCdataKey]: item["$"] }); - break; - default: - // element node - const ele = item; - if (ele[key].length !== 0 && util_1.isArray(ele[key][0])) { - // group of element nodes - const eleGroup = []; - const listOfLists = ele[key]; - for (let i = 0; i < listOfLists.length; i++) { - eleGroup.push(this._process(listOfLists[i], options)); - } - result.push({ [key]: eleGroup }); - } - else { - // single element node - result.push({ [key]: this._process(ele[key], options) }); - } - break; - } - } - return obj; - } - else { - // all element nodes have unique names - // return an object while prefixing data node keys - let textId = 1; - let commentId = 1; - let instructionId = 1; - let cdataId = 1; - const obj = {}; - for (let i = 0; i < items.length; i++) { - const item = items[i]; - const key = Object.keys(item)[0]; - switch (key) { - case "@": - const attrs = item["@"]; - const attrKeys = Object.keys(attrs); - if (!options.group || attrKeys.length === 1) { - for (const attrName in attrs) { - obj[defAttrKey + attrName] = attrs[attrName]; - } - } - else { - obj[defAttrKey] = attrs; - } - break; - case "#": - textId = this._processSpecItem(item["#"], obj, options.group, defTextKey, textCount, textId); - break; - case "!": - commentId = this._processSpecItem(item["!"], obj, options.group, defCommentKey, commentCount, commentId); - break; - case "?": - instructionId = this._processSpecItem(item["?"], obj, options.group, defInstructionKey, instructionCount, instructionId); - break; - case "$": - cdataId = this._processSpecItem(item["$"], obj, options.group, defCdataKey, cdataCount, cdataId); - break; - default: - // element node - const ele = item; - if (ele[key].length !== 0 && util_1.isArray(ele[key][0])) { - // group of element nodes - const eleGroup = []; - const listOfLists = ele[key]; - for (let i = 0; i < listOfLists.length; i++) { - eleGroup.push(this._process(listOfLists[i], options)); - } - obj[key] = eleGroup; - } - else { - // single element node - obj[key] = this._process(ele[key], options); - } - break; - } - } - return obj; - } - } - _processSpecItem(item, obj, group, defKey, count, id) { - if (!group && util_1.isArray(item) && count + item.length > 2) { - for (const subItem of item) { - const key = defKey + (id++).toString(); - obj[key] = subItem; - } - } - else { - const key = count > 1 ? defKey + (id++).toString() : defKey; - obj[key] = item; - } - return id; - } - /** @inheritdoc */ - beginElement(name) { - const childItems = []; - if (this._currentList.length === 0) { - this._currentList.push({ [name]: childItems }); - } - else { - const lastItem = this._currentList[this._currentList.length - 1]; - if (this._isElementNode(lastItem, name)) { - if (lastItem[name].length !== 0 && util_1.isArray(lastItem[name][0])) { - const listOfLists = lastItem[name]; - listOfLists.push(childItems); - } - else { - lastItem[name] = [lastItem[name], childItems]; - } - } - else { - this._currentList.push({ [name]: childItems }); - } - } - this._currentIndex++; - if (this._listRegister.length > this._currentIndex) { - this._listRegister[this._currentIndex] = childItems; - } - else { - this._listRegister.push(childItems); - } - this._currentList = childItems; - } - /** @inheritdoc */ - endElement() { - this._currentList = this._listRegister[--this._currentIndex]; - } - /** @inheritdoc */ - attribute(name, value) { - if (this._currentList.length === 0) { - this._currentList.push({ "@": { [name]: value } }); - } - else { - const lastItem = this._currentList[this._currentList.length - 1]; - /* istanbul ignore else */ - if (this._isAttrNode(lastItem)) { - lastItem["@"][name] = value; - } - else { - this._currentList.push({ "@": { [name]: value } }); - } - } - } - /** @inheritdoc */ - comment(data) { - if (this._currentList.length === 0) { - this._currentList.push({ "!": data }); - } - else { - const lastItem = this._currentList[this._currentList.length - 1]; - if (this._isCommentNode(lastItem)) { - if (util_1.isArray(lastItem["!"])) { - lastItem["!"].push(data); - } - else { - lastItem["!"] = [lastItem["!"], data]; - } - } - else { - this._currentList.push({ "!": data }); - } - } - } - /** @inheritdoc */ - text(data) { - if (this._currentList.length === 0) { - this._currentList.push({ "#": data }); - } - else { - const lastItem = this._currentList[this._currentList.length - 1]; - if (this._isTextNode(lastItem)) { - if (util_1.isArray(lastItem["#"])) { - lastItem["#"].push(data); - } - else { - lastItem["#"] = [lastItem["#"], data]; - } - } - else { - this._currentList.push({ "#": data }); - } - } - } - /** @inheritdoc */ - instruction(target, data) { - const value = (data === "" ? target : target + " " + data); - if (this._currentList.length === 0) { - this._currentList.push({ "?": value }); - } - else { - const lastItem = this._currentList[this._currentList.length - 1]; - if (this._isInstructionNode(lastItem)) { - if (util_1.isArray(lastItem["?"])) { - lastItem["?"].push(value); - } - else { - lastItem["?"] = [lastItem["?"], value]; - } - } - else { - this._currentList.push({ "?": value }); - } - } - } - /** @inheritdoc */ - cdata(data) { - if (this._currentList.length === 0) { - this._currentList.push({ "$": data }); - } - else { - const lastItem = this._currentList[this._currentList.length - 1]; - if (this._isCDATANode(lastItem)) { - if (util_1.isArray(lastItem["$"])) { - lastItem["$"].push(data); - } - else { - lastItem["$"] = [lastItem["$"], data]; - } - } - else { - this._currentList.push({ "$": data }); - } - } - } - _isAttrNode(x) { - return "@" in x; - } - _isTextNode(x) { - return "#" in x; - } - _isCommentNode(x) { - return "!" in x; - } - _isInstructionNode(x) { - return "?" in x; - } - _isCDATANode(x) { - return "$" in x; - } - _isElementNode(x, name) { - return name in x; - } - /** - * Returns an object key for an attribute or namespace declaration. - */ - _getAttrKey() { - return this._builderOptions.convert.att; - } - /** - * Returns an object key for the given node type. - * - * @param nodeType - node type to get a key for - */ - _getNodeKey(nodeType) { - switch (nodeType) { - case interfaces_1.NodeType.Comment: - return this._builderOptions.convert.comment; - case interfaces_1.NodeType.Text: - return this._builderOptions.convert.text; - case interfaces_1.NodeType.ProcessingInstruction: - return this._builderOptions.convert.ins; - case interfaces_1.NodeType.CData: - return this._builderOptions.convert.cdata; - /* istanbul ignore next */ - default: - throw new Error("Invalid node type."); - } - } -} -exports.ObjectWriter = ObjectWriter; -//# sourceMappingURL=ObjectWriter.js.map - -/***/ }), - -/***/ 425: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Returns the count of bytes in a sequence. - * - * @param list - a byte sequence - */ -function length(list) { - /** - * A byte sequence’s length is the number of bytes it contains. - */ - return list.length; -} -exports.length = length; -/** - * Converts each byte to lowercase. - * - * @param list - a byte sequence - */ -function byteLowercase(list) { - /** - * To byte-lowercase a byte sequence, increase each byte it contains, in the - * range 0x41 (A) to 0x5A (Z), inclusive, by 0x20. - */ - for (let i = 0; i < list.length; i++) { - const c = list[i]; - if (c >= 0x41 && c <= 0x5A) { - list[i] = c + 0x20; - } - } -} -exports.byteLowercase = byteLowercase; -/** - * Converts each byte to uppercase. - * - * @param list - a byte sequence - */ -function byteUppercase(list) { - /** - * To byte-uppercase a byte sequence, subtract each byte it contains, in the - * range 0x61 (a) to 0x7A (z), inclusive, by 0x20. - */ - for (let i = 0; i < list.length; i++) { - const c = list[i]; - if (c >= 0x61 && c <= 0x7A) { - list[i] = c - 0x20; - } - } -} -exports.byteUppercase = byteUppercase; -/** - * Compares two byte sequences. - * - * @param listA - a byte sequence - * @param listB - a byte sequence - */ -function byteCaseInsensitiveMatch(listA, listB) { - /** - * A byte sequence A is a byte-case-insensitive match for a byte sequence B, - * if the byte-lowercase of A is the byte-lowercase of B. - */ - if (listA.length !== listB.length) - return false; - for (let i = 0; i < listA.length; i++) { - let a = listA[i]; - let b = listB[i]; - if (a >= 0x41 && a <= 0x5A) - a += 0x20; - if (b >= 0x41 && b <= 0x5A) - b += 0x20; - if (a !== b) - return false; - } - return true; -} -exports.byteCaseInsensitiveMatch = byteCaseInsensitiveMatch; -/** - * Determines if `listA` starts with `listB`. - * - * @param listA - a byte sequence - * @param listB - a byte sequence - */ -function startsWith(listA, listB) { - /** - * 1. Let i be 0. - * 2. While true: - * 2.1. Let aByte be the ith byte of a if i is less than a’s length; otherwise null. - * 2.3. Let bByte be the ith byte of b if i is less than b’s length; otherwise null. - * 2.4. If bByte is null, then return true. - * 2.5. Return false if aByte is not bByte. - * 2.6. Set i to i + 1. - */ - let i = 0; - while (true) { - if (i >= listA.length) - return false; - if (i >= listB.length) - return true; - if (listA[i] !== listB[i]) - return false; - i++; - } -} -exports.startsWith = startsWith; -/** - * Determines if `listA` is less than `listB`. - * - * @param listA - a byte sequence - * @param listB - a byte sequence - */ -function byteLessThan(listA, listB) { - /** - * 1. If b starts with a, then return false. - * 2. If a starts with b, then return true. - * 3. Let n be the smallest index such that the nth byte of a is different - * from the nth byte of b. (There has to be such an index, since neither byte - * sequence starts with the other.) - * 4. If the nth byte of a is less than the nth byte of b, then return true. - * 5. Return false. - */ - let i = 0; - while (true) { - if (i >= listA.length) - return false; - if (i >= listB.length) - return true; - const a = listA[i]; - const b = listB[i]; - if (a < b) - return true; - else if (a > b) - return false; - i++; - } -} -exports.byteLessThan = byteLessThan; -/** - * Decodes a byte sequence into a string. - * - * @param list - a byte sequence - */ -function isomorphicDecode(list) { - /** - * To isomorphic decode a byte sequence input, return a string whose length is - * equal to input’s length and whose code points have the same values as - * input’s bytes, in the same order. - */ - return String.fromCodePoint(...list); -} -exports.isomorphicDecode = isomorphicDecode; -//# sourceMappingURL=ByteSequence.js.map - -/***/ }), - -/***/ 427: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const algorithm_1 = __webpack_require__(163); -const WebIDLAlgorithm_1 = __webpack_require__(495); -/** - * Represents a DOM event. - */ -class EventImpl { - /** - * Initializes a new instance of `Event`. - */ - constructor(type, eventInit) { - this._target = null; - this._relatedTarget = null; - this._touchTargetList = []; - this._path = []; - this._currentTarget = null; - this._eventPhase = interfaces_1.EventPhase.None; - this._stopPropagationFlag = false; - this._stopImmediatePropagationFlag = false; - this._canceledFlag = false; - this._inPassiveListenerFlag = false; - this._composedFlag = false; - this._initializedFlag = false; - this._dispatchFlag = false; - this._isTrusted = false; - this._bubbles = false; - this._cancelable = false; - /** - * When a constructor of the Event interface, or of an interface that - * inherits from the Event interface, is invoked, these steps must be run, - * given the arguments type and eventInitDict: - * 1. Let event be the result of running the inner event creation steps with - * this interface, null, now, and eventInitDict. - * 2. Initialize event’s type attribute to type. - * 3. Return event. - */ - this._type = type; - if (eventInit) { - this._bubbles = eventInit.bubbles || false; - this._cancelable = eventInit.cancelable || false; - this._composedFlag = eventInit.composed || false; - } - this._initializedFlag = true; - this._timeStamp = new Date().getTime(); - } - /** @inheritdoc */ - get type() { return this._type; } - /** @inheritdoc */ - get target() { return this._target; } - /** @inheritdoc */ - get srcElement() { return this._target; } - /** @inheritdoc */ - get currentTarget() { return this._currentTarget; } - /** @inheritdoc */ - composedPath() { - /** - * 1. Let composedPath be an empty list. - * 2. Let path be the context object’s path. - * 3. If path is empty, then return composedPath. - * 4. Let currentTarget be the context object’s currentTarget attribute - * value. - * 5. Append currentTarget to composedPath. - * 6. Let currentTargetIndex be 0. - * 7. Let currentTargetHiddenSubtreeLevel be 0. - */ - const composedPath = []; - const path = this._path; - if (path.length === 0) - return composedPath; - const currentTarget = this._currentTarget; - if (currentTarget === null) { - throw new Error("Event currentTarget is null."); - } - composedPath.push(currentTarget); - let currentTargetIndex = 0; - let currentTargetHiddenSubtreeLevel = 0; - /** - * 8. Let index be path’s size − 1. - * 9. While index is greater than or equal to 0: - */ - let index = path.length - 1; - while (index >= 0) { - /** - * 9.1. If path[index]'s root-of-closed-tree is true, then increase - * currentTargetHiddenSubtreeLevel by 1. - * 9.2. If path[index]'s invocation target is currentTarget, then set - * currentTargetIndex to index and break. - * 9.3. If path[index]'s slot-in-closed-tree is true, then decrease - * currentTargetHiddenSubtreeLevel by 1. - * 9.4. Decrease index by 1. - */ - if (path[index].rootOfClosedTree) { - currentTargetHiddenSubtreeLevel++; - } - if (path[index].invocationTarget === currentTarget) { - currentTargetIndex = index; - break; - } - if (path[index].slotInClosedTree) { - currentTargetHiddenSubtreeLevel--; - } - index--; - } - /** - * 10. Let currentHiddenLevel and maxHiddenLevel be - * currentTargetHiddenSubtreeLevel. - */ - let currentHiddenLevel = currentTargetHiddenSubtreeLevel; - let maxHiddenLevel = currentTargetHiddenSubtreeLevel; - /** - * 11. Set index to currentTargetIndex − 1. - * 12. While index is greater than or equal to 0: - */ - index = currentTargetIndex - 1; - while (index >= 0) { - /** - * 12.1. If path[index]'s root-of-closed-tree is true, then increase - * currentHiddenLevel by 1. - * 12.2. If currentHiddenLevel is less than or equal to maxHiddenLevel, - * then prepend path[index]'s invocation target to composedPath. - */ - if (path[index].rootOfClosedTree) { - currentHiddenLevel++; - } - if (currentHiddenLevel <= maxHiddenLevel) { - composedPath.unshift(path[index].invocationTarget); - } - /** - * 12.3. If path[index]'s slot-in-closed-tree is true, then: - */ - if (path[index].slotInClosedTree) { - /** - * 12.3.1. Decrease currentHiddenLevel by 1. - * 12.3.2. If currentHiddenLevel is less than maxHiddenLevel, then set - * maxHiddenLevel to currentHiddenLevel. - */ - currentHiddenLevel--; - if (currentHiddenLevel < maxHiddenLevel) { - maxHiddenLevel = currentHiddenLevel; - } - } - /** - * 12.4. Decrease index by 1. - */ - index--; - } - /** - * 13. Set currentHiddenLevel and maxHiddenLevel to - * currentTargetHiddenSubtreeLevel. - */ - currentHiddenLevel = currentTargetHiddenSubtreeLevel; - maxHiddenLevel = currentTargetHiddenSubtreeLevel; - /** - * 14. Set index to currentTargetIndex + 1. - * 15. While index is less than path’s size: - */ - index = currentTargetIndex + 1; - while (index < path.length) { - /** - * 15.1. If path[index]'s slot-in-closed-tree is true, then increase - * currentHiddenLevel by 1. - * 15.2. If currentHiddenLevel is less than or equal to maxHiddenLevel, - * then append path[index]'s invocation target to composedPath. - */ - if (path[index].slotInClosedTree) { - currentHiddenLevel++; - } - if (currentHiddenLevel <= maxHiddenLevel) { - composedPath.push(path[index].invocationTarget); - } - /** - * 15.3. If path[index]'s root-of-closed-tree is true, then: - */ - if (path[index].rootOfClosedTree) { - /** - * 15.3.1. Decrease currentHiddenLevel by 1. - * 15.3.2. If currentHiddenLevel is less than maxHiddenLevel, then set - * maxHiddenLevel to currentHiddenLevel. - */ - currentHiddenLevel--; - if (currentHiddenLevel < maxHiddenLevel) { - maxHiddenLevel = currentHiddenLevel; - } - } - /** - * 15.4. Increase index by 1. - */ - index++; - } - /** - * 16. Return composedPath. - */ - return composedPath; - } - /** @inheritdoc */ - get eventPhase() { return this._eventPhase; } - /** @inheritdoc */ - stopPropagation() { this._stopPropagationFlag = true; } - /** @inheritdoc */ - get cancelBubble() { return this._stopPropagationFlag; } - set cancelBubble(value) { if (value) - this.stopPropagation(); } - /** @inheritdoc */ - stopImmediatePropagation() { - this._stopPropagationFlag = true; - this._stopImmediatePropagationFlag = true; - } - /** @inheritdoc */ - get bubbles() { return this._bubbles; } - /** @inheritdoc */ - get cancelable() { return this._cancelable; } - /** @inheritdoc */ - get returnValue() { return !this._canceledFlag; } - set returnValue(value) { - if (!value) { - algorithm_1.event_setTheCanceledFlag(this); - } - } - /** @inheritdoc */ - preventDefault() { - algorithm_1.event_setTheCanceledFlag(this); - } - /** @inheritdoc */ - get defaultPrevented() { return this._canceledFlag; } - /** @inheritdoc */ - get composed() { return this._composedFlag; } - /** @inheritdoc */ - get isTrusted() { return this._isTrusted; } - /** @inheritdoc */ - get timeStamp() { return this._timeStamp; } - /** @inheritdoc */ - initEvent(type, bubbles = false, cancelable = false) { - /** - * 1. If the context object’s dispatch flag is set, then return. - */ - if (this._dispatchFlag) - return; - /** - * 2. Initialize the context object with type, bubbles, and cancelable. - */ - algorithm_1.event_initialize(this, type, bubbles, cancelable); - } -} -exports.EventImpl = EventImpl; -EventImpl.NONE = 0; -EventImpl.CAPTURING_PHASE = 1; -EventImpl.AT_TARGET = 2; -EventImpl.BUBBLING_PHASE = 3; -/** - * Define constants on prototype. - */ -WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "NONE", 0); -WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "CAPTURING_PHASE", 1); -WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "AT_TARGET", 2); -WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "BUBBLING_PHASE", 3); -//# sourceMappingURL=EventImpl.js.map - -/***/ }), - -/***/ 429: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Appends the given item to the queue. - * - * @param list - a list - * @param item - an item - */ -function enqueue(list, item) { - list.push(item); -} -exports.enqueue = enqueue; -/** - * Removes and returns an item from the queue. - * - * @param list - a list - */ -function dequeue(list) { - return list.shift() || null; -} -exports.dequeue = dequeue; -//# sourceMappingURL=Queue.js.map - -/***/ }), - -/***/ 431: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); }; -Object.defineProperty(exports, "__esModule", { value: true }); -const os = __importStar(__webpack_require__(87)); -const utils_1 = __webpack_require__(82); -/** - * Commands - * - * Command Format: - * ::name key=value,key=value::message - * - * Examples: - * ::warning::This is the message - * ::set-env name=MY_VAR::some value - */ -function issueCommand(command, properties, message) { - const cmd = new Command(command, properties, message); - process.stdout.write(cmd.toString() + os.EOL); -} -exports.issueCommand = issueCommand; -function issue(name, message = '') { - issueCommand(name, {}, message); -} -exports.issue = issue; -const CMD_STRING = '::'; -class Command { - constructor(command, properties, message) { - if (!command) { - command = 'missing.command'; - } - this.command = command; - this.properties = properties; - this.message = message; - } - toString() { - let cmdStr = CMD_STRING + this.command; - if (this.properties && Object.keys(this.properties).length > 0) { - cmdStr += ' '; - let first = true; - for (const key in this.properties) { - if (this.properties.hasOwnProperty(key)) { - const val = this.properties[key]; - if (val) { - if (first) { - first = false; - } - else { - cmdStr += ','; - } - cmdStr += `${key}=${escapeProperty(val)}`; - } - } - } - } - cmdStr += `${CMD_STRING}${escapeData(this.message)}`; - return cmdStr; - } -} -function escapeData(s) { - return utils_1.toCommandValue(s) - .replace(/%/g, '%25') - .replace(/\r/g, '%0D') - .replace(/\n/g, '%0A'); -} -function escapeProperty(s) { - return utils_1.toCommandValue(s) - .replace(/%/g, '%25') - .replace(/\r/g, '%0D') - .replace(/\n/g, '%0A') - .replace(/:/g, '%3A') - .replace(/,/g, '%2C'); -} -//# sourceMappingURL=command.js.map - -/***/ }), - -/***/ 441: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents a cache for storing order between equal objects. - * - * This cache is used when an algorithm compares two objects and finds them to - * be equal but still needs to establish an order between those two objects. - * When two such objects `a` and `b` are passed to the `check` method, a random - * number is generated with `Math.random()`. If the random number is less than - * `0.5` it is assumed that `a < b` otherwise `a > b`. The random number along - * with `a` and `b` is stored in the cache, so that subsequent checks result - * in the same consistent result. - * - * The cache has a size limit which is defined on initialization. - */ -class CompareCache { - /** - * Initializes a new instance of `CompareCache`. - * - * @param limit - maximum number of items to keep in the cache. When the limit - * is exceeded the first item is removed from the cache. - */ - constructor(limit = 1000) { - this._items = new Map(); - this._limit = limit; - } - /** - * Compares and caches the given objects. Returns `true` if `objA < objB` and - * `false` otherwise. - * - * @param objA - an item to compare - * @param objB - an item to compare - */ - check(objA, objB) { - if (this._items.get(objA) === objB) - return true; - else if (this._items.get(objB) === objA) - return false; - const result = (Math.random() < 0.5); - if (result) { - this._items.set(objA, objB); - } - else { - this._items.set(objB, objA); - } - if (this._items.size > this._limit) { - const it = this._items.keys().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - return result; - } -} -exports.CompareCache = CompareCache; -//# sourceMappingURL=CompareCache.js.map - -/***/ }), - -/***/ 442: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Determines if the given string is valid for a `"Name"` construct. - * - * @param name - name string to test - */ -function xml_isName(name) { - for (let i = 0; i < name.length; i++) { - let n = name.charCodeAt(i); - // NameStartChar - if ((n >= 97 && n <= 122) || // [a-z] - (n >= 65 && n <= 90) || // [A-Z] - n === 58 || n === 95 || // ':' or '_' - (n >= 0xC0 && n <= 0xD6) || - (n >= 0xD8 && n <= 0xF6) || - (n >= 0xF8 && n <= 0x2FF) || - (n >= 0x370 && n <= 0x37D) || - (n >= 0x37F && n <= 0x1FFF) || - (n >= 0x200C && n <= 0x200D) || - (n >= 0x2070 && n <= 0x218F) || - (n >= 0x2C00 && n <= 0x2FEF) || - (n >= 0x3001 && n <= 0xD7FF) || - (n >= 0xF900 && n <= 0xFDCF) || - (n >= 0xFDF0 && n <= 0xFFFD)) { - continue; - } - else if (i !== 0 && - (n === 45 || n === 46 || // '-' or '.' - (n >= 48 && n <= 57) || // [0-9] - (n === 0xB7) || - (n >= 0x0300 && n <= 0x036F) || - (n >= 0x203F && n <= 0x2040))) { - continue; - } - if (n >= 0xD800 && n <= 0xDBFF && i < name.length - 1) { - const n2 = name.charCodeAt(i + 1); - if (n2 >= 0xDC00 && n2 <= 0xDFFF) { - n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000; - i++; - if (n >= 0x10000 && n <= 0xEFFFF) { - continue; - } - } - } - return false; - } - return true; -} -exports.xml_isName = xml_isName; -/** - * Determines if the given string is valid for a `"QName"` construct. - * - * @param name - name string to test - */ -function xml_isQName(name) { - let colonFound = false; - for (let i = 0; i < name.length; i++) { - let n = name.charCodeAt(i); - // NameStartChar - if ((n >= 97 && n <= 122) || // [a-z] - (n >= 65 && n <= 90) || // [A-Z] - n === 95 || // '_' - (n >= 0xC0 && n <= 0xD6) || - (n >= 0xD8 && n <= 0xF6) || - (n >= 0xF8 && n <= 0x2FF) || - (n >= 0x370 && n <= 0x37D) || - (n >= 0x37F && n <= 0x1FFF) || - (n >= 0x200C && n <= 0x200D) || - (n >= 0x2070 && n <= 0x218F) || - (n >= 0x2C00 && n <= 0x2FEF) || - (n >= 0x3001 && n <= 0xD7FF) || - (n >= 0xF900 && n <= 0xFDCF) || - (n >= 0xFDF0 && n <= 0xFFFD)) { - continue; - } - else if (i !== 0 && - (n === 45 || n === 46 || // '-' or '.' - (n >= 48 && n <= 57) || // [0-9] - (n === 0xB7) || - (n >= 0x0300 && n <= 0x036F) || - (n >= 0x203F && n <= 0x2040))) { - continue; - } - else if (i !== 0 && n === 58) { // : - if (colonFound) - return false; // multiple colons in qname - if (i === name.length - 1) - return false; // colon at the end of qname - colonFound = true; - continue; - } - if (n >= 0xD800 && n <= 0xDBFF && i < name.length - 1) { - const n2 = name.charCodeAt(i + 1); - if (n2 >= 0xDC00 && n2 <= 0xDFFF) { - n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000; - i++; - if (n >= 0x10000 && n <= 0xEFFFF) { - continue; - } - } - } - return false; - } - return true; -} -exports.xml_isQName = xml_isQName; -/** - * Determines if the given string contains legal characters. - * - * @param chars - sequence of characters to test - */ -function xml_isLegalChar(chars) { - for (let i = 0; i < chars.length; i++) { - let n = chars.charCodeAt(i); - // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] - if (n === 0x9 || n === 0xA || n === 0xD || - (n >= 0x20 && n <= 0xD7FF) || - (n >= 0xE000 && n <= 0xFFFD)) { - continue; - } - if (n >= 0xD800 && n <= 0xDBFF && i < chars.length - 1) { - const n2 = chars.charCodeAt(i + 1); - if (n2 >= 0xDC00 && n2 <= 0xDFFF) { - n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000; - i++; - if (n >= 0x10000 && n <= 0x10FFFF) { - continue; - } - } - } - return false; - } - return true; -} -exports.xml_isLegalChar = xml_isLegalChar; -/** - * Determines if the given string contains legal characters for a public - * identifier. - * - * @param chars - sequence of characters to test - */ -function xml_isPubidChar(chars) { - for (let i = 0; i < chars.length; i++) { - // PubId chars are all in the ASCII range, no need to check surrogates - const n = chars.charCodeAt(i); - // #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] - if ((n >= 97 && n <= 122) || // [a-z] - (n >= 65 && n <= 90) || // [A-Z] - (n >= 39 && n <= 59) || // ['()*+,-./] | [0-9] | [:;] - n === 0x20 || n === 0xD || n === 0xA || // #x20 | #xD | #xA - (n >= 35 && n <= 37) || // [#$%] - n === 33 || // ! - n === 61 || n === 63 || n === 64 || n === 95) { // [=?@_] - continue; - } - else { - return false; - } - } - return true; -} -exports.xml_isPubidChar = xml_isPubidChar; -//# sourceMappingURL=XMLAlgorithm.js.map - -/***/ }), - -/***/ 457: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * UTF-8 encodes the given string. - * - * @param input - a string - */ -function utf8Encode(input) { - const bytes = new Uint8Array(input.length * 4); - let byteIndex = 0; - for (let i = 0; i < input.length; i++) { - let char = input.charCodeAt(i); - if (char < 128) { - bytes[byteIndex++] = char; - continue; - } - else if (char < 2048) { - bytes[byteIndex++] = char >> 6 | 192; - } - else { - if (char > 0xd7ff && char < 0xdc00) { - if (++i >= input.length) { - throw new Error("Incomplete surrogate pair."); - } - const c2 = input.charCodeAt(i); - if (c2 < 0xdc00 || c2 > 0xdfff) { - throw new Error("Invalid surrogate character."); - } - char = 0x10000 + ((char & 0x03ff) << 10) + (c2 & 0x03ff); - bytes[byteIndex++] = char >> 18 | 240; - bytes[byteIndex++] = char >> 12 & 63 | 128; - } - else { - bytes[byteIndex++] = char >> 12 | 224; - } - bytes[byteIndex++] = char >> 6 & 63 | 128; - } - bytes[byteIndex++] = char & 63 | 128; - } - return bytes.subarray(0, byteIndex); -} -exports.utf8Encode = utf8Encode; -/** - * UTF-8 decodes the given byte sequence into a string. - * - * @param bytes - a byte sequence - */ -function utf8Decode(bytes) { - let result = ""; - let i = 0; - while (i < bytes.length) { - var c = bytes[i++]; - if (c > 127) { - if (c > 191 && c < 224) { - if (i >= bytes.length) { - throw new Error("Incomplete 2-byte sequence."); - } - c = (c & 31) << 6 | bytes[i++] & 63; - } - else if (c > 223 && c < 240) { - if (i + 1 >= bytes.length) { - throw new Error("Incomplete 3-byte sequence."); - } - c = (c & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63; - } - else if (c > 239 && c < 248) { - if (i + 2 >= bytes.length) { - throw new Error("Incomplete 4-byte sequence."); - } - c = (c & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63; - } - else { - throw new Error("Unknown multi-byte start."); - } - } - if (c <= 0xffff) { - result += String.fromCharCode(c); - } - else if (c <= 0x10ffff) { - c -= 0x10000; - result += String.fromCharCode(c >> 10 | 0xd800); - result += String.fromCharCode(c & 0x3FF | 0xdc00); - } - else { - throw new Error("Code point exceeds UTF-16 limit."); - } - } - return result; -} -exports.utf8Decode = utf8Decode; -//# sourceMappingURL=index.js.map - -/***/ }), - -/***/ 462: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const LocalNameSet_1 = __webpack_require__(575); -const NamespacePrefixMap_1 = __webpack_require__(392); -const DOMException_1 = __webpack_require__(35); -const infra_1 = __webpack_require__(23); -const algorithm_1 = __webpack_require__(163); -/** - * Pre-serializes XML nodes. - */ -class BaseWriter { - /** - * Initializes a new instance of `BaseWriter`. - * - * @param builderOptions - XML builder options - */ - constructor(builderOptions) { - /** - * Gets the current depth of the XML tree. - */ - this.level = 0; - this._builderOptions = builderOptions; - } - /** - * Used by derived classes to serialize a DocType node. - * - * @param name - node name - * @param publicId - public identifier - * @param systemId - system identifier - */ - docType(name, publicId, systemId) { } - /** - * Used by derived classes to serialize a comment node. - * - * @param data - node data - */ - comment(data) { } - /** - * Used by derived classes to serialize a text node. - * - * @param data - node data - */ - text(data) { } - /** - * Used by derived classes to serialize a processing instruction node. - * - * @param target - instruction target - * @param data - node data - */ - instruction(target, data) { } - /** - * Used by derived classes to serialize a CData section node. - * - * @param data - node data - */ - cdata(data) { } - /** - * Used by derived classes to serialize the beginning of the opening tag of an - * element node. - * - * @param name - node name - */ - openTagBegin(name) { } - /** - * Used by derived classes to serialize the ending of the opening tag of an - * element node. - * - * @param name - node name - * @param selfClosing - whether the element node is self closing - * @param voidElement - whether the element node is a HTML void element - */ - openTagEnd(name, selfClosing, voidElement) { } - /** - * Used by derived classes to serialize the closing tag of an element node. - * - * @param name - node name - */ - closeTag(name) { } - /** - * Used by derived classes to serialize attributes or namespace declarations. - * - * @param attributes - attribute array - */ - attributes(attributes) { - for (const attr of attributes) { - this.attribute(attr[1] === null ? attr[2] : attr[1] + ':' + attr[2], attr[3]); - } - } - /** - * Used by derived classes to serialize an attribute or namespace declaration. - * - * @param name - node name - * @param value - node value - */ - attribute(name, value) { } - /** - * Used by derived classes to perform any pre-processing steps before starting - * serializing an element node. - * - * @param name - node name - */ - beginElement(name) { } - /** - * Used by derived classes to perform any post-processing steps after - * completing serializing an element node. - * - * @param name - node name - */ - endElement(name) { } - /** - * Produces an XML serialization of the given node. The pre-serializer inserts - * namespace declarations where necessary and produces qualified names for - * nodes and attributes. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - */ - serializeNode(node, requireWellFormed, noDoubleEncoding) { - const hasNamespaces = (node._nodeDocument !== undefined && node._nodeDocument._hasNamespaces); - this.level = 0; - this.currentNode = node; - if (hasNamespaces) { - /** From: https://w3c.github.io/DOM-Parsing/#xml-serialization - * - * 1. Let namespace be a context namespace with value null. - * The context namespace tracks the XML serialization algorithm's current - * default namespace. The context namespace is changed when either an Element - * Node has a default namespace declaration, or the algorithm generates a - * default namespace declaration for the Element Node to match its own - * namespace. The algorithm assumes no namespace (null) to start. - * 2. Let prefix map be a new namespace prefix map. - * 3. Add the XML namespace with prefix value "xml" to prefix map. - * 4. Let prefix index be a generated namespace prefix index with value 1. - * The generated namespace prefix index is used to generate a new unique - * prefix value when no suitable existing namespace prefix is available to - * serialize a node's namespaceURI (or the namespaceURI of one of node's - * attributes). See the generate a prefix algorithm. - */ - let namespace = null; - const prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap(); - prefixMap.set("xml", infra_1.namespace.XML); - const prefixIndex = { value: 1 }; - /** - * 5. Return the result of running the XML serialization algorithm on node - * passing the context namespace namespace, namespace prefix map prefix map, - * generated namespace prefix index reference to prefix index, and the - * flag require well-formed. If an exception occurs during the execution - * of the algorithm, then catch that exception and throw an - * "InvalidStateError" DOMException. - */ - try { - this._serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); - } - catch (e) { - throw new DOMException_1.InvalidStateError(e.message); - } - } - else { - try { - this._serializeNode(node, requireWellFormed, noDoubleEncoding); - } - catch (e) { - throw new DOMException_1.InvalidStateError(e.message); - } - } - } - /** - * Produces an XML serialization of a node. - * - * @param node - node to serialize - * @param namespace - context namespace - * @param prefixMap - namespace prefix map - * @param prefixIndex - generated namespace prefix index - * @param requireWellFormed - whether to check conformance - */ - _serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) { - this.currentNode = node; - switch (node.nodeType) { - case interfaces_1.NodeType.Element: - this._serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.Document: - this._serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.Comment: - this._serializeComment(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.Text: - this._serializeText(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.DocumentFragment: - this._serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.DocumentType: - this._serializeDocumentType(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.ProcessingInstruction: - this._serializeProcessingInstruction(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.CData: - this._serializeCData(node, requireWellFormed, noDoubleEncoding); - break; - default: - throw new Error(`Unknown node type: ${node.nodeType}`); - } - } - /** - * Produces an XML serialization of a node. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - */ - _serializeNode(node, requireWellFormed, noDoubleEncoding) { - this.currentNode = node; - switch (node.nodeType) { - case interfaces_1.NodeType.Element: - this._serializeElement(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.Document: - this._serializeDocument(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.Comment: - this._serializeComment(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.Text: - this._serializeText(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.DocumentFragment: - this._serializeDocumentFragment(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.DocumentType: - this._serializeDocumentType(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.ProcessingInstruction: - this._serializeProcessingInstruction(node, requireWellFormed, noDoubleEncoding); - break; - case interfaces_1.NodeType.CData: - this._serializeCData(node, requireWellFormed, noDoubleEncoding); - break; - default: - throw new Error(`Unknown node type: ${node.nodeType}`); - } - } - /** - * Produces an XML serialization of an element node. - * - * @param node - node to serialize - * @param namespace - context namespace - * @param prefixMap - namespace prefix map - * @param prefixIndex - generated namespace prefix index - * @param requireWellFormed - whether to check conformance - */ - _serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) { - const attributes = []; - /** - * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node - * - * 1. If the require well-formed flag is set (its value is true), and this - * node's localName attribute contains the character ":" (U+003A COLON) or - * does not match the XML Name production, then throw an exception; the - * serialization of this node would not be a well-formed element. - */ - if (requireWellFormed && (node.localName.indexOf(":") !== -1 || - !algorithm_1.xml_isName(node.localName))) { - throw new Error("Node local name contains invalid characters (well-formed required)."); - } - /** - * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN). - * 3. Let qualified name be an empty string. - * 4. Let skip end tag be a boolean flag with value false. - * 5. Let ignore namespace definition attribute be a boolean flag with value - * false. - * 6. Given prefix map, copy a namespace prefix map and let map be the - * result. - * 7. Let local prefixes map be an empty map. The map has unique Node prefix - * strings as its keys, with corresponding namespaceURI Node values as the - * map's key values (in this map, the null namespace is represented by the - * empty string). - * - * _Note:_ This map is local to each element. It is used to ensure there - * are no conflicting prefixes should a new namespace prefix attribute need - * to be generated. It is also used to enable skipping of duplicate prefix - * definitions when writing an element's attributes: the map allows the - * algorithm to distinguish between a prefix in the namespace prefix map - * that might be locally-defined (to the current Element) and one that is - * not. - * 8. Let local default namespace be the result of recording the namespace - * information for node given map and local prefixes map. - * - * _Note:_ The above step will update map with any found namespace prefix - * definitions, add the found prefix definitions to the local prefixes map - * and return a local default namespace value defined by a default namespace - * attribute if one exists. Otherwise it returns null. - * 9. Let inherited ns be a copy of namespace. - * 10. Let ns be the value of node's namespaceURI attribute. - */ - let qualifiedName = ''; - let skipEndTag = false; - let ignoreNamespaceDefinitionAttribute = false; - let map = prefixMap.copy(); - let localPrefixesMap = {}; - let localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap); - let inheritedNS = namespace; - let ns = node.namespaceURI; - /** 11. If inherited ns is equal to ns, then: */ - if (inheritedNS === ns) { - /** - * 11.1. If local default namespace is not null, then set ignore - * namespace definition attribute to true. - */ - if (localDefaultNamespace !== null) { - ignoreNamespaceDefinitionAttribute = true; - } - /** - * 11.2. If ns is the XML namespace, then append to qualified name the - * concatenation of the string "xml:" and the value of node's localName. - * 11.3. Otherwise, append to qualified name the value of node's - * localName. The node's prefix if it exists, is dropped. - */ - if (ns === infra_1.namespace.XML) { - qualifiedName = 'xml:' + node.localName; - } - else { - qualifiedName = node.localName; - } - /** 11.4. Append the value of qualified name to markup. */ - this.beginElement(qualifiedName); - this.openTagBegin(qualifiedName); - } - else { - /** - * 12. Otherwise, inherited ns is not equal to ns (the node's own - * namespace is different from the context namespace of its parent). - * Run these sub-steps: - * - * 12.1. Let prefix be the value of node's prefix attribute. - * 12.2. Let candidate prefix be the result of retrieving a preferred - * prefix string prefix from map given namespace ns. The above may return - * null if no namespace key ns exists in map. - */ - let prefix = node.prefix; - /** - * We don't need to run "retrieving a preferred prefix string" algorithm if - * the element has no prefix and its namespace matches to the default - * namespace. - * See: https://github.com/web-platform-tests/wpt/pull/16703 - */ - let candidatePrefix = null; - if (prefix !== null || ns !== localDefaultNamespace) { - candidatePrefix = map.get(prefix, ns); - } - /** - * 12.3. If the value of prefix matches "xmlns", then run the following - * steps: - */ - if (prefix === "xmlns") { - /** - * 12.3.1. If the require well-formed flag is set, then throw an error. - * An Element with prefix "xmlns" will not legally round-trip in a - * conforming XML parser. - */ - if (requireWellFormed) { - throw new Error("An element cannot have the 'xmlns' prefix (well-formed required)."); - } - /** - * 12.3.2. Let candidate prefix be the value of prefix. - */ - candidatePrefix = prefix; - } - /** - * 12.4.Found a suitable namespace prefix: if candidate prefix is not - * null (a namespace prefix is defined which maps to ns), then: - */ - if (candidatePrefix !== null) { - /** - * The following may serialize a different prefix than the Element's - * existing prefix if it already had one. However, the retrieving a - * preferred prefix string algorithm already tried to match the - * existing prefix if possible. - * - * 12.4.1. Append to qualified name the concatenation of candidate - * prefix, ":" (U+003A COLON), and node's localName. There exists on - * this node or the node's ancestry a namespace prefix definition that - * defines the node's namespace. - * 12.4.2. If the local default namespace is not null (there exists a - * locally-defined default namespace declaration attribute) and its - * value is not the XML namespace, then let inherited ns get the value - * of local default namespace unless the local default namespace is the - * empty string in which case let it get null (the context namespace - * is changed to the declared default, rather than this node's own - * namespace). - * - * _Note:_ Any default namespace definitions or namespace prefixes that - * define the XML namespace are omitted when serializing this node's - * attributes. - */ - qualifiedName = candidatePrefix + ':' + node.localName; - if (localDefaultNamespace !== null && localDefaultNamespace !== infra_1.namespace.XML) { - inheritedNS = localDefaultNamespace || null; - } - /** - * 12.4.3. Append the value of qualified name to markup. - */ - this.beginElement(qualifiedName); - this.openTagBegin(qualifiedName); - /** 12.5. Otherwise, if prefix is not null, then: */ - } - else if (prefix !== null) { - /** - * _Note:_ By this step, there is no namespace or prefix mapping - * declaration in this node (or any parent node visited by this - * algorithm) that defines prefix otherwise the step labelled Found - * a suitable namespace prefix would have been followed. The sub-steps - * that follow will create a new namespace prefix declaration for prefix - * and ensure that prefix does not conflict with an existing namespace - * prefix declaration of the same localName in node's attribute list. - * - * 12.5.1. If the local prefixes map contains a key matching prefix, - * then let prefix be the result of generating a prefix providing as - * input map, ns, and prefix index. - */ - if (prefix in localPrefixesMap) { - prefix = this._generatePrefix(ns, map, prefixIndex); - } - /** - * 12.5.2. Add prefix to map given namespace ns. - * 12.5.3. Append to qualified name the concatenation of prefix, ":" - * (U+003A COLON), and node's localName. - * 12.5.4. Append the value of qualified name to markup. - */ - map.set(prefix, ns); - qualifiedName += prefix + ':' + node.localName; - this.beginElement(qualifiedName); - this.openTagBegin(qualifiedName); - /** - * 12.5.5. Append the following to markup, in the order listed: - * - * _Note:_ The following serializes a namespace prefix declaration for - * prefix which was just added to the map. - * - * 12.5.5.1. " " (U+0020 SPACE); - * 12.5.5.2. The string "xmlns:"; - * 12.5.5.3. The value of prefix; - * 12.5.5.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); - * 12.5.5.5. The result of serializing an attribute value given ns and - * the require well-formed flag as input; - * 12.5.5.6. """ (U+0022 QUOTATION MARK). - */ - attributes.push([null, 'xmlns', prefix, - this._serializeAttributeValue(ns, requireWellFormed, noDoubleEncoding)]); - /** - * 12.5.5.7. If local default namespace is not null (there exists a - * locally-defined default namespace declaration attribute), then - * let inherited ns get the value of local default namespace unless the - * local default namespace is the empty string in which case let it get - * null. - */ - if (localDefaultNamespace !== null) { - inheritedNS = localDefaultNamespace || null; - } - /** - * 12.6. Otherwise, if local default namespace is null, or local - * default namespace is not null and its value is not equal to ns, then: - */ - } - else if (localDefaultNamespace === null || - (localDefaultNamespace !== null && localDefaultNamespace !== ns)) { - /** - * _Note:_ At this point, the namespace for this node still needs to be - * serialized, but there's no prefix (or candidate prefix) available; the - * following uses the default namespace declaration to define the - * namespace--optionally replacing an existing default declaration - * if present. - * - * 12.6.1. Set the ignore namespace definition attribute flag to true. - * 12.6.2. Append to qualified name the value of node's localName. - * 12.6.3. Let the value of inherited ns be ns. - * - * _Note:_ The new default namespace will be used in the serialization - * to define this node's namespace and act as the context namespace for - * its children. - */ - ignoreNamespaceDefinitionAttribute = true; - qualifiedName += node.localName; - inheritedNS = ns; - /** - * 12.6.4. Append the value of qualified name to markup. - */ - this.beginElement(qualifiedName); - this.openTagBegin(qualifiedName); - /** - * 12.6.5. Append the following to markup, in the order listed: - * - * _Note:_ The following serializes the new (or replacement) default - * namespace definition. - * - * 12.6.5.1. " " (U+0020 SPACE); - * 12.6.5.2. The string "xmlns"; - * 12.6.5.3. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); - * 12.6.5.4. The result of serializing an attribute value given ns - * and the require well-formed flag as input; - * 12.6.5.5. """ (U+0022 QUOTATION MARK). - */ - attributes.push([null, null, 'xmlns', - this._serializeAttributeValue(ns, requireWellFormed, noDoubleEncoding)]); - /** - * 12.7. Otherwise, the node has a local default namespace that matches - * ns. Append to qualified name the value of node's localName, let the - * value of inherited ns be ns, and append the value of qualified name - * to markup. - */ - } - else { - qualifiedName += node.localName; - inheritedNS = ns; - this.beginElement(qualifiedName); - this.openTagBegin(qualifiedName); - } - } - /** - * 13. Append to markup the result of the XML serialization of node's - * attributes given map, prefix index, local prefixes map, ignore namespace - * definition attribute flag, and require well-formed flag. - */ - attributes.push(...this._serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed, noDoubleEncoding)); - this.attributes(attributes); - /** - * 14. If ns is the HTML namespace, and the node's list of children is - * empty, and the node's localName matches any one of the following void - * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed", - * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta", - * "param", "source", "track", "wbr"; then append the following to markup, - * in the order listed: - * 14.1. " " (U+0020 SPACE); - * 14.2. "/" (U+002F SOLIDUS). - * and set the skip end tag flag to true. - * 15. If ns is not the HTML namespace, and the node's list of children is - * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end - * tag flag to true. - * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup. - */ - const isHTML = (ns === infra_1.namespace.HTML); - if (isHTML && node.childNodes.length === 0 && - BaseWriter._VoidElementNames.has(node.localName)) { - this.openTagEnd(qualifiedName, true, true); - this.endElement(qualifiedName); - skipEndTag = true; - } - else if (!isHTML && node.childNodes.length === 0) { - this.openTagEnd(qualifiedName, true, false); - this.endElement(qualifiedName); - skipEndTag = true; - } - else { - this.openTagEnd(qualifiedName, false, false); - } - /** - * 17. If the value of skip end tag is true, then return the value of markup - * and skip the remaining steps. The node is a leaf-node. - */ - if (skipEndTag) - return; - /** - * 18. If ns is the HTML namespace, and the node's localName matches the - * string "template", then this is a template element. Append to markup the - * result of XML serializing a DocumentFragment node given the template - * element's template contents (a DocumentFragment), providing inherited - * ns, map, prefix index, and the require well-formed flag. - * - * _Note:_ This allows template content to round-trip, given the rules for - * parsing XHTML documents. - * - * 19. Otherwise, append to markup the result of running the XML - * serialization algorithm on each of node's children, in tree order, - * providing inherited ns, map, prefix index, and the require well-formed - * flag. - */ - if (isHTML && node.localName === "template") { - // TODO: serialize template contents - } - else { - for (const childNode of node.childNodes) { - this.level++; - this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed, noDoubleEncoding); - this.level--; - } - } - /** - * 20. Append the following to markup, in the order listed: - * 20.1. "" (U+003E GREATER-THAN SIGN). - * 21. Return the value of markup. - */ - this.closeTag(qualifiedName); - this.endElement(qualifiedName); - } - /** - * Produces an XML serialization of an element node. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - */ - _serializeElement(node, requireWellFormed, noDoubleEncoding) { - /** - * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node - * - * 1. If the require well-formed flag is set (its value is true), and this - * node's localName attribute contains the character ":" (U+003A COLON) or - * does not match the XML Name production, then throw an exception; the - * serialization of this node would not be a well-formed element. - */ - if (requireWellFormed && (node.localName.indexOf(":") !== -1 || - !algorithm_1.xml_isName(node.localName))) { - throw new Error("Node local name contains invalid characters (well-formed required)."); - } - /** - * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN). - * 3. Let qualified name be an empty string. - * 4. Let skip end tag be a boolean flag with value false. - * 5. Let ignore namespace definition attribute be a boolean flag with value - * false. - * 6. Given prefix map, copy a namespace prefix map and let map be the - * result. - * 7. Let local prefixes map be an empty map. The map has unique Node prefix - * strings as its keys, with corresponding namespaceURI Node values as the - * map's key values (in this map, the null namespace is represented by the - * empty string). - * - * _Note:_ This map is local to each element. It is used to ensure there - * are no conflicting prefixes should a new namespace prefix attribute need - * to be generated. It is also used to enable skipping of duplicate prefix - * definitions when writing an element's attributes: the map allows the - * algorithm to distinguish between a prefix in the namespace prefix map - * that might be locally-defined (to the current Element) and one that is - * not. - * 8. Let local default namespace be the result of recording the namespace - * information for node given map and local prefixes map. - * - * _Note:_ The above step will update map with any found namespace prefix - * definitions, add the found prefix definitions to the local prefixes map - * and return a local default namespace value defined by a default namespace - * attribute if one exists. Otherwise it returns null. - * 9. Let inherited ns be a copy of namespace. - * 10. Let ns be the value of node's namespaceURI attribute. - */ - let skipEndTag = false; - /** 11. If inherited ns is equal to ns, then: */ - /** - * 11.1. If local default namespace is not null, then set ignore - * namespace definition attribute to true. - */ - /** - * 11.2. If ns is the XML namespace, then append to qualified name the - * concatenation of the string "xml:" and the value of node's localName. - * 11.3. Otherwise, append to qualified name the value of node's - * localName. The node's prefix if it exists, is dropped. - */ - const qualifiedName = node.localName; - /** 11.4. Append the value of qualified name to markup. */ - this.beginElement(qualifiedName); - this.openTagBegin(qualifiedName); - /** - * 13. Append to markup the result of the XML serialization of node's - * attributes given map, prefix index, local prefixes map, ignore namespace - * definition attribute flag, and require well-formed flag. - */ - const attributes = this._serializeAttributes(node, requireWellFormed, noDoubleEncoding); - this.attributes(attributes); - /** - * 14. If ns is the HTML namespace, and the node's list of children is - * empty, and the node's localName matches any one of the following void - * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed", - * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta", - * "param", "source", "track", "wbr"; then append the following to markup, - * in the order listed: - * 14.1. " " (U+0020 SPACE); - * 14.2. "/" (U+002F SOLIDUS). - * and set the skip end tag flag to true. - * 15. If ns is not the HTML namespace, and the node's list of children is - * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end - * tag flag to true. - * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup. - */ - if (!node.hasChildNodes()) { - this.openTagEnd(qualifiedName, true, false); - this.endElement(qualifiedName); - skipEndTag = true; - } - else { - this.openTagEnd(qualifiedName, false, false); - } - /** - * 17. If the value of skip end tag is true, then return the value of markup - * and skip the remaining steps. The node is a leaf-node. - */ - if (skipEndTag) - return; - /** - * 18. If ns is the HTML namespace, and the node's localName matches the - * string "template", then this is a template element. Append to markup the - * result of XML serializing a DocumentFragment node given the template - * element's template contents (a DocumentFragment), providing inherited - * ns, map, prefix index, and the require well-formed flag. - * - * _Note:_ This allows template content to round-trip, given the rules for - * parsing XHTML documents. - * - * 19. Otherwise, append to markup the result of running the XML - * serialization algorithm on each of node's children, in tree order, - * providing inherited ns, map, prefix index, and the require well-formed - * flag. - */ - for (const childNode of node._children) { - this.level++; - this._serializeNode(childNode, requireWellFormed, noDoubleEncoding); - this.level--; - } - /** - * 20. Append the following to markup, in the order listed: - * 20.1. "" (U+003E GREATER-THAN SIGN). - * 21. Return the value of markup. - */ - this.closeTag(qualifiedName); - this.endElement(qualifiedName); - } - /** - * Produces an XML serialization of a document node. - * - * @param node - node to serialize - * @param namespace - context namespace - * @param prefixMap - namespace prefix map - * @param prefixIndex - generated namespace prefix index - * @param requireWellFormed - whether to check conformance - */ - _serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) { - /** - * If the require well-formed flag is set (its value is true), and this node - * has no documentElement (the documentElement attribute's value is null), - * then throw an exception; the serialization of this node would not be a - * well-formed document. - */ - if (requireWellFormed && node.documentElement === null) { - throw new Error("Missing document element (well-formed required)."); - } - /** - * Otherwise, run the following steps: - * 1. Let serialized document be an empty string. - * 2. For each child child of node, in tree order, run the XML - * serialization algorithm on the child passing along the provided - * arguments, and append the result to serialized document. - * - * _Note:_ This will serialize any number of ProcessingInstruction and - * Comment nodes both before and after the Document's documentElement node, - * including at most one DocumentType node. (Text nodes are not allowed as - * children of the Document.) - * - * 3. Return the value of serialized document. - */ - for (const childNode of node.childNodes) { - this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); - } - } - /** - * Produces an XML serialization of a document node. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - */ - _serializeDocument(node, requireWellFormed, noDoubleEncoding) { - /** - * If the require well-formed flag is set (its value is true), and this node - * has no documentElement (the documentElement attribute's value is null), - * then throw an exception; the serialization of this node would not be a - * well-formed document. - */ - if (requireWellFormed && node.documentElement === null) { - throw new Error("Missing document element (well-formed required)."); - } - /** - * Otherwise, run the following steps: - * 1. Let serialized document be an empty string. - * 2. For each child child of node, in tree order, run the XML - * serialization algorithm on the child passing along the provided - * arguments, and append the result to serialized document. - * - * _Note:_ This will serialize any number of ProcessingInstruction and - * Comment nodes both before and after the Document's documentElement node, - * including at most one DocumentType node. (Text nodes are not allowed as - * children of the Document.) - * - * 3. Return the value of serialized document. - */ - for (const childNode of node._children) { - this._serializeNode(childNode, requireWellFormed, noDoubleEncoding); - } - } - /** - * Produces an XML serialization of a comment node. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - */ - _serializeComment(node, requireWellFormed, noDoubleEncoding) { - /** - * If the require well-formed flag is set (its value is true), and node's - * data contains characters that are not matched by the XML Char production - * or contains "--" (two adjacent U+002D HYPHEN-MINUS characters) or that - * ends with a "-" (U+002D HYPHEN-MINUS) character, then throw an exception; - * the serialization of this node's data would not be well-formed. - */ - if (requireWellFormed && (!algorithm_1.xml_isLegalChar(node.data) || - node.data.indexOf("--") !== -1 || node.data.endsWith("-"))) { - throw new Error("Comment data contains invalid characters (well-formed required)."); - } - /** - * Otherwise, return the concatenation of "". - */ - this.comment(node.data); - } - /** - * Produces an XML serialization of a text node. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - * @param level - current depth of the XML tree - */ - _serializeText(node, requireWellFormed, noDoubleEncoding) { - /** - * 1. If the require well-formed flag is set (its value is true), and - * node's data contains characters that are not matched by the XML Char - * production, then throw an exception; the serialization of this node's - * data would not be well-formed. - */ - if (requireWellFormed && !algorithm_1.xml_isLegalChar(node.data)) { - throw new Error("Text data contains invalid characters (well-formed required)."); - } - /** - * 2. Let markup be the value of node's data. - * 3. Replace any occurrences of "&" in markup by "&". - * 4. Replace any occurrences of "<" in markup by "<". - * 5. Replace any occurrences of ">" in markup by ">". - * 6. Return the value of markup. - */ - let markup = ""; - if (noDoubleEncoding) { - markup = node.data.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&') - .replace(//g, '>') - .replace(/\r/g, ' '); - } - else { - for (let i = 0; i < node.data.length; i++) { - const c = node.data[i]; - if (c === "&") - markup += "&"; - else if (c === "<") - markup += "<"; - else if (c === ">") - markup += ">"; - else - markup += c; - } - } - this.text(markup); - } - /** - * Produces an XML serialization of a document fragment node. - * - * @param node - node to serialize - * @param namespace - context namespace - * @param prefixMap - namespace prefix map - * @param prefixIndex - generated namespace prefix index - * @param requireWellFormed - whether to check conformance - */ - _serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) { - /** - * 1. Let markup the empty string. - * 2. For each child child of node, in tree order, run the XML serialization - * algorithm on the child given namespace, prefix map, a reference to prefix - * index, and flag require well-formed. Concatenate the result to markup. - * 3. Return the value of markup. - */ - for (const childNode of node.childNodes) { - this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding); - } - } - /** - * Produces an XML serialization of a document fragment node. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - */ - _serializeDocumentFragment(node, requireWellFormed, noDoubleEncoding) { - /** - * 1. Let markup the empty string. - * 2. For each child child of node, in tree order, run the XML serialization - * algorithm on the child given namespace, prefix map, a reference to prefix - * index, and flag require well-formed. Concatenate the result to markup. - * 3. Return the value of markup. - */ - for (const childNode of node._children) { - this._serializeNode(childNode, requireWellFormed, noDoubleEncoding); - } - } - /** - * Produces an XML serialization of a document type node. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - */ - _serializeDocumentType(node, requireWellFormed, noDoubleEncoding) { - /** - * 1. If the require well-formed flag is true and the node's publicId - * attribute contains characters that are not matched by the XML PubidChar - * production, then throw an exception; the serialization of this node - * would not be a well-formed document type declaration. - */ - if (requireWellFormed && !algorithm_1.xml_isPubidChar(node.publicId)) { - throw new Error("DocType public identifier does not match PubidChar construct (well-formed required)."); - } - /** - * 2. If the require well-formed flag is true and the node's systemId - * attribute contains characters that are not matched by the XML Char - * production or that contains both a """ (U+0022 QUOTATION MARK) and a - * "'" (U+0027 APOSTROPHE), then throw an exception; the serialization - * of this node would not be a well-formed document type declaration. - */ - if (requireWellFormed && - (!algorithm_1.xml_isLegalChar(node.systemId) || - (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) { - throw new Error("DocType system identifier contains invalid characters (well-formed required)."); - } - /** - * 3. Let markup be an empty string. - * 4. Append the string "" (U+003E GREATER-THAN SIGN) to markup. - * 11. Return the value of markup. - */ - this.docType(node.name, node.publicId, node.systemId); - } - /** - * Produces an XML serialization of a processing instruction node. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - */ - _serializeProcessingInstruction(node, requireWellFormed, noDoubleEncoding) { - /** - * 1. If the require well-formed flag is set (its value is true), and node's - * target contains a ":" (U+003A COLON) character or is an ASCII - * case-insensitive match for the string "xml", then throw an exception; - * the serialization of this node's target would not be well-formed. - */ - if (requireWellFormed && (node.target.indexOf(":") !== -1 || (/^xml$/i).test(node.target))) { - throw new Error("Processing instruction target contains invalid characters (well-formed required)."); - } - /** - * 2. If the require well-formed flag is set (its value is true), and node's - * data contains characters that are not matched by the XML Char production - * or contains the string "?>" (U+003F QUESTION MARK, - * U+003E GREATER-THAN SIGN), then throw an exception; the serialization of - * this node's data would not be well-formed. - */ - if (requireWellFormed && (!algorithm_1.xml_isLegalChar(node.data) || - node.data.indexOf("?>") !== -1)) { - throw new Error("Processing instruction data contains invalid characters (well-formed required)."); - } - /** - * 3. Let markup be the concatenation of the following, in the order listed: - * 3.1. "" (U+003F QUESTION MARK, U+003E GREATER-THAN SIGN). - * 4. Return the value of markup. - */ - this.instruction(node.target, node.data); - } - /** - * Produces an XML serialization of a CDATA node. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - */ - _serializeCData(node, requireWellFormed, noDoubleEncoding) { - if (requireWellFormed && (node.data.indexOf("]]>") !== -1)) { - throw new Error("CDATA contains invalid characters (well-formed required)."); - } - this.cdata(node.data); - } - /** - * Produces an XML serialization of the attributes of an element node. - * - * @param node - node to serialize - * @param map - namespace prefix map - * @param prefixIndex - generated namespace prefix index - * @param localPrefixesMap - local prefixes map - * @param ignoreNamespaceDefinitionAttribute - whether to ignore namespace - * attributes - * @param requireWellFormed - whether to check conformance - */ - _serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed, noDoubleEncoding) { - /** - * 1. Let result be the empty string. - * 2. Let localname set be a new empty namespace localname set. This - * localname set will contain tuples of unique attribute namespaceURI and - * localName pairs, and is populated as each attr is processed. This set is - * used to [optionally] enforce the well-formed constraint that an element - * cannot have two attributes with the same namespaceURI and localName. - * This can occur when two otherwise identical attributes on the same - * element differ only by their prefix values. - */ - const result = []; - const localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined; - /** - * 3. Loop: For each attribute attr in element's attributes, in the order - * they are specified in the element's attribute list: - */ - for (const attr of node.attributes) { - // Optimize common case - if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) { - result.push([null, null, attr.localName, - this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]); - continue; - } - /** - * 3.1. If the require well-formed flag is set (its value is true), and the - * localname set contains a tuple whose values match those of a new tuple - * consisting of attr's namespaceURI attribute and localName attribute, - * then throw an exception; the serialization of this attr would fail to - * produce a well-formed element serialization. - */ - if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) { - throw new Error("Element contains duplicate attributes (well-formed required)."); - } - /** - * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and - * localName attribute, and add it to the localname set. - * 3.3. Let attribute namespace be the value of attr's namespaceURI value. - * 3.4. Let candidate prefix be null. - */ - if (requireWellFormed && localNameSet) - localNameSet.set(attr.namespaceURI, attr.localName); - let attributeNamespace = attr.namespaceURI; - let candidatePrefix = null; - /** 3.5. If attribute namespace is not null, then run these sub-steps: */ - if (attributeNamespace !== null) { - /** - * 3.5.1. Let candidate prefix be the result of retrieving a preferred - * prefix string from map given namespace attribute namespace with - * preferred prefix being attr's prefix value. - */ - candidatePrefix = map.get(attr.prefix, attributeNamespace); - /** - * 3.5.2. If the value of attribute namespace is the XMLNS namespace, - * then run these steps: - */ - if (attributeNamespace === infra_1.namespace.XMLNS) { - /** - * 3.5.2.1. If any of the following are true, then stop running these - * steps and goto Loop to visit the next attribute: - * - the attr's value is the XML namespace; - * _Note:_ The XML namespace cannot be redeclared and survive - * round-tripping (unless it defines the prefix "xml"). To avoid this - * problem, this algorithm always prefixes elements in the XML - * namespace with "xml" and drops any related definitions as seen - * in the above condition. - * - the attr's prefix is null and the ignore namespace definition - * attribute flag is true (the Element's default namespace attribute - * should be skipped); - * - the attr's prefix is not null and either - * * the attr's localName is not a key contained in the local - * prefixes map, or - * * the attr's localName is present in the local prefixes map but - * the value of the key does not match attr's value - * and furthermore that the attr's localName (as the prefix to find) - * is found in the namespace prefix map given the namespace consisting - * of the attr's value (the current namespace prefix definition was - * exactly defined previously--on an ancestor element not the current - * element whose attributes are being processed). - */ - if (attr.value === infra_1.namespace.XML || - (attr.prefix === null && ignoreNamespaceDefinitionAttribute) || - (attr.prefix !== null && (!(attr.localName in localPrefixesMap) || - localPrefixesMap[attr.localName] !== attr.value) && - map.has(attr.localName, attr.value))) - continue; - /** - * 3.5.2.2. If the require well-formed flag is set (its value is true), - * and the value of attr's value attribute matches the XMLNS - * namespace, then throw an exception; the serialization of this - * attribute would produce invalid XML because the XMLNS namespace - * is reserved and cannot be applied as an element's namespace via - * XML parsing. - * - * _Note:_ DOM APIs do allow creation of elements in the XMLNS - * namespace but with strict qualifications. - */ - if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) { - throw new Error("XMLNS namespace is reserved (well-formed required)."); - } - /** - * 3.5.2.3. If the require well-formed flag is set (its value is true), - * and the value of attr's value attribute is the empty string, then - * throw an exception; namespace prefix declarations cannot be used - * to undeclare a namespace (use a default namespace declaration - * instead). - */ - if (requireWellFormed && attr.value === '') { - throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required)."); - } - /** - * 3.5.2.4. the attr's prefix matches the string "xmlns", then let - * candidate prefix be the string "xmlns". - */ - if (attr.prefix === 'xmlns') - candidatePrefix = 'xmlns'; - /** - * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace. - * Run these steps: - * - * _Note:_ The (candidatePrefix === null) check is not in the spec. - * We deviate from the spec here. Otherwise a prefix is generated for - * all attributes with namespaces. - */ - } - else if (candidatePrefix === null) { - if (attr.prefix !== null && - (!map.hasPrefix(attr.prefix) || - map.has(attr.prefix, attributeNamespace))) { - /** - * Check if we can use the attribute's own prefix. - * We deviate from the spec here. - * TODO: This is not an efficient way of searching for prefixes. - * Follow developments to the spec. - */ - candidatePrefix = attr.prefix; - } - else { - /** - * 3.5.3.1. Let candidate prefix be the result of generating a prefix - * providing map, attribute namespace, and prefix index as input. - */ - candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex); - } - /** - * 3.5.3.2. Append the following to result, in the order listed: - * 3.5.3.2.1. " " (U+0020 SPACE); - * 3.5.3.2.2. The string "xmlns:"; - * 3.5.3.2.3. The value of candidate prefix; - * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); - * 3.5.3.2.5. The result of serializing an attribute value given - * attribute namespace and the require well-formed flag as input; - * 3.5.3.2.6. """ (U+0022 QUOTATION MARK). - */ - result.push([null, "xmlns", candidatePrefix, - this._serializeAttributeValue(attributeNamespace, requireWellFormed, noDoubleEncoding)]); - } - } - /** - * 3.6. Append a " " (U+0020 SPACE) to result. - * 3.7. If candidate prefix is not null, then append to result the - * concatenation of candidate prefix with ":" (U+003A COLON). - */ - let attrName = ''; - if (candidatePrefix !== null) { - attrName = candidatePrefix; - } - /** - * 3.8. If the require well-formed flag is set (its value is true), and - * this attr's localName attribute contains the character - * ":" (U+003A COLON) or does not match the XML Name production or - * equals "xmlns" and attribute namespace is null, then throw an - * exception; the serialization of this attr would not be a - * well-formed attribute. - */ - if (requireWellFormed && (attr.localName.indexOf(":") !== -1 || - !algorithm_1.xml_isName(attr.localName) || - (attr.localName === "xmlns" && attributeNamespace === null))) { - throw new Error("Attribute local name contains invalid characters (well-formed required)."); - } - /** - * 3.9. Append the following strings to result, in the order listed: - * 3.9.1. The value of attr's localName; - * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); - * 3.9.3. The result of serializing an attribute value given attr's value - * attribute and the require well-formed flag as input; - * 3.9.4. """ (U+0022 QUOTATION MARK). - */ - result.push([attributeNamespace, candidatePrefix, attr.localName, - this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]); - } - /** - * 4. Return the value of result. - */ - return result; - } - /** - * Produces an XML serialization of the attributes of an element node. - * - * @param node - node to serialize - * @param requireWellFormed - whether to check conformance - */ - _serializeAttributes(node, requireWellFormed, noDoubleEncoding) { - /** - * 1. Let result be the empty string. - * 2. Let localname set be a new empty namespace localname set. This - * localname set will contain tuples of unique attribute namespaceURI and - * localName pairs, and is populated as each attr is processed. This set is - * used to [optionally] enforce the well-formed constraint that an element - * cannot have two attributes with the same namespaceURI and localName. - * This can occur when two otherwise identical attributes on the same - * element differ only by their prefix values. - */ - const result = []; - const localNameSet = requireWellFormed ? {} : undefined; - /** - * 3. Loop: For each attribute attr in element's attributes, in the order - * they are specified in the element's attribute list: - */ - for (const attr of node.attributes) { - // Optimize common case - if (!requireWellFormed) { - result.push([null, null, attr.localName, - this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]); - continue; - } - /** - * 3.1. If the require well-formed flag is set (its value is true), and the - * localname set contains a tuple whose values match those of a new tuple - * consisting of attr's namespaceURI attribute and localName attribute, - * then throw an exception; the serialization of this attr would fail to - * produce a well-formed element serialization. - */ - if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) { - throw new Error("Element contains duplicate attributes (well-formed required)."); - } - /** - * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and - * localName attribute, and add it to the localname set. - * 3.3. Let attribute namespace be the value of attr's namespaceURI value. - * 3.4. Let candidate prefix be null. - */ - /* istanbul ignore else */ - if (requireWellFormed && localNameSet) - localNameSet[attr.localName] = true; - /** 3.5. If attribute namespace is not null, then run these sub-steps: */ - /** - * 3.6. Append a " " (U+0020 SPACE) to result. - * 3.7. If candidate prefix is not null, then append to result the - * concatenation of candidate prefix with ":" (U+003A COLON). - */ - /** - * 3.8. If the require well-formed flag is set (its value is true), and - * this attr's localName attribute contains the character - * ":" (U+003A COLON) or does not match the XML Name production or - * equals "xmlns" and attribute namespace is null, then throw an - * exception; the serialization of this attr would not be a - * well-formed attribute. - */ - if (requireWellFormed && (attr.localName.indexOf(":") !== -1 || - !algorithm_1.xml_isName(attr.localName))) { - throw new Error("Attribute local name contains invalid characters (well-formed required)."); - } - /** - * 3.9. Append the following strings to result, in the order listed: - * 3.9.1. The value of attr's localName; - * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK); - * 3.9.3. The result of serializing an attribute value given attr's value - * attribute and the require well-formed flag as input; - * 3.9.4. """ (U+0022 QUOTATION MARK). - */ - result.push([null, null, attr.localName, - this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]); - } - /** - * 4. Return the value of result. - */ - return result; - } - /** - * Records namespace information for the given element and returns the - * default namespace attribute value. - * - * @param node - element node to process - * @param map - namespace prefix map - * @param localPrefixesMap - local prefixes map - */ - _recordNamespaceInformation(node, map, localPrefixesMap) { - /** - * 1. Let default namespace attr value be null. - */ - let defaultNamespaceAttrValue = null; - /** - * 2. Main: For each attribute attr in element's attributes, in the order - * they are specified in the element's attribute list: - */ - for (const attr of node.attributes) { - /** - * _Note:_ The following conditional steps find namespace prefixes. Only - * attributes in the XMLNS namespace are considered (e.g., attributes made - * to look like namespace declarations via - * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not - * included). - */ - /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */ - let attributeNamespace = attr.namespaceURI; - /** 2.2. Let attribute prefix be the value of attr's prefix. */ - let attributePrefix = attr.prefix; - /** 2.3. If the attribute namespace is the XMLNS namespace, then: */ - if (attributeNamespace === infra_1.namespace.XMLNS) { - /** - * 2.3.1. If attribute prefix is null, then attr is a default namespace - * declaration. Set the default namespace attr value to attr's value and - * stop running these steps, returning to Main to visit the next - * attribute. - */ - if (attributePrefix === null) { - defaultNamespaceAttrValue = attr.value; - continue; - /** - * 2.3.2. Otherwise, the attribute prefix is not null and attr is a - * namespace prefix definition. Run the following steps: - */ - } - else { - /** 2.3.2.1. Let prefix definition be the value of attr's localName. */ - let prefixDefinition = attr.localName; - /** 2.3.2.2. Let namespace definition be the value of attr's value. */ - let namespaceDefinition = attr.value; - /** - * 2.3.2.3. If namespace definition is the XML namespace, then stop - * running these steps, and return to Main to visit the next - * attribute. - * - * _Note:_ XML namespace definitions in prefixes are completely - * ignored (in order to avoid unnecessary work when there might be - * prefix conflicts). XML namespaced elements are always handled - * uniformly by prefixing (and overriding if necessary) the element's - * localname with the reserved "xml" prefix. - */ - if (namespaceDefinition === infra_1.namespace.XML) { - continue; - } - /** - * 2.3.2.4. If namespace definition is the empty string (the - * declarative form of having no namespace), then let namespace - * definition be null instead. - */ - if (namespaceDefinition === '') { - namespaceDefinition = null; - } - /** - * 2.3.2.5. If prefix definition is found in map given the namespace - * namespace definition, then stop running these steps, and return to - * Main to visit the next attribute. - * - * _Note:_ This step avoids adding duplicate prefix definitions for - * the same namespace in the map. This has the side-effect of avoiding - * later serialization of duplicate namespace prefix declarations in - * any descendant nodes. - */ - if (map.has(prefixDefinition, namespaceDefinition)) { - continue; - } - /** - * 2.3.2.6. Add the prefix prefix definition to map given namespace - * namespace definition. - */ - map.set(prefixDefinition, namespaceDefinition); - /** - * 2.3.2.7. Add the value of prefix definition as a new key to the - * local prefixes map, with the namespace definition as the key's - * value replacing the value of null with the empty string if - * applicable. - */ - localPrefixesMap[prefixDefinition] = namespaceDefinition || ''; - } - } - } - /** - * 3. Return the value of default namespace attr value. - * - * _Note:_ The empty string is a legitimate return value and is not - * converted to null. - */ - return defaultNamespaceAttrValue; - } - /** - * Generates a new prefix for the given namespace. - * - * @param newNamespace - a namespace to generate prefix for - * @param prefixMap - namespace prefix map - * @param prefixIndex - generated namespace prefix index - */ - _generatePrefix(newNamespace, prefixMap, prefixIndex) { - /** - * 1. Let generated prefix be the concatenation of the string "ns" and the - * current numerical value of prefix index. - * 2. Let the value of prefix index be incremented by one. - * 3. Add to map the generated prefix given the new namespace namespace. - * 4. Return the value of generated prefix. - */ - const generatedPrefix = "ns" + prefixIndex.value.toString(); - prefixIndex.value++; - prefixMap.set(generatedPrefix, newNamespace); - return generatedPrefix; - } - /** - * Produces an XML serialization of an attribute value. - * - * @param value - attribute value - * @param requireWellFormed - whether to check conformance - */ - _serializeAttributeValue(value, requireWellFormed, noDoubleEncoding) { - /** - * From: https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value - * - * 1. If the require well-formed flag is set (its value is true), and - * attribute value contains characters that are not matched by the XML Char - * production, then throw an exception; the serialization of this attribute - * value would fail to produce a well-formed element serialization. - */ - if (requireWellFormed && value !== null && !algorithm_1.xml_isLegalChar(value)) { - throw new Error("Invalid characters in attribute value."); - } - /** - * 2. If attribute value is null, then return the empty string. - */ - if (value === null) - return ""; - /** - * 3. Otherwise, attribute value is a string. Return the value of attribute - * value, first replacing any occurrences of the following: - * - "&" with "&" - * - """ with """ - * - "<" with "<" - * - ">" with ">" - * NOTE - * This matches behavior present in browsers, and goes above and beyond the - * grammar requirement in the XML specification's AttValue production by - * also replacing ">" characters. - */ - if (noDoubleEncoding) { - return value.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&') - .replace(/") - result += ">"; - else - result += c; - } - return result; - } - } -} -exports.BaseWriter = BaseWriter; -BaseWriter._VoidElementNames = new Set(['area', 'base', 'basefont', - 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen', - 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']); -//# sourceMappingURL=BaseWriter.js.map - -/***/ }), - -/***/ 464: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const DOMException_1 = __webpack_require__(35); -/** - * Applies the filter to the given node and returns the result. - * - * @param traverser - the `NodeIterator` or `TreeWalker` instance - * @param node - the node to filter - */ -function traversal_filter(traverser, node) { - /** - * 1. If traverser’s active flag is set, then throw an "InvalidStateError" - * DOMException. - */ - if (traverser._activeFlag) { - throw new DOMException_1.InvalidStateError(); - } - /** - * 2. Let n be node’s nodeType attribute value − 1. - */ - const n = node._nodeType - 1; - /** - * 3. If the nth bit (where 0 is the least significant bit) of traverser’s - * whatToShow is not set, then return FILTER_SKIP. - */ - const mask = 1 << n; - if ((traverser.whatToShow & mask) === 0) { - return interfaces_1.FilterResult.Skip; - } - /** - * 4. If traverser’s filter is null, then return FILTER_ACCEPT. - */ - if (!traverser.filter) { - return interfaces_1.FilterResult.Accept; - } - /** - * 5. Set traverser’s active flag. - */ - traverser._activeFlag = true; - /** - * 6. Let result be the return value of call a user object’s operation with - * traverser’s filter, "acceptNode", and « node ». If this throws an - * exception, then unset traverser’s active flag and rethrow the exception. - */ - let result = interfaces_1.FilterResult.Reject; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; try { - result = traverser.filter.acceptNode(node); + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); } - catch (err) { - traverser._activeFlag = false; - throw err; - } - /** - * 7. Unset traverser’s active flag. - * 8. Return result. - */ - traverser._activeFlag = false; - return result; -} -exports.traversal_filter = traversal_filter; -//# sourceMappingURL=TraversalAlgorithm.js.map - -/***/ }), - -/***/ 468: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const XMLStringLexer_1 = __webpack_require__(911); -const interfaces_1 = __webpack_require__(172); -const infra_1 = __webpack_require__(23); -const algorithm_1 = __webpack_require__(163); -const LocalNameSet_1 = __webpack_require__(575); -/** - * Represents a parser for XML content. - * - * See: https://html.spec.whatwg.org/#xml-parser - */ -class XMLParserImpl { - /** - * Parses XML content. - * - * @param source - a string containing XML content - */ - parse(source) { - const lexer = new XMLStringLexer_1.XMLStringLexer(source, { skipWhitespaceOnlyText: true }); - const doc = algorithm_1.create_document(); - let context = doc; - let token = lexer.nextToken(); - while (token.type !== interfaces_1.TokenType.EOF) { - switch (token.type) { - case interfaces_1.TokenType.Declaration: - const declaration = token; - if (declaration.version !== "1.0") { - throw new Error("Invalid xml version: " + declaration.version); - } - break; - case interfaces_1.TokenType.DocType: - const doctype = token; - if (!algorithm_1.xml_isPubidChar(doctype.pubId)) { - throw new Error("DocType public identifier does not match PubidChar construct."); - } - if (!algorithm_1.xml_isLegalChar(doctype.sysId) || - (doctype.sysId.indexOf('"') !== -1 && doctype.sysId.indexOf("'") !== -1)) { - throw new Error("DocType system identifier contains invalid characters."); - } - context.appendChild(doc.implementation.createDocumentType(doctype.name, doctype.pubId, doctype.sysId)); - break; - case interfaces_1.TokenType.CDATA: - const cdata = token; - if (!algorithm_1.xml_isLegalChar(cdata.data) || - cdata.data.indexOf("]]>") !== -1) { - throw new Error("CDATA contains invalid characters."); - } - context.appendChild(doc.createCDATASection(cdata.data)); - break; - case interfaces_1.TokenType.Comment: - const comment = token; - if (!algorithm_1.xml_isLegalChar(comment.data) || - comment.data.indexOf("--") !== -1 || comment.data.endsWith("-")) { - throw new Error("Comment data contains invalid characters."); - } - context.appendChild(doc.createComment(comment.data)); - break; - case interfaces_1.TokenType.PI: - const pi = token; - if (pi.target.indexOf(":") !== -1 || (/^xml$/i).test(pi.target)) { - throw new Error("Processing instruction target contains invalid characters."); - } - if (!algorithm_1.xml_isLegalChar(pi.data) || pi.data.indexOf("?>") !== -1) { - throw new Error("Processing instruction data contains invalid characters."); - } - context.appendChild(doc.createProcessingInstruction(pi.target, pi.data)); - break; - case interfaces_1.TokenType.Text: - const text = token; - if (!algorithm_1.xml_isLegalChar(text.data)) { - throw new Error("Text data contains invalid characters."); - } - context.appendChild(doc.createTextNode(text.data)); - break; - case interfaces_1.TokenType.Element: - const element = token; - // inherit namespace from parent - const [prefix, localName] = algorithm_1.namespace_extractQName(element.name); - if (localName.indexOf(":") !== -1 || !algorithm_1.xml_isName(localName)) { - throw new Error("Node local name contains invalid characters."); - } - if (prefix === "xmlns") { - throw new Error("An element cannot have the 'xmlns' prefix."); - } - let namespace = context.lookupNamespaceURI(prefix); - // override namespace if there is a namespace declaration - // attribute - // also lookup namespace declaration attributes - const nsDeclarations = {}; - for (const [attName, attValue] of element.attributes) { - if (attName === "xmlns") { - namespace = attValue; - } - else { - const [attPrefix, attLocalName] = algorithm_1.namespace_extractQName(attName); - if (attPrefix === "xmlns") { - if (attLocalName === prefix) { - namespace = attValue; - } - nsDeclarations[attLocalName] = attValue; - } - } - } - // create the DOM element node - const elementNode = (namespace !== null ? - doc.createElementNS(namespace, element.name) : - doc.createElement(element.name)); - context.appendChild(elementNode); - // assign attributes - const localNameSet = new LocalNameSet_1.LocalNameSet(); - for (const [attName, attValue] of element.attributes) { - const [attPrefix, attLocalName] = algorithm_1.namespace_extractQName(attName); - let attNamespace = null; - if (attPrefix === "xmlns" || (attPrefix === null && attLocalName === "xmlns")) { - // namespace declaration attribute - attNamespace = infra_1.namespace.XMLNS; - } - else { - attNamespace = elementNode.lookupNamespaceURI(attPrefix); - if (attNamespace !== null && elementNode.isDefaultNamespace(attNamespace)) { - attNamespace = null; - } - else if (attNamespace === null && attPrefix !== null) { - attNamespace = nsDeclarations[attPrefix] || null; - } - } - if (localNameSet.has(attNamespace, attLocalName)) { - throw new Error("Element contains duplicate attributes."); - } - localNameSet.set(attNamespace, attLocalName); - if (attNamespace === infra_1.namespace.XMLNS) { - if (attValue === infra_1.namespace.XMLNS) { - throw new Error("XMLNS namespace is reserved."); - } - } - if (attLocalName.indexOf(":") !== -1 || !algorithm_1.xml_isName(attLocalName)) { - throw new Error("Attribute local name contains invalid characters."); - } - if (attPrefix === "xmlns" && attValue === "") { - throw new Error("Empty XML namespace is not allowed."); - } - if (attNamespace !== null) - elementNode.setAttributeNS(attNamespace, attName, attValue); - else - elementNode.setAttribute(attName, attValue); - } - if (!element.selfClosing) { - context = elementNode; - } - break; - case interfaces_1.TokenType.ClosingTag: - const closingTag = token; - if (closingTag.name !== context.nodeName) { - throw new Error('Closing tag name does not match opening tag name.'); - } - /* istanbul ignore else */ - if (context._parent) { - context = context._parent; - } - break; - } - token = lexer.nextToken(); - } - return doc; - } -} -exports.XMLParserImpl = XMLParserImpl; -//# sourceMappingURL=XMLParserImpl.js.map - -/***/ }), - -/***/ 470: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const command_1 = __webpack_require__(431); -const file_command_1 = __webpack_require__(102); -const utils_1 = __webpack_require__(82); -const os = __importStar(__webpack_require__(87)); -const path = __importStar(__webpack_require__(622)); -/** - * The code to exit an action - */ -var ExitCode; -(function (ExitCode) { - /** - * A code indicating that the action was successful - */ - ExitCode[ExitCode["Success"] = 0] = "Success"; - /** - * A code indicating that the action was a failure - */ - ExitCode[ExitCode["Failure"] = 1] = "Failure"; -})(ExitCode = exports.ExitCode || (exports.ExitCode = {})); -//----------------------------------------------------------------------- -// Variables -//----------------------------------------------------------------------- -/** - * Sets env variable for this action and future actions in the job - * @param name the name of the variable to set - * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -function exportVariable(name, val) { - const convertedVal = utils_1.toCommandValue(val); - process.env[name] = convertedVal; - const filePath = process.env['GITHUB_ENV'] || ''; - if (filePath) { - const delimiter = '_GitHubActionsFileCommandDelimeter_'; - const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`; - file_command_1.issueCommand('ENV', commandValue); - } - else { - command_1.issueCommand('set-env', { name }, convertedVal); - } -} -exports.exportVariable = exportVariable; -/** - * Registers a secret which will get masked from logs - * @param secret value of the secret - */ -function setSecret(secret) { - command_1.issueCommand('add-mask', {}, secret); -} -exports.setSecret = setSecret; -/** - * Prepends inputPath to the PATH (for this action and future actions) - * @param inputPath - */ -function addPath(inputPath) { - const filePath = process.env['GITHUB_PATH'] || ''; - if (filePath) { - file_command_1.issueCommand('PATH', inputPath); - } - else { - command_1.issueCommand('add-path', {}, inputPath); - } - process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; -} -exports.addPath = addPath; -/** - * Gets the value of an input. The value is also trimmed. - * - * @param name name of the input to get - * @param options optional. See InputOptions. - * @returns string - */ -function getInput(name, options) { - const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''; - if (options && options.required && !val) { - throw new Error(`Input required and not supplied: ${name}`); - } - return val.trim(); -} -exports.getInput = getInput; -/** - * Sets the value of an output. - * - * @param name name of the output to set - * @param value value to store. 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) { - command_1.issueCommand('set-output', { name }, value); -} -exports.setOutput = setOutput; -/** - * Enables or disables the echoing of commands into stdout for the rest of the step. - * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set. - * - */ -function setCommandEcho(enabled) { - command_1.issue('echo', enabled ? 'on' : 'off'); -} -exports.setCommandEcho = setCommandEcho; -//----------------------------------------------------------------------- -// Results -//----------------------------------------------------------------------- -/** - * Sets the action status to failed. - * When the action exits it will be with an exit code of 1 - * @param message add error issue message - */ -function setFailed(message) { - process.exitCode = ExitCode.Failure; - error(message); -} -exports.setFailed = setFailed; -//----------------------------------------------------------------------- -// Logging Commands -//----------------------------------------------------------------------- -/** - * Gets whether Actions Step Debug is on or not - */ -function isDebug() { - return process.env['RUNNER_DEBUG'] === '1'; -} -exports.isDebug = isDebug; -/** - * Writes debug message to user log - * @param message debug message - */ -function debug(message) { - command_1.issueCommand('debug', {}, message); -} -exports.debug = debug; -/** - * Adds an error issue - * @param message error issue message. Errors will be converted to string via toString() - */ -function error(message) { - command_1.issue('error', message instanceof Error ? message.toString() : message); -} -exports.error = error; -/** - * Adds an warning issue - * @param message warning issue message. Errors will be converted to string via toString() - */ -function warning(message) { - command_1.issue('warning', message instanceof Error ? message.toString() : message); -} -exports.warning = warning; -/** - * Writes info to log with console.log. - * @param message info message - */ -function info(message) { - process.stdout.write(message + os.EOL); -} -exports.info = info; -/** - * Begin an output group. - * - * Output until the next `groupEnd` will be foldable in this group - * - * @param name The name of the output group - */ -function startGroup(name) { - command_1.issue('group', name); -} -exports.startGroup = startGroup; -/** - * End an output group. - */ -function endGroup() { - command_1.issue('endgroup'); -} -exports.endGroup = endGroup; -/** - * Wrap an asynchronous function call in a group. - * - * Returns the same type as the function itself. - * - * @param name The name of the group - * @param fn The function to wrap in the group - */ -function group(name, fn) { - return __awaiter(this, void 0, void 0, function* () { - startGroup(name); - let result; + catch (error) { e = { error: error }; } + finally { try { - result = yield fn(); + if (r && !r.done && (m = i["return"])) m.call(i); } - finally { - endGroup(); - } - return result; - }); -} -exports.group = group; -//----------------------------------------------------------------------- -// Wrapper action state -//----------------------------------------------------------------------- -/** - * Saves state for current action, the state can only be retrieved by this action's post job execution. - * - * @param name name of the state to store - * @param value value to store. Non-string values will be converted to a string via JSON.stringify - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -function saveState(name, value) { - command_1.issueCommand('save-state', { name }, value); -} -exports.saveState = saveState; -/** - * Gets the value of an state set by this action's main execution. - * - * @param name name of the state to get - * @returns string - */ -function getState(name) { - return process.env[`STATE_${name}`] || ''; -} -exports.getState = getState; -//# sourceMappingURL=core.js.map - -/***/ }), - -/***/ 476: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const algorithm_1 = __webpack_require__(163); -/** - * Represents a mixin that allows nodes to become the contents of - * a element. This mixin is implemented by {@link Element} and - * {@link Text}. - */ -class SlotableImpl { - get _name() { return this.__name || ''; } - set _name(val) { this.__name = val; } - get _assignedSlot() { return this.__assignedSlot || null; } - set _assignedSlot(val) { this.__assignedSlot = val; } - /** @inheritdoc */ - get assignedSlot() { - return algorithm_1.shadowTree_findASlot(this, true); - } -} -exports.SlotableImpl = SlotableImpl; -//# sourceMappingURL=SlotableImpl.js.map - -/***/ }), - -/***/ 479: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const DOMException_1 = __webpack_require__(35); -const interfaces_1 = __webpack_require__(970); -const util_1 = __webpack_require__(918); -const util_2 = __webpack_require__(337); -const infra_1 = __webpack_require__(23); -const CustomElementAlgorithm_1 = __webpack_require__(344); -const TreeAlgorithm_1 = __webpack_require__(873); -const NodeIteratorAlgorithm_1 = __webpack_require__(272); -const ShadowTreeAlgorithm_1 = __webpack_require__(180); -const MutationObserverAlgorithm_1 = __webpack_require__(151); -const DOMAlgorithm_1 = __webpack_require__(304); -const DocumentAlgorithm_1 = __webpack_require__(493); -/** - * Ensures pre-insertion validity of a node into a parent before a - * child. - * - * @param node - node to insert - * @param parent - parent node to receive node - * @param child - child node to insert node before - */ -function mutation_ensurePreInsertionValidity(node, parent, child) { - const parentNodeType = parent._nodeType; - const nodeNodeType = node._nodeType; - const childNodeType = child ? child._nodeType : null; - /** - * 1. If parent is not a Document, DocumentFragment, or Element node, - * throw a "HierarchyRequestError" DOMException. - */ - if (parentNodeType !== interfaces_1.NodeType.Document && - parentNodeType !== interfaces_1.NodeType.DocumentFragment && - parentNodeType !== interfaces_1.NodeType.Element) - throw new DOMException_1.HierarchyRequestError(`Only document, document fragment and element nodes can contain child nodes. Parent node is ${parent.nodeName}.`); - /** - * 2. If node is a host-including inclusive ancestor of parent, throw a - * "HierarchyRequestError" DOMException. - */ - if (TreeAlgorithm_1.tree_isHostIncludingAncestorOf(parent, node, true)) - throw new DOMException_1.HierarchyRequestError(`The node to be inserted cannot be an inclusive ancestor of parent node. Node is ${node.nodeName}, parent node is ${parent.nodeName}.`); - /** - * 3. If child is not null and its parent is not parent, then throw a - * "NotFoundError" DOMException. - */ - if (child !== null && child._parent !== parent) - throw new DOMException_1.NotFoundError(`The reference child node cannot be found under parent node. Child node is ${child.nodeName}, parent node is ${parent.nodeName}.`); - /** - * 4. If node is not a DocumentFragment, DocumentType, Element, Text, - * ProcessingInstruction, or Comment node, throw a "HierarchyRequestError" - * DOMException. - */ - if (nodeNodeType !== interfaces_1.NodeType.DocumentFragment && - nodeNodeType !== interfaces_1.NodeType.DocumentType && - nodeNodeType !== interfaces_1.NodeType.Element && - nodeNodeType !== interfaces_1.NodeType.Text && - nodeNodeType !== interfaces_1.NodeType.ProcessingInstruction && - nodeNodeType !== interfaces_1.NodeType.CData && - nodeNodeType !== interfaces_1.NodeType.Comment) - throw new DOMException_1.HierarchyRequestError(`Only document fragment, document type, element, text, processing instruction, cdata section or comment nodes can be inserted. Node is ${node.nodeName}.`); - /** - * 5. If either node is a Text node and parent is a document, or node is a - * doctype and parent is not a document, throw a "HierarchyRequestError" - * DOMException. - */ - if (nodeNodeType === interfaces_1.NodeType.Text && - parentNodeType === interfaces_1.NodeType.Document) - throw new DOMException_1.HierarchyRequestError(`Cannot insert a text node as a child of a document node. Node is ${node.nodeName}.`); - if (nodeNodeType === interfaces_1.NodeType.DocumentType && - parentNodeType !== interfaces_1.NodeType.Document) - throw new DOMException_1.HierarchyRequestError(`A document type node can only be inserted under a document node. Parent node is ${parent.nodeName}.`); - /** - * 6. If parent is a document, and any of the statements below, switched on - * node, are true, throw a "HierarchyRequestError" DOMException. - * - DocumentFragment node - * If node has more than one element child or has a Text node child. - * Otherwise, if node has one element child and either parent has an element - * child, child is a doctype, or child is not null and a doctype is - * following child. - * - element - * parent has an element child, child is a doctype, or child is not null and - * a doctype is following child. - * - doctype - * parent has a doctype child, child is non-null and an element is preceding - * child, or child is null and parent has an element child. - */ - if (parentNodeType === interfaces_1.NodeType.Document) { - if (nodeNodeType === interfaces_1.NodeType.DocumentFragment) { - let eleCount = 0; - for (const childNode of node._children) { - if (childNode._nodeType === interfaces_1.NodeType.Element) - eleCount++; - else if (childNode._nodeType === interfaces_1.NodeType.Text) - throw new DOMException_1.HierarchyRequestError(`Cannot insert text a node as a child of a document node. Node is ${childNode.nodeName}.`); - } - if (eleCount > 1) { - throw new DOMException_1.HierarchyRequestError(`A document node can only have one document element node. Document fragment to be inserted has ${eleCount} element nodes.`); - } - else if (eleCount === 1) { - for (const ele of parent._children) { - if (ele._nodeType === interfaces_1.NodeType.Element) - throw new DOMException_1.HierarchyRequestError(`The document node already has a document element node.`); - } - if (child) { - if (childNodeType === interfaces_1.NodeType.DocumentType) - throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node.`); - let doctypeChild = child._nextSibling; - while (doctypeChild) { - if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType) - throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node.`); - doctypeChild = doctypeChild._nextSibling; - } - } - } - } - else if (nodeNodeType === interfaces_1.NodeType.Element) { - for (const ele of parent._children) { - if (ele._nodeType === interfaces_1.NodeType.Element) - throw new DOMException_1.HierarchyRequestError(`Document already has a document element node. Node is ${node.nodeName}.`); - } - if (child) { - if (childNodeType === interfaces_1.NodeType.DocumentType) - throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node. Node is ${node.nodeName}.`); - let doctypeChild = child._nextSibling; - while (doctypeChild) { - if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType) - throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node. Node is ${node.nodeName}.`); - doctypeChild = doctypeChild._nextSibling; - } - } - } - else if (nodeNodeType === interfaces_1.NodeType.DocumentType) { - for (const ele of parent._children) { - if (ele._nodeType === interfaces_1.NodeType.DocumentType) - throw new DOMException_1.HierarchyRequestError(`Document already has a document type node. Node is ${node.nodeName}.`); - } - if (child) { - let elementChild = child._previousSibling; - while (elementChild) { - if (elementChild._nodeType === interfaces_1.NodeType.Element) - throw new DOMException_1.HierarchyRequestError(`Cannot insert a document type node before an element node. Node is ${node.nodeName}.`); - elementChild = elementChild._previousSibling; - } - } - else { - let elementChild = parent._firstChild; - while (elementChild) { - if (elementChild._nodeType === interfaces_1.NodeType.Element) - throw new DOMException_1.HierarchyRequestError(`Cannot insert a document type node before an element node. Node is ${node.nodeName}.`); - elementChild = elementChild._nextSibling; - } - } - } - } -} -exports.mutation_ensurePreInsertionValidity = mutation_ensurePreInsertionValidity; -/** - * Ensures pre-insertion validity of a node into a parent before a - * child, then adopts the node to the tree and inserts it. - * - * @param node - node to insert - * @param parent - parent node to receive node - * @param child - child node to insert node before - */ -function mutation_preInsert(node, parent, child) { - /** - * 1. Ensure pre-insertion validity of node into parent before child. - * 2. Let reference child be child. - * 3. If reference child is node, set it to node’s next sibling. - * 4. Adopt node into parent’s node document. - * 5. Insert node into parent before reference child. - * 6. Return node. - */ - mutation_ensurePreInsertionValidity(node, parent, child); - let referenceChild = child; - if (referenceChild === node) - referenceChild = node._nextSibling; - DocumentAlgorithm_1.document_adopt(node, parent._nodeDocument); - mutation_insert(node, parent, referenceChild); - return node; -} -exports.mutation_preInsert = mutation_preInsert; -/** - * Inserts a node into a parent node before the given child node. - * - * @param node - node to insert - * @param parent - parent node to receive node - * @param child - child node to insert node before - * @param suppressObservers - whether to notify observers - */ -function mutation_insert(node, parent, child, suppressObservers) { - // Optimized common case - if (child === null && node._nodeType !== interfaces_1.NodeType.DocumentFragment) { - mutation_insert_single(node, parent, suppressObservers); - return; - } - /** - * 1. Let count be the number of children of node if it is a - * DocumentFragment node, and one otherwise. - */ - const count = (node._nodeType === interfaces_1.NodeType.DocumentFragment ? - node._children.size : 1); - /** - * 2. If child is non-null, then: - */ - if (child !== null) { - /** - * 2.1. For each live range whose start node is parent and start - * offset is greater than child's index, increase its start - * offset by count. - * 2.2. For each live range whose end node is parent and end - * offset is greater than child's index, increase its end - * offset by count. - */ - if (dom_1.dom.rangeList.size !== 0) { - const index = TreeAlgorithm_1.tree_index(child); - for (const range of dom_1.dom.rangeList) { - if (range._start[0] === parent && range._start[1] > index) { - range._start[1] += count; - } - if (range._end[0] === parent && range._end[1] > index) { - range._end[1] += count; - } - } - } - } - /** - * 3. Let nodes be node’s children, if node is a DocumentFragment node; - * otherwise « node ». - */ - const nodes = node._nodeType === interfaces_1.NodeType.DocumentFragment ? - new Array(...node._children) : [node]; - /** - * 4. If node is a DocumentFragment node, remove its children with the - * suppress observers flag set. - */ - if (node._nodeType === interfaces_1.NodeType.DocumentFragment) { - while (node._firstChild) { - mutation_remove(node._firstChild, node, true); - } - } - /** - * 5. If node is a DocumentFragment node, then queue a tree mutation record - * for node with « », nodes, null, and null. - */ - if (dom_1.dom.features.mutationObservers) { - if (node._nodeType === interfaces_1.NodeType.DocumentFragment) { - MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(node, [], nodes, null, null); - } - } - /** - * 6. Let previousSibling be child’s previous sibling or parent’s last - * child if child is null. - */ - const previousSibling = (child ? child._previousSibling : parent._lastChild); - let index = child === null ? -1 : TreeAlgorithm_1.tree_index(child); - /** - * 7. For each node in nodes, in tree order: - */ - for (let i = 0; i < nodes.length; i++) { - const node = nodes[i]; - if (util_1.Guard.isElementNode(node)) { - // set document element node - if (util_1.Guard.isDocumentNode(parent)) { - parent._documentElement = node; - } - // mark that the document has namespaces - if (!node._nodeDocument._hasNamespaces && (node._namespace !== null || - node._namespacePrefix !== null)) { - node._nodeDocument._hasNamespaces = true; - } - } - /** - * 7.1. If child is null, then append node to parent’s children. - * 7.2. Otherwise, insert node into parent’s children before child’s - * index. - */ - node._parent = parent; - if (child === null) { - infra_1.set.append(parent._children, node); - } - else { - infra_1.set.insert(parent._children, node, index); - index++; - } - // assign siblings and children for quick lookups - if (parent._firstChild === null) { - node._previousSibling = null; - node._nextSibling = null; - parent._firstChild = node; - parent._lastChild = node; - } - else { - const prev = (child ? child._previousSibling : parent._lastChild); - const next = (child ? child : null); - node._previousSibling = prev; - node._nextSibling = next; - if (prev) - prev._nextSibling = node; - if (next) - next._previousSibling = node; - if (!prev) - parent._firstChild = node; - if (!next) - parent._lastChild = node; - } - /** - * 7.3. If parent is a shadow host and node is a slotable, then - * assign a slot for node. - */ - if (dom_1.dom.features.slots) { - if (parent._shadowRoot !== null && util_1.Guard.isSlotable(node)) { - ShadowTreeAlgorithm_1.shadowTree_assignASlot(node); - } - } - /** - * 7.4. If node is a Text node, run the child text content change - * steps for parent. - */ - if (dom_1.dom.features.steps) { - if (util_1.Guard.isTextNode(node)) { - DOMAlgorithm_1.dom_runChildTextContentChangeSteps(parent); - } - } - /** - * 7.5. If parent's root is a shadow root, and parent is a slot - * whose assigned nodes is the empty list, then run signal - * a slot change for parent. - */ - if (dom_1.dom.features.slots) { - if (util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(parent)) && - util_1.Guard.isSlot(parent) && util_2.isEmpty(parent._assignedNodes)) { - ShadowTreeAlgorithm_1.shadowTree_signalASlotChange(parent); - } - } - /** - * 7.6. Run assign slotables for a tree with node's root. - */ - if (dom_1.dom.features.slots) { - ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(node)); - } - /** - * 7.7. For each shadow-including inclusive descendant - * inclusiveDescendant of node, in shadow-including tree - * order: - */ - let inclusiveDescendant = TreeAlgorithm_1.tree_getFirstDescendantNode(node, true, true); - while (inclusiveDescendant !== null) { - /** - * 7.7.1. Run the insertion steps with inclusiveDescendant. - */ - if (dom_1.dom.features.steps) { - DOMAlgorithm_1.dom_runInsertionSteps(inclusiveDescendant); - } - if (dom_1.dom.features.customElements) { - /** - * 7.7.2. If inclusiveDescendant is connected, then: - */ - if (util_1.Guard.isElementNode(inclusiveDescendant) && - ShadowTreeAlgorithm_1.shadowTree_isConnected(inclusiveDescendant)) { - if (util_1.Guard.isCustomElementNode(inclusiveDescendant)) { - /** - * 7.7.2.1. If inclusiveDescendant is custom, then enqueue a custom - * element callback reaction with inclusiveDescendant, callback name - * "connectedCallback", and an empty argument list. - */ - CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(inclusiveDescendant, "connectedCallback", []); - } - else { - /** - * 7.7.2.2. Otherwise, try to upgrade inclusiveDescendant. - */ - CustomElementAlgorithm_1.customElement_tryToUpgrade(inclusiveDescendant); - } - } - } - inclusiveDescendant = TreeAlgorithm_1.tree_getNextDescendantNode(node, inclusiveDescendant, true, true); - } - } - /** - * 8. If suppress observers flag is unset, then queue a tree mutation record - * for parent with nodes, « », previousSibling, and child. - */ - if (dom_1.dom.features.mutationObservers) { - if (!suppressObservers) { - MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, nodes, [], previousSibling, child); - } - } -} -exports.mutation_insert = mutation_insert; -/** - * Inserts a node into a parent node. Optimized routine for the common case where - * node is not a document fragment node and it has no child nodes. - * - * @param node - node to insert - * @param parent - parent node to receive node - * @param suppressObservers - whether to notify observers - */ -function mutation_insert_single(node, parent, suppressObservers) { - /** - * 1. Let count be the number of children of node if it is a - * DocumentFragment node, and one otherwise. - * 2. If child is non-null, then: - * 2.1. For each live range whose start node is parent and start - * offset is greater than child's index, increase its start - * offset by count. - * 2.2. For each live range whose end node is parent and end - * offset is greater than child's index, increase its end - * offset by count. - * 3. Let nodes be node’s children, if node is a DocumentFragment node; - * otherwise « node ». - * 4. If node is a DocumentFragment node, remove its children with the - * suppress observers flag set. - * 5. If node is a DocumentFragment node, then queue a tree mutation record - * for node with « », nodes, null, and null. - */ - /** - * 6. Let previousSibling be child’s previous sibling or parent’s last - * child if child is null. - */ - const previousSibling = parent._lastChild; - // set document element node - if (util_1.Guard.isElementNode(node)) { - // set document element node - if (util_1.Guard.isDocumentNode(parent)) { - parent._documentElement = node; - } - // mark that the document has namespaces - if (!node._nodeDocument._hasNamespaces && (node._namespace !== null || - node._namespacePrefix !== null)) { - node._nodeDocument._hasNamespaces = true; - } - } - /** - * 7. For each node in nodes, in tree order: - * 7.1. If child is null, then append node to parent’s children. - * 7.2. Otherwise, insert node into parent’s children before child’s - * index. - */ - node._parent = parent; - parent._children.add(node); - // assign siblings and children for quick lookups - if (parent._firstChild === null) { - node._previousSibling = null; - node._nextSibling = null; - parent._firstChild = node; - parent._lastChild = node; - } - else { - const prev = parent._lastChild; - node._previousSibling = prev; - node._nextSibling = null; - if (prev) - prev._nextSibling = node; - if (!prev) - parent._firstChild = node; - parent._lastChild = node; - } - /** - * 7.3. If parent is a shadow host and node is a slotable, then - * assign a slot for node. - */ - if (dom_1.dom.features.slots) { - if (parent._shadowRoot !== null && util_1.Guard.isSlotable(node)) { - ShadowTreeAlgorithm_1.shadowTree_assignASlot(node); - } - } - /** - * 7.4. If node is a Text node, run the child text content change - * steps for parent. - */ - if (dom_1.dom.features.steps) { - if (util_1.Guard.isTextNode(node)) { - DOMAlgorithm_1.dom_runChildTextContentChangeSteps(parent); - } - } - /** - * 7.5. If parent's root is a shadow root, and parent is a slot - * whose assigned nodes is the empty list, then run signal - * a slot change for parent. - */ - if (dom_1.dom.features.slots) { - if (util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(parent)) && - util_1.Guard.isSlot(parent) && util_2.isEmpty(parent._assignedNodes)) { - ShadowTreeAlgorithm_1.shadowTree_signalASlotChange(parent); - } - } - /** - * 7.6. Run assign slotables for a tree with node's root. - */ - if (dom_1.dom.features.slots) { - ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(node)); - } - /** - * 7.7. For each shadow-including inclusive descendant - * inclusiveDescendant of node, in shadow-including tree - * order: - * 7.7.1. Run the insertion steps with inclusiveDescendant. - */ - if (dom_1.dom.features.steps) { - DOMAlgorithm_1.dom_runInsertionSteps(node); - } - if (dom_1.dom.features.customElements) { - /** - * 7.7.2. If inclusiveDescendant is connected, then: - */ - if (util_1.Guard.isElementNode(node) && - ShadowTreeAlgorithm_1.shadowTree_isConnected(node)) { - if (util_1.Guard.isCustomElementNode(node)) { - /** - * 7.7.2.1. If inclusiveDescendant is custom, then enqueue a custom - * element callback reaction with inclusiveDescendant, callback name - * "connectedCallback", and an empty argument list. - */ - CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(node, "connectedCallback", []); - } - else { - /** - * 7.7.2.2. Otherwise, try to upgrade inclusiveDescendant. - */ - CustomElementAlgorithm_1.customElement_tryToUpgrade(node); - } - } - } - /** - * 8. If suppress observers flag is unset, then queue a tree mutation record - * for parent with nodes, « », previousSibling, and child. - */ - if (dom_1.dom.features.mutationObservers) { - if (!suppressObservers) { - MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, [node], [], previousSibling, null); - } - } -} -/** - * Appends a node to the children of a parent node. - * - * @param node - a node - * @param parent - the parent to receive node - */ -function mutation_append(node, parent) { - /** - * To append a node to a parent, pre-insert node into parent before null. - */ - return mutation_preInsert(node, parent, null); -} -exports.mutation_append = mutation_append; -/** - * Replaces a node with another node. - * - * @param child - child node to remove - * @param node - node to insert - * @param parent - parent node to receive node - */ -function mutation_replace(child, node, parent) { - /** - * 1. If parent is not a Document, DocumentFragment, or Element node, - * throw a "HierarchyRequestError" DOMException. - */ - if (parent._nodeType !== interfaces_1.NodeType.Document && - parent._nodeType !== interfaces_1.NodeType.DocumentFragment && - parent._nodeType !== interfaces_1.NodeType.Element) - throw new DOMException_1.HierarchyRequestError(`Only document, document fragment and element nodes can contain child nodes. Parent node is ${parent.nodeName}.`); - /** - * 2. If node is a host-including inclusive ancestor of parent, throw a - * "HierarchyRequestError" DOMException. - */ - if (TreeAlgorithm_1.tree_isHostIncludingAncestorOf(parent, node, true)) - throw new DOMException_1.HierarchyRequestError(`The node to be inserted cannot be an ancestor of parent node. Node is ${node.nodeName}, parent node is ${parent.nodeName}.`); - /** - * 3. If child’s parent is not parent, then throw a "NotFoundError" - * DOMException. - */ - if (child._parent !== parent) - throw new DOMException_1.NotFoundError(`The reference child node cannot be found under parent node. Child node is ${child.nodeName}, parent node is ${parent.nodeName}.`); - /** - * 4. If node is not a DocumentFragment, DocumentType, Element, Text, - * ProcessingInstruction, or Comment node, throw a "HierarchyRequestError" - * DOMException. - */ - if (node._nodeType !== interfaces_1.NodeType.DocumentFragment && - node._nodeType !== interfaces_1.NodeType.DocumentType && - node._nodeType !== interfaces_1.NodeType.Element && - node._nodeType !== interfaces_1.NodeType.Text && - node._nodeType !== interfaces_1.NodeType.ProcessingInstruction && - node._nodeType !== interfaces_1.NodeType.CData && - node._nodeType !== interfaces_1.NodeType.Comment) - throw new DOMException_1.HierarchyRequestError(`Only document fragment, document type, element, text, processing instruction, cdata section or comment nodes can be inserted. Node is ${node.nodeName}.`); - /** - * 5. If either node is a Text node and parent is a document, or node is a - * doctype and parent is not a document, throw a "HierarchyRequestError" - * DOMException. - */ - if (node._nodeType === interfaces_1.NodeType.Text && - parent._nodeType === interfaces_1.NodeType.Document) - throw new DOMException_1.HierarchyRequestError(`Cannot insert a text node as a child of a document node. Node is ${node.nodeName}.`); - if (node._nodeType === interfaces_1.NodeType.DocumentType && - parent._nodeType !== interfaces_1.NodeType.Document) - throw new DOMException_1.HierarchyRequestError(`A document type node can only be inserted under a document node. Parent node is ${parent.nodeName}.`); - /** - * 6. If parent is a document, and any of the statements below, switched on - * node, are true, throw a "HierarchyRequestError" DOMException. - * - DocumentFragment node - * If node has more than one element child or has a Text node child. - * Otherwise, if node has one element child and either parent has an element - * child that is not child or a doctype is following child. - * - element - * parent has an element child that is not child or a doctype is - * following child. - * - doctype - * parent has a doctype child that is not child, or an element is - * preceding child. - */ - if (parent._nodeType === interfaces_1.NodeType.Document) { - if (node._nodeType === interfaces_1.NodeType.DocumentFragment) { - let eleCount = 0; - for (const childNode of node._children) { - if (childNode._nodeType === interfaces_1.NodeType.Element) - eleCount++; - else if (childNode._nodeType === interfaces_1.NodeType.Text) - throw new DOMException_1.HierarchyRequestError(`Cannot insert text a node as a child of a document node. Node is ${childNode.nodeName}.`); - } - if (eleCount > 1) { - throw new DOMException_1.HierarchyRequestError(`A document node can only have one document element node. Document fragment to be inserted has ${eleCount} element nodes.`); - } - else if (eleCount === 1) { - for (const ele of parent._children) { - if (ele._nodeType === interfaces_1.NodeType.Element && ele !== child) - throw new DOMException_1.HierarchyRequestError(`The document node already has a document element node.`); - } - let doctypeChild = child._nextSibling; - while (doctypeChild) { - if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType) - throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node.`); - doctypeChild = doctypeChild._nextSibling; - } - } - } - else if (node._nodeType === interfaces_1.NodeType.Element) { - for (const ele of parent._children) { - if (ele._nodeType === interfaces_1.NodeType.Element && ele !== child) - throw new DOMException_1.HierarchyRequestError(`Document already has a document element node. Node is ${node.nodeName}.`); - } - let doctypeChild = child._nextSibling; - while (doctypeChild) { - if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType) - throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node. Node is ${node.nodeName}.`); - doctypeChild = doctypeChild._nextSibling; - } - } - else if (node._nodeType === interfaces_1.NodeType.DocumentType) { - for (const ele of parent._children) { - if (ele._nodeType === interfaces_1.NodeType.DocumentType && ele !== child) - throw new DOMException_1.HierarchyRequestError(`Document already has a document type node. Node is ${node.nodeName}.`); - } - let elementChild = child._previousSibling; - while (elementChild) { - if (elementChild._nodeType === interfaces_1.NodeType.Element) - throw new DOMException_1.HierarchyRequestError(`Cannot insert a document type node before an element node. Node is ${node.nodeName}.`); - elementChild = elementChild._previousSibling; - } - } - } - /** - * 7. Let reference child be child’s next sibling. - * 8. If reference child is node, set it to node’s next sibling. - * 8. Let previousSibling be child’s previous sibling. - */ - let referenceChild = child._nextSibling; - if (referenceChild === node) - referenceChild = node._nextSibling; - let previousSibling = child._previousSibling; - /** - * 10. Adopt node into parent’s node document. - * 11. Let removedNodes be the empty list. - */ - DocumentAlgorithm_1.document_adopt(node, parent._nodeDocument); - const removedNodes = []; - /** - * 12. If child’s parent is not null, then: - */ - if (child._parent !== null) { - /** - * 12.1. Set removedNodes to [child]. - * 12.2. Remove child from its parent with the suppress observers flag - * set. - */ - removedNodes.push(child); - mutation_remove(child, child._parent, true); - } - /** - * 13. Let nodes be node’s children if node is a DocumentFragment node; - * otherwise [node]. - */ - let nodes = []; - if (node._nodeType === interfaces_1.NodeType.DocumentFragment) { - nodes = Array.from(node._children); - } - else { - nodes.push(node); - } - /** - * 14. Insert node into parent before reference child with the suppress - * observers flag set. - */ - mutation_insert(node, parent, referenceChild, true); - /** - * 15. Queue a tree mutation record for parent with nodes, removedNodes, - * previousSibling, and reference child. - */ - if (dom_1.dom.features.mutationObservers) { - MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, nodes, removedNodes, previousSibling, referenceChild); - } - /** - * 16. Return child. - */ - return child; -} -exports.mutation_replace = mutation_replace; -/** - * Replaces all nodes of a parent with the given node. - * - * @param node - node to insert - * @param parent - parent node to receive node - */ -function mutation_replaceAll(node, parent) { - /** - * 1. If node is not null, adopt node into parent’s node document. - */ - if (node !== null) { - DocumentAlgorithm_1.document_adopt(node, parent._nodeDocument); - } - /** - * 2. Let removedNodes be parent’s children. - */ - const removedNodes = Array.from(parent._children); - /** - * 3. Let addedNodes be the empty list. - * 4. If node is DocumentFragment node, then set addedNodes to node’s - * children. - * 5. Otherwise, if node is non-null, set addedNodes to [node]. - */ - let addedNodes = []; - if (node && node._nodeType === interfaces_1.NodeType.DocumentFragment) { - addedNodes = Array.from(node._children); - } - else if (node !== null) { - addedNodes.push(node); - } - /** - * 6. Remove all parent’s children, in tree order, with the suppress - * observers flag set. - */ - for (const childNode of removedNodes) { - mutation_remove(childNode, parent, true); - } - /** - * 7. If node is not null, then insert node into parent before null with the - * suppress observers flag set. - */ - if (node !== null) { - mutation_insert(node, parent, null, true); - } - /** - * 8. Queue a tree mutation record for parent with addedNodes, removedNodes, - * null, and null. - */ - if (dom_1.dom.features.mutationObservers) { - MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, addedNodes, removedNodes, null, null); - } -} -exports.mutation_replaceAll = mutation_replaceAll; -/** - * Ensures pre-removal validity of a child node from a parent, then - * removes it. - * - * @param child - child node to remove - * @param parent - parent node - */ -function mutation_preRemove(child, parent) { - /** - * 1. If child’s parent is not parent, then throw a "NotFoundError" - * DOMException. - * 2. Remove child from parent. - * 3. Return child. - */ - if (child._parent !== parent) - throw new DOMException_1.NotFoundError(`The child node cannot be found under parent node. Child node is ${child.nodeName}, parent node is ${parent.nodeName}.`); - mutation_remove(child, parent); - return child; -} -exports.mutation_preRemove = mutation_preRemove; -/** - * Removes a child node from its parent. - * - * @param node - node to remove - * @param parent - parent node - * @param suppressObservers - whether to notify observers - */ -function mutation_remove(node, parent, suppressObservers) { - if (dom_1.dom.rangeList.size !== 0) { - /** - * 1. Let index be node’s index. - */ - const index = TreeAlgorithm_1.tree_index(node); - /** - * 2. For each live range whose start node is an inclusive descendant of - * node, set its start to (parent, index). - * 3. For each live range whose end node is an inclusive descendant of - * node, set its end to (parent, index). - */ - for (const range of dom_1.dom.rangeList) { - if (TreeAlgorithm_1.tree_isDescendantOf(node, range._start[0], true)) { - range._start = [parent, index]; - } - if (TreeAlgorithm_1.tree_isDescendantOf(node, range._end[0], true)) { - range._end = [parent, index]; - } - if (range._start[0] === parent && range._start[1] > index) { - range._start[1]--; - } - if (range._end[0] === parent && range._end[1] > index) { - range._end[1]--; - } - } - /** - * 4. For each live range whose start node is parent and start offset is - * greater than index, decrease its start offset by 1. - * 5. For each live range whose end node is parent and end offset is greater - * than index, decrease its end offset by 1. - */ - for (const range of dom_1.dom.rangeList) { - if (range._start[0] === parent && range._start[1] > index) { - range._start[1] -= 1; - } - if (range._end[0] === parent && range._end[1] > index) { - range._end[1] -= 1; - } - } - } - /** - * 6. For each NodeIterator object iterator whose root’s node document is - * node’s node document, run the NodeIterator pre-removing steps given node - * and iterator. - */ - if (dom_1.dom.features.steps) { - for (const iterator of NodeIteratorAlgorithm_1.nodeIterator_iteratorList()) { - if (iterator._root._nodeDocument === node._nodeDocument) { - DOMAlgorithm_1.dom_runNodeIteratorPreRemovingSteps(iterator, node); - } - } - } - /** - * 7. Let oldPreviousSibling be node’s previous sibling. - * 8. Let oldNextSibling be node’s next sibling. - */ - const oldPreviousSibling = node._previousSibling; - const oldNextSibling = node._nextSibling; - // set document element node - if (util_1.Guard.isDocumentNode(parent) && util_1.Guard.isElementNode(node)) { - parent._documentElement = null; - } - /** - * 9. Remove node from its parent’s children. - */ - node._parent = null; - parent._children.delete(node); - // assign siblings and children for quick lookups - const prev = node._previousSibling; - const next = node._nextSibling; - node._previousSibling = null; - node._nextSibling = null; - if (prev) - prev._nextSibling = next; - if (next) - next._previousSibling = prev; - if (!prev) - parent._firstChild = next; - if (!next) - parent._lastChild = prev; - /** - * 10. If node is assigned, then run assign slotables for node’s assigned - * slot. - */ - if (dom_1.dom.features.slots) { - if (util_1.Guard.isSlotable(node) && node._assignedSlot !== null && ShadowTreeAlgorithm_1.shadowTree_isAssigned(node)) { - ShadowTreeAlgorithm_1.shadowTree_assignSlotables(node._assignedSlot); - } - } - /** - * 11. If parent’s root is a shadow root, and parent is a slot whose - * assigned nodes is the empty list, then run signal a slot change for - * parent. - */ - if (dom_1.dom.features.slots) { - if (util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(parent)) && - util_1.Guard.isSlot(parent) && util_2.isEmpty(parent._assignedNodes)) { - ShadowTreeAlgorithm_1.shadowTree_signalASlotChange(parent); - } - } - /** - * 12. If node has an inclusive descendant that is a slot, then: - * 12.1. Run assign slotables for a tree with parent's root. - * 12.2. Run assign slotables for a tree with node. - */ - if (dom_1.dom.features.slots) { - const descendant = TreeAlgorithm_1.tree_getFirstDescendantNode(node, true, false, (e) => util_1.Guard.isSlot(e)); - if (descendant !== null) { - ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(parent)); - ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(node); - } - } - /** - * 13. Run the removing steps with node and parent. - */ - if (dom_1.dom.features.steps) { - DOMAlgorithm_1.dom_runRemovingSteps(node, parent); - } - /** - * 14. If node is custom, then enqueue a custom element callback - * reaction with node, callback name "disconnectedCallback", - * and an empty argument list. - */ - if (dom_1.dom.features.customElements) { - if (util_1.Guard.isCustomElementNode(node)) { - CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(node, "disconnectedCallback", []); - } - } - /** - * 15. For each shadow-including descendant descendant of node, - * in shadow-including tree order, then: - */ - let descendant = TreeAlgorithm_1.tree_getFirstDescendantNode(node, false, true); - while (descendant !== null) { - /** - * 15.1. Run the removing steps with descendant. - */ - if (dom_1.dom.features.steps) { - DOMAlgorithm_1.dom_runRemovingSteps(descendant, node); - } - /** - * 15.2. If descendant is custom, then enqueue a custom element - * callback reaction with descendant, callback name - * "disconnectedCallback", and an empty argument list. - */ - if (dom_1.dom.features.customElements) { - if (util_1.Guard.isCustomElementNode(descendant)) { - CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(descendant, "disconnectedCallback", []); - } - } - descendant = TreeAlgorithm_1.tree_getNextDescendantNode(node, descendant, false, true); - } - /** - * 16. For each inclusive ancestor inclusiveAncestor of parent, and - * then for each registered of inclusiveAncestor's registered - * observer list, if registered's options's subtree is true, - * then append a new transient registered observer whose - * observer is registered's observer, options is registered's - * options, and source is registered to node's registered - * observer list. - */ - if (dom_1.dom.features.mutationObservers) { - let inclusiveAncestor = TreeAlgorithm_1.tree_getFirstAncestorNode(parent, true); - while (inclusiveAncestor !== null) { - for (const registered of inclusiveAncestor._registeredObserverList) { - if (registered.options.subtree) { - node._registeredObserverList.push({ - observer: registered.observer, - options: registered.options, - source: registered - }); - } - } - inclusiveAncestor = TreeAlgorithm_1.tree_getNextAncestorNode(parent, inclusiveAncestor, true); - } - } - /** - * 17. If suppress observers flag is unset, then queue a tree mutation - * record for parent with « », « node », oldPreviousSibling, and - * oldNextSibling. - */ - if (dom_1.dom.features.mutationObservers) { - if (!suppressObservers) { - MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, [], [node], oldPreviousSibling, oldNextSibling); - } - } - /** - * 18. If node is a Text node, then run the child text content change steps - * for parent. - */ - if (dom_1.dom.features.steps) { - if (util_1.Guard.isTextNode(node)) { - DOMAlgorithm_1.dom_runChildTextContentChangeSteps(parent); - } - } -} -exports.mutation_remove = mutation_remove; -//# sourceMappingURL=MutationAlgorithm.js.map - -/***/ }), - -/***/ 483: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const DOMException_1 = __webpack_require__(35); -/** - * Matches elements with the given selectors. - * - * @param selectors - selectors - * @param node - the node to match against - */ -function selectors_scopeMatchASelectorsString(selectors, node) { - /** - * TODO: Selectors - * 1. Let s be the result of parse a selector selectors. [SELECTORS4] - * 2. If s is failure, then throw a "SyntaxError" DOMException. - * 3. Return the result of match a selector against a tree with s and node’s - * root using scoping root node. [SELECTORS4]. - */ - throw new DOMException_1.NotSupportedError(); -} -exports.selectors_scopeMatchASelectorsString = selectors_scopeMatchASelectorsString; -//# sourceMappingURL=SelectorsAlgorithm.js.map - -/***/ }), - -/***/ 486: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(42); -/** - * Gets the value corresponding to the given key. - * - * @param map - a map - * @param key - a key - */ -function get(map, key) { - return map.get(key); -} -exports.get = get; -/** - * Sets the value corresponding to the given key. - * - * @param map - a map - * @param key - a key - * @param val - a value - */ -function set(map, key, val) { - map.set(key, val); -} -exports.set = set; -/** - * Removes the item with the given key or all items matching condition. - * - * @param map - a map - * @param conditionOrItem - the key of an item to remove or a condition matching - * items to remove - */ -function remove(map, conditionOrItem) { - if (!util_1.isFunction(conditionOrItem)) { - map.delete(conditionOrItem); - } - else { - const toRemove = []; - for (const item of map) { - if (!!conditionOrItem.call(null, item)) { - toRemove.push(item[0]); - } - } - for (const key of toRemove) { - map.delete(key); - } - } -} -exports.remove = remove; -/** - * Determines if the map contains a value with the given key. - * - * @param map - a map - * @param conditionOrItem - the key of an item to match or a condition matching - * items - */ -function contains(map, conditionOrItem) { - if (!util_1.isFunction(conditionOrItem)) { - return map.has(conditionOrItem); - } - else { - for (const item of map) { - if (!!conditionOrItem.call(null, item)) { - return true; - } - } - return false; - } -} -exports.contains = contains; -/** - * Gets the keys of the map. - * - * @param map - a map - */ -function keys(map) { - return new Set(map.keys()); -} -exports.keys = keys; -/** - * Gets the values of the map. - * - * @param map - a map - */ -function values(map) { - return [...map.values()]; -} -exports.values = values; -/** - * Gets the size of the map. - * - * @param map - a map - * @param condition - an optional condition to match - */ -function size(map, condition) { - if (condition === undefined) { - return map.size; - } - else { - let count = 0; - for (const item of map) { - if (!!condition.call(null, item)) { - count++; - } - } - return count; - } -} -exports.size = size; -/** - * Determines if the map is empty. - * - * @param map - a map - */ -function isEmpty(map) { - return map.size === 0; -} -exports.isEmpty = isEmpty; -/** - * Returns an iterator for the items of the map. - * - * @param map - a map - * @param condition - an optional condition to match - */ -function* forEach(map, condition) { - if (condition === undefined) { - yield* map; - } - else { - for (const item of map) { - if (!!condition.call(null, item)) { - yield item; - } - } - } -} -exports.forEach = forEach; -/** - * Creates and returns a shallow clone of map. - * - * @param map - a map - */ -function clone(map) { - return new Map(map); -} -exports.clone = clone; -/** - * Returns a new map containing items from the map sorted in ascending - * order. - * - * @param map - a map - * @param lessThanAlgo - a function that returns `true` if its first argument - * is less than its second argument, and `false` otherwise. - */ -function sortInAscendingOrder(map, lessThanAlgo) { - const list = new Array(...map); - list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1); - return new Map(list); -} -exports.sortInAscendingOrder = sortInAscendingOrder; -/** - * Returns a new map containing items from the map sorted in descending - * order. - * - * @param map - a map - * @param lessThanAlgo - a function that returns `true` if its first argument - * is less than its second argument, and `false` otherwise. - */ -function sortInDescendingOrder(map, lessThanAlgo) { - const list = new Array(...map); - list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1); - return new Map(list); -} -exports.sortInDescendingOrder = sortInDescendingOrder; -//# sourceMappingURL=Map.js.map - -/***/ }), - -/***/ 487: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -/** - * Represents an object which can be used to iterate through the nodes - * of a subtree. - */ -class TraverserImpl { - /** - * Initializes a new instance of `Traverser`. - * - * @param root - root node - */ - constructor(root) { - this._activeFlag = false; - this._root = root; - this._whatToShow = interfaces_1.WhatToShow.All; - this._filter = null; - } - /** @inheritdoc */ - get root() { return this._root; } - /** @inheritdoc */ - get whatToShow() { return this._whatToShow; } - /** @inheritdoc */ - get filter() { return this._filter; } -} -exports.TraverserImpl = TraverserImpl; -//# sourceMappingURL=TraverserImpl.js.map - -/***/ }), - -/***/ 488: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const _1 = __webpack_require__(113); -const interfaces_1 = __webpack_require__(970); -const DOMException_1 = __webpack_require__(35); -const NodeImpl_1 = __webpack_require__(935); -const util_1 = __webpack_require__(918); -const util_2 = __webpack_require__(337); -const infra_1 = __webpack_require__(23); -const URLAlgorithm_1 = __webpack_require__(813); -const algorithm_1 = __webpack_require__(163); -const WebIDLAlgorithm_1 = __webpack_require__(495); -/** - * Represents a document node. - */ -class DocumentImpl extends NodeImpl_1.NodeImpl { - /** - * Initializes a new instance of `Document`. - */ - constructor() { - super(); - this._children = new Set(); - this._encoding = { - name: "UTF-8", - labels: ["unicode-1-1-utf-8", "utf-8", "utf8"] - }; - this._contentType = 'application/xml'; - this._URL = { - scheme: "about", - username: "", - password: "", - host: null, - port: null, - path: ["blank"], - query: null, - fragment: null, - _cannotBeABaseURLFlag: true, - _blobURLEntry: null - }; - this._origin = null; - this._type = "xml"; - this._mode = "no-quirks"; - this._documentElement = null; - this._hasNamespaces = false; - this._nodeDocumentOverwrite = null; - } - get _nodeDocument() { return this._nodeDocumentOverwrite || this; } - set _nodeDocument(val) { this._nodeDocumentOverwrite = val; } - /** @inheritdoc */ - get implementation() { - /** - * The implementation attribute’s getter must return the DOMImplementation - * object that is associated with the document. - */ - return this._implementation || (this._implementation = algorithm_1.create_domImplementation(this)); - } - /** @inheritdoc */ - get URL() { - /** - * The URL attribute’s getter and documentURI attribute’s getter must return - * the URL, serialized. - * See: https://url.spec.whatwg.org/#concept-url-serializer - */ - return URLAlgorithm_1.urlSerializer(this._URL); - } - /** @inheritdoc */ - get documentURI() { return this.URL; } - /** @inheritdoc */ - get origin() { - return "null"; - } - /** @inheritdoc */ - get compatMode() { - /** - * The compatMode attribute’s getter must return "BackCompat" if context - * object’s mode is "quirks", and "CSS1Compat" otherwise. - */ - return this._mode === "quirks" ? "BackCompat" : "CSS1Compat"; - } - /** @inheritdoc */ - get characterSet() { - /** - * The characterSet attribute’s getter, charset attribute’s getter, and - * inputEncoding attribute’s getter, must return context object’s - * encoding’s name. - */ - return this._encoding.name; - } - /** @inheritdoc */ - get charset() { return this._encoding.name; } - /** @inheritdoc */ - get inputEncoding() { return this._encoding.name; } - /** @inheritdoc */ - get contentType() { - /** - * The contentType attribute’s getter must return the content type. - */ - return this._contentType; - } - /** @inheritdoc */ - get doctype() { - /** - * The doctype attribute’s getter must return the child of the document - * that is a doctype, and null otherwise. - */ - for (const child of this._children) { - if (util_1.Guard.isDocumentTypeNode(child)) - return child; - } - return null; - } - /** @inheritdoc */ - get documentElement() { - /** - * The documentElement attribute’s getter must return the document element. - */ - return this._documentElement; - } - /** @inheritdoc */ - getElementsByTagName(qualifiedName) { - /** - * The getElementsByTagName(qualifiedName) method, when invoked, must return - * the list of elements with qualified name qualifiedName for the context object. - */ - return algorithm_1.node_listOfElementsWithQualifiedName(qualifiedName, this); - } - /** @inheritdoc */ - getElementsByTagNameNS(namespace, localName) { - /** - * The getElementsByTagNameNS(namespace, localName) method, when invoked, - * must return the list of elements with namespace namespace and local name - * localName for the context object. - */ - return algorithm_1.node_listOfElementsWithNamespace(namespace, localName, this); - } - /** @inheritdoc */ - getElementsByClassName(classNames) { - /** - * The getElementsByClassName(classNames) method, when invoked, must return - * the list of elements with class names classNames for the context object. - */ - return algorithm_1.node_listOfElementsWithClassNames(classNames, this); - } - /** @inheritdoc */ - createElement(localName, options) { - /** - * 1. If localName does not match the Name production, then throw an - * "InvalidCharacterError" DOMException. - * 2. If the context object is an HTML document, then set localName to - * localName in ASCII lowercase. - * 3. Let is be null. - * 4. If options is a dictionary and options’s is is present, then set is - * to it. - * 5. Let namespace be the HTML namespace, if the context object is an - * HTML document or context object’s content type is - * "application/xhtml+xml", and null otherwise. - * 6. Return the result of creating an element given the context object, - * localName, namespace, null, is, and with the synchronous custom elements - * flag set. - */ - if (!algorithm_1.xml_isName(localName)) - throw new DOMException_1.InvalidCharacterError(); - if (this._type === "html") - localName = localName.toLowerCase(); - let is = null; - if (options !== undefined) { - if (util_2.isString(options)) { - is = options; - } - else { - is = options.is; - } - } - const namespace = (this._type === "html" || this._contentType === "application/xhtml+xml") ? - infra_1.namespace.HTML : null; - return algorithm_1.element_createAnElement(this, localName, namespace, null, is, true); - } - /** @inheritdoc */ - createElementNS(namespace, qualifiedName, options) { - /** - * The createElementNS(namespace, qualifiedName, options) method, when - * invoked, must return the result of running the internal createElementNS - * steps, given context object, namespace, qualifiedName, and options. - */ - return algorithm_1.document_internalCreateElementNS(this, namespace, qualifiedName, options); - } - /** @inheritdoc */ - createDocumentFragment() { - /** - * The createDocumentFragment() method, when invoked, must return a new - * DocumentFragment node with its node document set to the context object. - */ - return algorithm_1.create_documentFragment(this); - } - /** @inheritdoc */ - createTextNode(data) { - /** - * The createTextNode(data) method, when invoked, must return a new Text - * node with its data set to data and node document set to the context object. - */ - return algorithm_1.create_text(this, data); - } - /** @inheritdoc */ - createCDATASection(data) { - /** - * 1. If context object is an HTML document, then throw a - * "NotSupportedError" DOMException. - * 2. If data contains the string "]]>", then throw an - * "InvalidCharacterError" DOMException. - * 3. Return a new CDATASection node with its data set to data and node - * document set to the context object. - */ - if (this._type === "html") - throw new DOMException_1.NotSupportedError(); - if (data.indexOf(']]>') !== -1) - throw new DOMException_1.InvalidCharacterError(); - return algorithm_1.create_cdataSection(this, data); - } - /** @inheritdoc */ - createComment(data) { - /** - * The createComment(data) method, when invoked, must return a new Comment - * node with its data set to data and node document set to the context object. - */ - return algorithm_1.create_comment(this, data); - } - /** @inheritdoc */ - createProcessingInstruction(target, data) { - /** - * 1. If target does not match the Name production, then throw an - * "InvalidCharacterError" DOMException. - * 2. If data contains the string "?>", then throw an - * "InvalidCharacterError" DOMException. - * 3. Return a new ProcessingInstruction node, with target set to target, - * data set to data, and node document set to the context object. - */ - if (!algorithm_1.xml_isName(target)) - throw new DOMException_1.InvalidCharacterError(); - if (data.indexOf("?>") !== -1) - throw new DOMException_1.InvalidCharacterError(); - return algorithm_1.create_processingInstruction(this, target, data); - } - /** @inheritdoc */ - importNode(node, deep = false) { - /** - * 1. If node is a document or shadow root, then throw a "NotSupportedError" DOMException. - */ - if (util_1.Guard.isDocumentNode(node) || util_1.Guard.isShadowRoot(node)) - throw new DOMException_1.NotSupportedError(); - /** - * 2. Return a clone of node, with context object and the clone children flag set if deep is true. - */ - return algorithm_1.node_clone(node, this, deep); - } - /** @inheritdoc */ - adoptNode(node) { - /** - * 1. If node is a document, then throw a "NotSupportedError" DOMException. - */ - if (util_1.Guard.isDocumentNode(node)) - throw new DOMException_1.NotSupportedError(); - /** - * 2. If node is a shadow root, then throw a "HierarchyRequestError" DOMException. - */ - if (util_1.Guard.isShadowRoot(node)) - throw new DOMException_1.HierarchyRequestError(); - /** - * 3. Adopt node into the context object. - * 4. Return node. - */ - algorithm_1.document_adopt(node, this); - return node; - } - /** @inheritdoc */ - createAttribute(localName) { - /** - * 1. If localName does not match the Name production in XML, then throw - * an "InvalidCharacterError" DOMException. - * 2. If the context object is an HTML document, then set localName to - * localName in ASCII lowercase. - * 3. Return a new attribute whose local name is localName and node document - * is context object. - */ - if (!algorithm_1.xml_isName(localName)) - throw new DOMException_1.InvalidCharacterError(); - if (this._type === "html") { - localName = localName.toLowerCase(); - } - const attr = algorithm_1.create_attr(this, localName); - return attr; - } - /** @inheritdoc */ - createAttributeNS(namespace, qualifiedName) { - /** - * 1. Let namespace, prefix, and localName be the result of passing - * namespace and qualifiedName to validate and extract. - * 2. Return a new attribute whose namespace is namespace, namespace prefix - * is prefix, local name is localName, and node document is context object. - */ - const [ns, prefix, localName] = algorithm_1.namespace_validateAndExtract(namespace, qualifiedName); - const attr = algorithm_1.create_attr(this, localName); - attr._namespace = ns; - attr._namespacePrefix = prefix; - return attr; - } - /** @inheritdoc */ - createEvent(eventInterface) { - return algorithm_1.event_createLegacyEvent(eventInterface); - } - /** @inheritdoc */ - createRange() { - /** - * The createRange() method, when invoked, must return a new live range - * with (context object, 0) as its start and end. - */ - const range = algorithm_1.create_range(); - range._start = [this, 0]; - range._end = [this, 0]; - return range; - } - /** @inheritdoc */ - createNodeIterator(root, whatToShow = interfaces_1.WhatToShow.All, filter = null) { - /** - * 1. Let iterator be a new NodeIterator object. - * 2. Set iterator’s root and iterator’s reference to root. - * 3. Set iterator’s pointer before reference to true. - * 4. Set iterator’s whatToShow to whatToShow. - * 5. Set iterator’s filter to filter. - * 6. Return iterator. - */ - const iterator = algorithm_1.create_nodeIterator(root, root, true); - iterator._whatToShow = whatToShow; - iterator._iteratorCollection = algorithm_1.create_nodeList(root); - if (util_2.isFunction(filter)) { - iterator._filter = algorithm_1.create_nodeFilter(); - iterator._filter.acceptNode = filter; - } - else { - iterator._filter = filter; - } - return iterator; - } - /** @inheritdoc */ - createTreeWalker(root, whatToShow = interfaces_1.WhatToShow.All, filter = null) { - /** - * 1. Let walker be a new TreeWalker object. - * 2. Set walker’s root and walker’s current to root. - * 3. Set walker’s whatToShow to whatToShow. - * 4. Set walker’s filter to filter. - * 5. Return walker. - */ - const walker = algorithm_1.create_treeWalker(root, root); - walker._whatToShow = whatToShow; - if (util_2.isFunction(filter)) { - walker._filter = algorithm_1.create_nodeFilter(); - walker._filter.acceptNode = filter; - } - else { - walker._filter = filter; - } - return walker; - } - /** - * Gets the parent event target for the given event. - * - * @param event - an event - */ - _getTheParent(event) { - /** - * TODO: Implement realms - * A document’s get the parent algorithm, given an event, returns null if - * event’s type attribute value is "load" or document does not have a - * browsing context, and the document’s relevant global object otherwise. - */ - if (event._type === "load") { - return null; - } - else { - return _1.dom.window; - } - } - // MIXIN: NonElementParentNode - /* istanbul ignore next */ - getElementById(elementId) { throw new Error("Mixin: NonElementParentNode not implemented."); } - // MIXIN: DocumentOrShadowRoot - // No elements - // MIXIN: ParentNode - /* istanbul ignore next */ - get children() { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - get firstElementChild() { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - get lastElementChild() { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - get childElementCount() { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - prepend(...nodes) { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - append(...nodes) { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - querySelector(selectors) { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - querySelectorAll(selectors) { throw new Error("Mixin: ParentNode not implemented."); } -} -exports.DocumentImpl = DocumentImpl; -/** - * Initialize prototype properties - */ -WebIDLAlgorithm_1.idl_defineConst(DocumentImpl.prototype, "_nodeType", interfaces_1.NodeType.Document); -//# sourceMappingURL=DocumentImpl.js.map - -/***/ }), - -/***/ 493: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const util_1 = __webpack_require__(918); -const util_2 = __webpack_require__(337); -const ElementImpl_1 = __webpack_require__(695); -const CustomElementAlgorithm_1 = __webpack_require__(344); -const TreeAlgorithm_1 = __webpack_require__(873); -const NamespaceAlgorithm_1 = __webpack_require__(664); -const DOMAlgorithm_1 = __webpack_require__(304); -const ElementAlgorithm_1 = __webpack_require__(33); -const MutationAlgorithm_1 = __webpack_require__(479); -/** - * Returns an element interface for the given name and namespace. - * - * @param name - element name - * @param namespace - namespace - */ -function document_elementInterface(name, namespace) { - return ElementImpl_1.ElementImpl; -} -exports.document_elementInterface = document_elementInterface; -/** - * Creates a new element node. - * See: https://dom.spec.whatwg.org/#internal-createelementns-steps - * - * @param document - owner document - * @param namespace - element namespace - * @param qualifiedName - qualified name - * @param options - element options - */ -function document_internalCreateElementNS(document, namespace, qualifiedName, options) { - /** - * 1. Let namespace, prefix, and localName be the result of passing - * namespace and qualifiedName to validate and extract. - * 2. Let is be null. - * 3. If options is a dictionary and options’s is is present, then set - * is to it. - * 4. Return the result of creating an element given document, localName, - * namespace, prefix, is, and with the synchronous custom elements flag set. - */ - const [ns, prefix, localName] = NamespaceAlgorithm_1.namespace_validateAndExtract(namespace, qualifiedName); - let is = null; - if (options !== undefined) { - if (util_2.isString(options)) { - is = options; - } - else { - is = options.is; - } - } - return ElementAlgorithm_1.element_createAnElement(document, localName, ns, prefix, is, true); -} -exports.document_internalCreateElementNS = document_internalCreateElementNS; -/** - * Removes `node` and its subtree from its document and changes - * its owner document to `document` so that it can be inserted - * into `document`. - * - * @param node - the node to move - * @param document - document to receive the node and its subtree - */ -function document_adopt(node, document) { - // Optimize for common case of inserting a fresh node - if (node._nodeDocument === document && node._parent === null) { - return; - } - /** - * 1. Let oldDocument be node’s node document. - * 2. If node’s parent is not null, remove node from its parent. - */ - const oldDocument = node._nodeDocument; - if (node._parent) - MutationAlgorithm_1.mutation_remove(node, node._parent); - /** - * 3. If document is not oldDocument, then: - */ - if (document !== oldDocument) { - /** - * 3.1. For each inclusiveDescendant in node’s shadow-including inclusive - * descendants: - */ - let inclusiveDescendant = TreeAlgorithm_1.tree_getFirstDescendantNode(node, true, true); - while (inclusiveDescendant !== null) { - /** - * 3.1.1. Set inclusiveDescendant’s node document to document. - * 3.1.2. If inclusiveDescendant is an element, then set the node - * document of each attribute in inclusiveDescendant’s attribute list - * to document. - */ - inclusiveDescendant._nodeDocument = document; - if (util_1.Guard.isElementNode(inclusiveDescendant)) { - for (const attr of inclusiveDescendant._attributeList._asArray()) { - attr._nodeDocument = document; - } - } - /** - * 3.2. For each inclusiveDescendant in node's shadow-including - * inclusive descendants that is custom, enqueue a custom - * element callback reaction with inclusiveDescendant, - * callback name "adoptedCallback", and an argument list - * containing oldDocument and document. - */ - if (dom_1.dom.features.customElements) { - if (util_1.Guard.isElementNode(inclusiveDescendant) && - inclusiveDescendant._customElementState === "custom") { - CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(inclusiveDescendant, "adoptedCallback", [oldDocument, document]); - } - } - /** - * 3.3. For each inclusiveDescendant in node’s shadow-including - * inclusive descendants, in shadow-including tree order, run the - * adopting steps with inclusiveDescendant and oldDocument. - */ - if (dom_1.dom.features.steps) { - DOMAlgorithm_1.dom_runAdoptingSteps(inclusiveDescendant, oldDocument); - } - inclusiveDescendant = TreeAlgorithm_1.tree_getNextDescendantNode(node, inclusiveDescendant, true, true); - } - } -} -exports.document_adopt = document_adopt; -//# sourceMappingURL=DocumentAlgorithm.js.map - -/***/ }), - -/***/ 495: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Defines a WebIDL `Const` property on the given object. - * - * @param o - object on which to add the property - * @param name - property name - * @param value - property value - */ -function idl_defineConst(o, name, value) { - Object.defineProperty(o, name, { writable: false, enumerable: true, configurable: false, value: value }); -} -exports.idl_defineConst = idl_defineConst; -//# sourceMappingURL=WebIDLAlgorithm.js.map - -/***/ }), - -/***/ 496: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(68); -/** - * Adds the given item to the end of the set. - * - * @param set - a set - * @param item - an item - */ -function append(set, item) { - set.add(item); -} -exports.append = append; -/** - * Extends a set by appending all items from another set. - * - * @param setA - a list to extend - * @param setB - a list containing items to append to `setA` - */ -function extend(setA, setB) { - setB.forEach(setA.add, setA); -} -exports.extend = extend; -/** - * Inserts the given item to the start of the set. - * - * @param set - a set - * @param item - an item - */ -function prepend(set, item) { - const cloned = new Set(set); - set.clear(); - set.add(item); - cloned.forEach(set.add, set); -} -exports.prepend = prepend; -/** - * Replaces the given item or all items matching condition with a new item. - * - * @param set - a set - * @param conditionOrItem - an item to replace or a condition matching items - * to replace - * @param item - an item - */ -function replace(set, conditionOrItem, newItem) { - const newSet = new Set(); - for (const oldItem of set) { - if (util_1.isFunction(conditionOrItem)) { - if (!!conditionOrItem.call(null, oldItem)) { - newSet.add(newItem); - } - else { - newSet.add(oldItem); - } - } - else if (oldItem === conditionOrItem) { - newSet.add(newItem); - } - else { - newSet.add(oldItem); - } - } - set.clear(); - newSet.forEach(set.add, set); -} -exports.replace = replace; -/** - * Inserts the given item before the given index. - * - * @param set - a set - * @param item - an item - */ -function insert(set, item, index) { - const newSet = new Set(); - let i = 0; - for (const oldItem of set) { - if (i === index) - newSet.add(item); - newSet.add(oldItem); - i++; - } - set.clear(); - newSet.forEach(set.add, set); -} -exports.insert = insert; -/** - * Removes the given item or all items matching condition. - * - * @param set - a set - * @param conditionOrItem - an item to remove or a condition matching items - * to remove - */ -function remove(set, conditionOrItem) { - if (!util_1.isFunction(conditionOrItem)) { - set.delete(conditionOrItem); - } - else { - const toRemove = []; - for (const item of set) { - if (!!conditionOrItem.call(null, item)) { - toRemove.push(item); - } - } - for (const oldItem of toRemove) { - set.delete(oldItem); - } - } -} -exports.remove = remove; -/** - * Removes all items from the set. - */ -function empty(set) { - set.clear(); -} -exports.empty = empty; -/** - * Determines if the set contains the given item or any items matching - * condition. - * - * @param set - a set - * @param conditionOrItem - an item to a condition to match - */ -function contains(set, conditionOrItem) { - if (!util_1.isFunction(conditionOrItem)) { - return set.has(conditionOrItem); - } - else { - for (const oldItem of set) { - if (!!conditionOrItem.call(null, oldItem)) { - return true; - } - } - } - return false; -} -exports.contains = contains; -/** - * Returns the count of items in the set matching the given condition. - * - * @param set - a set - * @param condition - an optional condition to match - */ -function size(set, condition) { - if (condition === undefined) { - return set.size; - } - else { - let count = 0; - for (const item of set) { - if (!!condition.call(null, item)) { - count++; - } - } - return count; - } -} -exports.size = size; -/** - * Determines if the set is empty. - * - * @param set - a set - */ -function isEmpty(set) { - return set.size === 0; -} -exports.isEmpty = isEmpty; -/** - * Returns an iterator for the items of the set. - * - * @param set - a set - * @param condition - an optional condition to match - */ -function* forEach(set, condition) { - if (condition === undefined) { - yield* set; - } - else { - for (const item of set) { - if (!!condition.call(null, item)) { - yield item; - } - } - } -} -exports.forEach = forEach; -/** - * Creates and returns a shallow clone of set. - * - * @param set - a set - */ -function clone(set) { - return new Set(set); -} -exports.clone = clone; -/** - * Returns a new set containing items from the set sorted in ascending - * order. - * - * @param set - a set - * @param lessThanAlgo - a function that returns `true` if its first argument - * is less than its second argument, and `false` otherwise. - */ -function sortInAscendingOrder(set, lessThanAlgo) { - const list = new Array(...set); - list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1); - return new Set(list); -} -exports.sortInAscendingOrder = sortInAscendingOrder; -/** - * Returns a new set containing items from the set sorted in descending - * order. - * - * @param set - a set - * @param lessThanAlgo - a function that returns `true` if its first argument - * is less than its second argument, and `false` otherwise. - */ -function sortInDescendingOrder(set, lessThanAlgo) { - const list = new Array(...set); - list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1); - return new Set(list); -} -exports.sortInDescendingOrder = sortInDescendingOrder; -/** - * Determines if a set is a subset of another set. - * - * @param subset - a set - * @param superset - a superset possibly containing all items from `subset`. - */ -function isSubsetOf(subset, superset) { - for (const item of subset) { - if (!superset.has(item)) - return false; - } - return true; -} -exports.isSubsetOf = isSubsetOf; -/** - * Determines if a set is a superset of another set. - * - * @param superset - a set - * @param subset - a subset possibly contained within `superset`. - */ -function isSupersetOf(superset, subset) { - return isSubsetOf(subset, superset); -} -exports.isSupersetOf = isSupersetOf; -/** - * Returns a new set with items that are contained in both sets. - * - * @param setA - a set - * @param setB - a set - */ -function intersection(setA, setB) { - const newSet = new Set(); - for (const item of setA) { - if (setB.has(item)) - newSet.add(item); - } - return newSet; -} -exports.intersection = intersection; -/** - * Returns a new set with items from both sets. - * - * @param setA - a set - * @param setB - a set - */ -function union(setA, setB) { - const newSet = new Set(setA); - setB.forEach(newSet.add, newSet); - return newSet; -} -exports.union = union; -/** - * Returns a set of integers from `n` to `m` inclusive. - * - * @param n - starting number - * @param m - ending number - */ -function range(n, m) { - const newSet = new Set(); - for (let i = n; i <= m; i++) { - newSet.add(i); - } - return newSet; -} -exports.range = range; -//# sourceMappingURL=Set.js.map - -/***/ }), - -/***/ 501: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Appends the given item to the queue. - * - * @param list - a list - * @param item - an item - */ -function enqueue(list, item) { - list.push(item); -} -exports.enqueue = enqueue; -/** - * Removes and returns an item from the queue. - * - * @param list - a list - */ -function dequeue(list) { - return list.shift() || null; -} -exports.dequeue = dequeue; -//# sourceMappingURL=Queue.js.map - -/***/ }), - -/***/ 512: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Pre-serializes XML nodes. - */ -class BaseCBWriter { - /** - * Initializes a new instance of `BaseCBWriter`. - * - * @param builderOptions - XML builder options - */ - constructor(builderOptions) { - /** - * Gets the current depth of the XML tree. - */ - this.level = 0; - this._builderOptions = builderOptions; - this._writerOptions = builderOptions; - } -} -exports.BaseCBWriter = BaseCBWriter; -//# sourceMappingURL=BaseCBWriter.js.map - -/***/ }), - -/***/ 522: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(68); -/** - * Parses the given byte sequence representing a JSON string into an object. - * - * @param bytes - a byte sequence - */ -function parseJSONFromBytes(bytes) { - /** - * 1. Let jsonText be the result of running UTF-8 decode on bytes. [ENCODING] - * 2. Return ? Call(%JSONParse%, undefined, « jsonText »). - */ - const jsonText = util_1.utf8Decode(bytes); - return JSON.parse.call(undefined, jsonText); -} -exports.parseJSONFromBytes = parseJSONFromBytes; -/** - * Serialize the given JavaScript value into a byte sequence. - * - * @param value - a JavaScript value - */ -function serializeJSONToBytes(value) { - /** - * 1. Let jsonString be ? Call(%JSONStringify%, undefined, « value »). - * 2. Return the result of running UTF-8 encode on jsonString. [ENCODING] - */ - const jsonString = JSON.stringify.call(undefined, value); - return util_1.utf8Encode(jsonString); -} -exports.serializeJSONToBytes = serializeJSONToBytes; -/** - * Parses the given JSON string into a Realm-independent JavaScript value. - * - * @param jsonText - a JSON string - */ -function parseJSONIntoInfraValues(jsonText) { - /** - * 1. Let jsValue be ? Call(%JSONParse%, undefined, « jsonText »). - * 2. Return the result of converting a JSON-derived JavaScript value to an - * Infra value, given jsValue. - */ - const jsValue = JSON.parse.call(undefined, jsonText); - return convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue); -} -exports.parseJSONIntoInfraValues = parseJSONIntoInfraValues; -/** - * Parses the value into a Realm-independent JavaScript value. - * - * @param jsValue - a JavaScript value - */ -function convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue) { - /** - * 1. If Type(jsValue) is Null, String, or Number, then return jsValue. - */ - if (jsValue === null || util_1.isString(jsValue) || util_1.isNumber(jsValue)) - return jsValue; - /** - * 2. If IsArray(jsValue) is true, then: - * 2.1. Let result be an empty list. - * 2.2. Let length be ! ToLength(! Get(jsValue, "length")). - * 2.3. For each index of the range 0 to length − 1, inclusive: - * 2.3.1. Let indexName be ! ToString(index). - * 2.3.2. Let jsValueAtIndex be ! Get(jsValue, indexName). - * 2.3.3. Let infraValueAtIndex be the result of converting a JSON-derived - * JavaScript value to an Infra value, given jsValueAtIndex. - * 2.3.4. Append infraValueAtIndex to result. - * 2.8. Return result. - */ - if (util_1.isArray(jsValue)) { - const result = new Array(); - for (const jsValueAtIndex of jsValue) { - result.push(convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtIndex)); - } - return result; - } - else if (util_1.isObject(jsValue)) { - /** - * 3. Let result be an empty ordered map. - * 4. For each key of ! jsValue.[[OwnPropertyKeys]](): - * 4.1. Let jsValueAtKey be ! Get(jsValue, key). - * 4.2. Let infraValueAtKey be the result of converting a JSON-derived - * JavaScript value to an Infra value, given jsValueAtKey. - * 4.3. Set result[key] to infraValueAtKey. - * 5. Return result. - */ - const result = new Map(); - for (const key in jsValue) { - /* istanbul ignore else */ - if (jsValue.hasOwnProperty(key)) { - const jsValueAtKey = jsValue[key]; - result.set(key, convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtKey)); - } - } - return result; - } - /* istanbul ignore next */ - return jsValue; -} -exports.convertAJSONDerivedJavaScriptValueToAnInfraValue = convertAJSONDerivedJavaScriptValueToAnInfraValue; -//# sourceMappingURL=JSON.js.map - -/***/ }), - -/***/ 524: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents a cache for storing order between equal objects. - * - * This cache is used when an algorithm compares two objects and finds them to - * be equal but still needs to establish an order between those two objects. - * When two such objects `a` and `b` are passed to the `check` method, a random - * number is generated with `Math.random()`. If the random number is less than - * `0.5` it is assumed that `a < b` otherwise `a > b`. The random number along - * with `a` and `b` is stored in the cache, so that subsequent checks result - * in the same consistent result. - * - * The cache has a size limit which is defined on initialization. - */ -class CompareCache { - /** - * Initializes a new instance of `CompareCache`. - * - * @param limit - maximum number of items to keep in the cache. When the limit - * is exceeded the first item is removed from the cache. - */ - constructor(limit = 1000) { - this._items = new Map(); - this._limit = limit; - } - /** - * Compares and caches the given objects. Returns `true` if `objA < objB` and - * `false` otherwise. - * - * @param objA - an item to compare - * @param objB - an item to compare - */ - check(objA, objB) { - if (this._items.get(objA) === objB) - return true; - else if (this._items.get(objB) === objA) - return false; - const result = (Math.random() < 0.5); - if (result) { - this._items.set(objA, objB); - } - else { - this._items.set(objB, objA); - } - if (this._items.size > this._limit) { - const it = this._items.keys().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - return result; + finally { if (e) throw e.error; } } -} -exports.CompareCache = CompareCache; -//# sourceMappingURL=CompareCache.js.map - -/***/ }), - -/***/ 533: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; -var __importDefault = (this && this.__importDefault) || function (mod) { - return (mod && mod.__esModule) ? mod : { "default": mod }; + return ar; }; Object.defineProperty(exports, "__esModule", { value: true }); -const core = __importStar(__webpack_require__(470)); -const io = __importStar(__webpack_require__(1)); -const fs = __importStar(__webpack_require__(747)); -const os = __importStar(__webpack_require__(87)); -const path = __importStar(__webpack_require__(622)); -const httpm = __importStar(__webpack_require__(539)); -const semver = __importStar(__webpack_require__(280)); -const v4_1 = __importDefault(__webpack_require__(826)); -const exec_1 = __webpack_require__(986); -const assert_1 = __webpack_require__(357); -class HTTPError extends Error { - constructor(httpStatusCode) { - super(`Unexpected HTTP response: ${httpStatusCode}`); - this.httpStatusCode = httpStatusCode; - Object.setPrototypeOf(this, new.target.prototype); - } -} -exports.HTTPError = HTTPError; -const IS_WINDOWS = process.platform === 'win32'; -const userAgent = 'actions/tool-cache'; -// On load grab temp directory and cache directory and remove them from env (currently don't want to expose this) -let tempDirectory = process.env['RUNNER_TEMP'] || ''; -let cacheRoot = process.env['RUNNER_TOOL_CACHE'] || ''; -// If directories not found, place them in common temp locations -if (!tempDirectory || !cacheRoot) { - let baseLocation; - if (IS_WINDOWS) { - // On windows use the USERPROFILE env variable - baseLocation = process.env['USERPROFILE'] || 'C:\\'; - } - else { - if (process.platform === 'darwin') { - baseLocation = '/Users'; - } - else { - baseLocation = '/home'; - } - } - if (!tempDirectory) { - tempDirectory = path.join(baseLocation, 'actions', 'temp'); - } - if (!cacheRoot) { - cacheRoot = path.join(baseLocation, 'actions', 'cache'); - } -} -/** - * Download a tool from an url and stream it into a file - * - * @param url url of tool to download - * @param dest path to download tool - * @returns path to downloaded tool - */ -function downloadTool(url, dest) { - return __awaiter(this, void 0, void 0, function* () { - // Wrap in a promise so that we can resolve from within stream callbacks - return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { - try { - const http = new httpm.HttpClient(userAgent, [], { - allowRetries: true, - maxRetries: 3 - }); - dest = dest || path.join(tempDirectory, v4_1.default()); - yield io.mkdirP(path.dirname(dest)); - core.debug(`Downloading ${url}`); - core.debug(`Downloading ${dest}`); - if (fs.existsSync(dest)) { - throw new Error(`Destination file path ${dest} already exists`); - } - const response = yield http.get(url); - if (response.message.statusCode !== 200) { - const err = new HTTPError(response.message.statusCode); - core.debug(`Failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`); - throw err; - } - const file = fs.createWriteStream(dest); - file.on('open', () => __awaiter(this, void 0, void 0, function* () { - try { - const stream = response.message.pipe(file); - stream.on('close', () => { - core.debug('download complete'); - resolve(dest); - }); - } - catch (err) { - core.debug(`Failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`); - reject(err); - } - })); - file.on('error', err => { - file.end(); - reject(err); - }); - } - catch (err) { - reject(err); - } - })); - }); -} -exports.downloadTool = downloadTool; -/** - * Extract a .7z file - * - * @param file path to the .7z file - * @param dest destination directory. Optional. - * @param _7zPath path to 7zr.exe. Optional, for long path support. Most .7z archives do not have this - * problem. If your .7z archive contains very long paths, you can pass the path to 7zr.exe which will - * gracefully handle long paths. By default 7zdec.exe is used because it is a very small program and is - * bundled with the tool lib. However it does not support long paths. 7zr.exe is the reduced command line - * interface, it is smaller than the full command line interface, and it does support long paths. At the - * time of this writing, it is freely available from the LZMA SDK that is available on the 7zip website. - * Be sure to check the current license agreement. If 7zr.exe is bundled with your action, then the path - * to 7zr.exe can be pass to this function. - * @returns path to the destination directory - */ -function extract7z(file, dest, _7zPath) { - return __awaiter(this, void 0, void 0, function* () { - assert_1.ok(IS_WINDOWS, 'extract7z() not supported on current OS'); - assert_1.ok(file, 'parameter "file" is required'); - dest = yield _createExtractFolder(dest); - const originalCwd = process.cwd(); - process.chdir(dest); - if (_7zPath) { - try { - const args = [ - 'x', - '-bb1', - '-bd', - '-sccUTF-8', - file - ]; - const options = { - silent: true - }; - yield exec_1.exec(`"${_7zPath}"`, args, options); - } - finally { - process.chdir(originalCwd); - } - } - else { - const escapedScript = path - .join(__dirname, '..', 'scripts', 'Invoke-7zdec.ps1') - .replace(/'/g, "''") - .replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines - const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, ''); - const escapedTarget = dest.replace(/'/g, "''").replace(/"|\n|\r/g, ''); - const command = `& '${escapedScript}' -Source '${escapedFile}' -Target '${escapedTarget}'`; - const args = [ - '-NoLogo', - '-Sta', - '-NoProfile', - '-NonInteractive', - '-ExecutionPolicy', - 'Unrestricted', - '-Command', - command - ]; - const options = { - silent: true - }; - try { - const powershellPath = yield io.which('powershell', true); - yield exec_1.exec(`"${powershellPath}"`, args, options); - } - finally { - process.chdir(originalCwd); - } - } - return dest; - }); -} -exports.extract7z = extract7z; -/** - * Extract a compressed tar archive - * - * @param file path to the tar - * @param dest destination directory. Optional. - * @param flags flags for the tar command to use for extraction. Defaults to 'xz' (extracting gzipped tars). Optional. - * @returns path to the destination directory - */ -function extractTar(file, dest, flags = 'xz') { - return __awaiter(this, void 0, void 0, function* () { - if (!file) { - throw new Error("parameter 'file' is required"); - } - // Create dest - dest = yield _createExtractFolder(dest); - // Determine whether GNU tar - let versionOutput = ''; - yield exec_1.exec('tar --version', [], { - ignoreReturnCode: true, - listeners: { - stdout: (data) => (versionOutput += data.toString()), - stderr: (data) => (versionOutput += data.toString()) - } - }); - const isGnuTar = versionOutput.toUpperCase().includes('GNU TAR'); - // Initialize args - const args = [flags]; - let destArg = dest; - let fileArg = file; - if (IS_WINDOWS && isGnuTar) { - args.push('--force-local'); - destArg = dest.replace(/\\/g, '/'); - // Technically only the dest needs to have `/` but for aesthetic consistency - // convert slashes in the file arg too. - fileArg = file.replace(/\\/g, '/'); - } - if (isGnuTar) { - // Suppress warnings when using GNU tar to extract archives created by BSD tar - args.push('--warning=no-unknown-keyword'); - } - args.push('-C', destArg, '-f', fileArg); - yield exec_1.exec(`tar`, args); - return dest; - }); -} -exports.extractTar = extractTar; -/** - * Extract a zip - * - * @param file path to the zip - * @param dest destination directory. Optional. - * @returns path to the destination directory - */ -function extractZip(file, dest) { - return __awaiter(this, void 0, void 0, function* () { - if (!file) { - throw new Error("parameter 'file' is required"); - } - dest = yield _createExtractFolder(dest); - if (IS_WINDOWS) { - yield extractZipWin(file, dest); - } - else { - yield extractZipNix(file, dest); - } - return dest; - }); -} -exports.extractZip = extractZip; -function extractZipWin(file, dest) { - return __awaiter(this, void 0, void 0, function* () { - // build the powershell command - const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines - const escapedDest = dest.replace(/'/g, "''").replace(/"|\n|\r/g, ''); - const command = `$ErrorActionPreference = 'Stop' ; try { Add-Type -AssemblyName System.IO.Compression.FileSystem } catch { } ; [System.IO.Compression.ZipFile]::ExtractToDirectory('${escapedFile}', '${escapedDest}')`; - // run powershell - const powershellPath = yield io.which('powershell'); - const args = [ - '-NoLogo', - '-Sta', - '-NoProfile', - '-NonInteractive', - '-ExecutionPolicy', - 'Unrestricted', - '-Command', - command - ]; - yield exec_1.exec(`"${powershellPath}"`, args); - }); -} -function extractZipNix(file, dest) { - return __awaiter(this, void 0, void 0, function* () { - const unzipPath = yield io.which('unzip'); - yield exec_1.exec(`"${unzipPath}"`, [file], { cwd: dest }); - }); -} -/** - * Caches a directory and installs it into the tool cacheDir - * - * @param sourceDir the directory to cache into tools - * @param tool tool name - * @param version version of the tool. semver format - * @param arch architecture of the tool. Optional. Defaults to machine architecture - */ -function cacheDir(sourceDir, tool, version, arch) { - return __awaiter(this, void 0, void 0, function* () { - version = semver.clean(version) || version; - arch = arch || os.arch(); - core.debug(`Caching tool ${tool} ${version} ${arch}`); - core.debug(`source dir: ${sourceDir}`); - if (!fs.statSync(sourceDir).isDirectory()) { - throw new Error('sourceDir is not a directory'); - } - // Create the tool dir - const destPath = yield _createToolPath(tool, version, arch); - // copy each child item. do not move. move can fail on Windows - // due to anti-virus software having an open handle on a file. - for (const itemName of fs.readdirSync(sourceDir)) { - const s = path.join(sourceDir, itemName); - yield io.cp(s, destPath, { recursive: true }); - } - // write .complete - _completeToolPath(tool, version, arch); - return destPath; - }); -} -exports.cacheDir = cacheDir; -/** - * Caches a downloaded file (GUID) and installs it - * into the tool cache with a given targetName - * - * @param sourceFile the file to cache into tools. Typically a result of downloadTool which is a guid. - * @param targetFile the name of the file name in the tools directory - * @param tool tool name - * @param version version of the tool. semver format - * @param arch architecture of the tool. Optional. Defaults to machine architecture - */ -function cacheFile(sourceFile, targetFile, tool, version, arch) { - return __awaiter(this, void 0, void 0, function* () { - version = semver.clean(version) || version; - arch = arch || os.arch(); - core.debug(`Caching tool ${tool} ${version} ${arch}`); - core.debug(`source file: ${sourceFile}`); - if (!fs.statSync(sourceFile).isFile()) { - throw new Error('sourceFile is not a file'); - } - // create the tool dir - const destFolder = yield _createToolPath(tool, version, arch); - // copy instead of move. move can fail on Windows due to - // anti-virus software having an open handle on a file. - const destPath = path.join(destFolder, targetFile); - core.debug(`destination file ${destPath}`); - yield io.cp(sourceFile, destPath); - // write .complete - _completeToolPath(tool, version, arch); - return destFolder; - }); -} -exports.cacheFile = cacheFile; -/** - * Finds the path to a tool version in the local installed tool cache - * - * @param toolName name of the tool - * @param versionSpec version of the tool - * @param arch optional arch. defaults to arch of computer - */ -function find(toolName, versionSpec, arch) { - if (!toolName) { - throw new Error('toolName parameter is required'); - } - if (!versionSpec) { - throw new Error('versionSpec parameter is required'); - } - arch = arch || os.arch(); - // attempt to resolve an explicit version - if (!_isExplicitVersion(versionSpec)) { - const localVersions = findAllVersions(toolName, arch); - const match = _evaluateVersions(localVersions, versionSpec); - versionSpec = match; - } - // check for the explicit version in the cache - let toolPath = ''; - if (versionSpec) { - versionSpec = semver.clean(versionSpec) || ''; - const cachePath = path.join(cacheRoot, toolName, versionSpec, arch); - core.debug(`checking cache: ${cachePath}`); - if (fs.existsSync(cachePath) && fs.existsSync(`${cachePath}.complete`)) { - core.debug(`Found tool in cache ${toolName} ${versionSpec} ${arch}`); - toolPath = cachePath; - } - else { - core.debug('not found'); - } - } - return toolPath; -} -exports.find = find; -/** - * Finds the paths to all versions of a tool that are installed in the local tool cache - * - * @param toolName name of the tool - * @param arch optional arch. defaults to arch of computer - */ -function findAllVersions(toolName, arch) { - const versions = []; - arch = arch || os.arch(); - const toolPath = path.join(cacheRoot, toolName); - if (fs.existsSync(toolPath)) { - const children = fs.readdirSync(toolPath); - for (const child of children) { - if (_isExplicitVersion(child)) { - const fullPath = path.join(toolPath, child, arch || ''); - if (fs.existsSync(fullPath) && fs.existsSync(`${fullPath}.complete`)) { - versions.push(child); - } - } - } - } - return versions; -} -exports.findAllVersions = findAllVersions; -function _createExtractFolder(dest) { - return __awaiter(this, void 0, void 0, function* () { - if (!dest) { - // create a temp dir - dest = path.join(tempDirectory, v4_1.default()); - } - yield io.mkdirP(dest); - return dest; - }); -} -function _createToolPath(tool, version, arch) { - return __awaiter(this, void 0, void 0, function* () { - const folderPath = path.join(cacheRoot, tool, semver.clean(version) || version, arch || ''); - core.debug(`destination ${folderPath}`); - const markerPath = `${folderPath}.complete`; - yield io.rmRF(folderPath); - yield io.rmRF(markerPath); - yield io.mkdirP(folderPath); - return folderPath; - }); -} -function _completeToolPath(tool, version, arch) { - const folderPath = path.join(cacheRoot, tool, semver.clean(version) || version, arch || ''); - const markerPath = `${folderPath}.complete`; - fs.writeFileSync(markerPath, ''); - core.debug('finished caching tool'); -} -function _isExplicitVersion(versionSpec) { - const c = semver.clean(versionSpec) || ''; - core.debug(`isExplicit: ${c}`); - const valid = semver.valid(c) != null; - core.debug(`explicit? ${valid}`); - return valid; -} -function _evaluateVersions(versions, versionSpec) { - let version = ''; - core.debug(`evaluating ${versions.length} versions`); - versions = versions.sort((a, b) => { - if (semver.gt(a, b)) { - return 1; - } - return -1; - }); - for (let i = versions.length - 1; i >= 0; i--) { - const potential = versions[i]; - const satisfied = semver.satisfies(potential, versionSpec); - if (satisfied) { - version = potential; - break; - } - } - if (version) { - core.debug(`matched: ${version}`); - } - else { - core.debug('match not found'); - } - return version; -} -//# sourceMappingURL=tool-cache.js.map - -/***/ }), - -/***/ 535: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -var XMLBuilderImpl_1 = __webpack_require__(595); -exports.XMLBuilderImpl = XMLBuilderImpl_1.XMLBuilderImpl; -var XMLBuilderCBImpl_1 = __webpack_require__(551); -exports.XMLBuilderCBImpl = XMLBuilderCBImpl_1.XMLBuilderCBImpl; -//# sourceMappingURL=index.js.map - -/***/ }), - -/***/ 537: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents an abstract range with a start and end boundary point. - */ -class AbstractRangeImpl { - get _startNode() { return this._start[0]; } - get _startOffset() { return this._start[1]; } - get _endNode() { return this._end[0]; } - get _endOffset() { return this._end[1]; } - get _collapsed() { - return (this._start[0] === this._end[0] && - this._start[1] === this._end[1]); - } - /** @inheritdoc */ - get startContainer() { return this._startNode; } - /** @inheritdoc */ - get startOffset() { return this._startOffset; } - /** @inheritdoc */ - get endContainer() { return this._endNode; } - /** @inheritdoc */ - get endOffset() { return this._endOffset; } - /** @inheritdoc */ - get collapsed() { return this._collapsed; } -} -exports.AbstractRangeImpl = AbstractRangeImpl; -//# sourceMappingURL=AbstractRangeImpl.js.map - -/***/ }), - -/***/ 539: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const url = __webpack_require__(835); -const http = __webpack_require__(605); -const https = __webpack_require__(211); -const pm = __webpack_require__(950); -let tunnel; -var HttpCodes; -(function (HttpCodes) { - HttpCodes[HttpCodes["OK"] = 200] = "OK"; - HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; - HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; - HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; - HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; - HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; - HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; - HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; - HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; - HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; - HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; - HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; - HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; - HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; - HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; - HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; - HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; - HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; - HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; - HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; - HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; - HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; - HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; - HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; - HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; - HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; - HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; -})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); -var Headers; -(function (Headers) { - Headers["Accept"] = "accept"; - Headers["ContentType"] = "content-type"; -})(Headers = exports.Headers || (exports.Headers = {})); -var MediaTypes; -(function (MediaTypes) { - MediaTypes["ApplicationJson"] = "application/json"; -})(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {})); -/** - * Returns the proxy URL, depending upon the supplied url and proxy environment variables. - * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com - */ -function getProxyUrl(serverUrl) { - let proxyUrl = pm.getProxyUrl(url.parse(serverUrl)); - return proxyUrl ? proxyUrl.href : ''; -} -exports.getProxyUrl = getProxyUrl; -const HttpRedirectCodes = [ - HttpCodes.MovedPermanently, - HttpCodes.ResourceMoved, - HttpCodes.SeeOther, - HttpCodes.TemporaryRedirect, - HttpCodes.PermanentRedirect -]; -const HttpResponseRetryCodes = [ - HttpCodes.BadGateway, - HttpCodes.ServiceUnavailable, - HttpCodes.GatewayTimeout -]; -const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; -const ExponentialBackoffCeiling = 10; -const ExponentialBackoffTimeSlice = 5; -class HttpClientResponse { - constructor(message) { - this.message = message; - } - readBody() { - return new Promise(async (resolve, reject) => { - let output = Buffer.alloc(0); - this.message.on('data', (chunk) => { - output = Buffer.concat([output, chunk]); - }); - this.message.on('end', () => { - resolve(output.toString()); - }); - }); - } -} -exports.HttpClientResponse = HttpClientResponse; -function isHttps(requestUrl) { - let parsedUrl = url.parse(requestUrl); - return parsedUrl.protocol === 'https:'; -} -exports.isHttps = isHttps; -class HttpClient { - constructor(userAgent, handlers, requestOptions) { - this._ignoreSslError = false; - this._allowRedirects = true; - this._allowRedirectDowngrade = false; - this._maxRedirects = 50; - this._allowRetries = false; - this._maxRetries = 1; - this._keepAlive = false; - this._disposed = false; - this.userAgent = userAgent; - this.handlers = handlers || []; - this.requestOptions = requestOptions; - if (requestOptions) { - if (requestOptions.ignoreSslError != null) { - this._ignoreSslError = requestOptions.ignoreSslError; - } - this._socketTimeout = requestOptions.socketTimeout; - if (requestOptions.allowRedirects != null) { - this._allowRedirects = requestOptions.allowRedirects; - } - if (requestOptions.allowRedirectDowngrade != null) { - this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; - } - if (requestOptions.maxRedirects != null) { - this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); - } - if (requestOptions.keepAlive != null) { - this._keepAlive = requestOptions.keepAlive; - } - if (requestOptions.allowRetries != null) { - this._allowRetries = requestOptions.allowRetries; - } - if (requestOptions.maxRetries != null) { - this._maxRetries = requestOptions.maxRetries; - } - } - } - options(requestUrl, additionalHeaders) { - return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); - } - get(requestUrl, additionalHeaders) { - return this.request('GET', requestUrl, null, additionalHeaders || {}); - } - del(requestUrl, additionalHeaders) { - return this.request('DELETE', requestUrl, null, additionalHeaders || {}); - } - post(requestUrl, data, additionalHeaders) { - return this.request('POST', requestUrl, data, additionalHeaders || {}); - } - patch(requestUrl, data, additionalHeaders) { - return this.request('PATCH', requestUrl, data, additionalHeaders || {}); - } - put(requestUrl, data, additionalHeaders) { - return this.request('PUT', requestUrl, data, additionalHeaders || {}); - } - head(requestUrl, additionalHeaders) { - return this.request('HEAD', requestUrl, null, additionalHeaders || {}); - } - sendStream(verb, requestUrl, stream, additionalHeaders) { - return this.request(verb, requestUrl, stream, additionalHeaders); - } - /** - * Gets a typed object from an endpoint - * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise - */ - async getJson(requestUrl, additionalHeaders = {}) { - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - let res = await this.get(requestUrl, additionalHeaders); - return this._processResponse(res, this.requestOptions); - } - async postJson(requestUrl, obj, additionalHeaders = {}) { - let data = JSON.stringify(obj, null, 2); - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); - let res = await this.post(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - } - async putJson(requestUrl, obj, additionalHeaders = {}) { - let data = JSON.stringify(obj, null, 2); - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); - let res = await this.put(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - } - async patchJson(requestUrl, obj, additionalHeaders = {}) { - let data = JSON.stringify(obj, null, 2); - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); - let res = await this.patch(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - } - /** - * Makes a raw http request. - * All other methods such as get, post, patch, and request ultimately call this. - * Prefer get, del, post and patch - */ - async request(verb, requestUrl, data, headers) { - if (this._disposed) { - throw new Error('Client has already been disposed.'); - } - let parsedUrl = url.parse(requestUrl); - let info = this._prepareRequest(verb, parsedUrl, headers); - // Only perform retries on reads since writes may not be idempotent. - let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1 - ? this._maxRetries + 1 - : 1; - let numTries = 0; - let response; - while (numTries < maxTries) { - response = await this.requestRaw(info, data); - // Check if it's an authentication challenge - if (response && - response.message && - response.message.statusCode === HttpCodes.Unauthorized) { - let authenticationHandler; - for (let i = 0; i < this.handlers.length; i++) { - if (this.handlers[i].canHandleAuthentication(response)) { - authenticationHandler = this.handlers[i]; - break; - } - } - if (authenticationHandler) { - return authenticationHandler.handleAuthentication(this, info, data); - } - else { - // We have received an unauthorized response but have no handlers to handle it. - // Let the response return to the caller. - return response; - } - } - let redirectsRemaining = this._maxRedirects; - while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 && - this._allowRedirects && - redirectsRemaining > 0) { - const redirectUrl = response.message.headers['location']; - if (!redirectUrl) { - // if there's no location to redirect to, we won't - break; - } - let parsedRedirectUrl = url.parse(redirectUrl); - if (parsedUrl.protocol == 'https:' && - parsedUrl.protocol != parsedRedirectUrl.protocol && - !this._allowRedirectDowngrade) { - throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); - } - // we need to finish reading the response before reassigning response - // which will leak the open socket. - await response.readBody(); - // strip authorization header if redirected to a different hostname - if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { - for (let header in headers) { - // header names are case insensitive - if (header.toLowerCase() === 'authorization') { - delete headers[header]; - } - } - } - // let's make the request with the new redirectUrl - info = this._prepareRequest(verb, parsedRedirectUrl, headers); - response = await this.requestRaw(info, data); - redirectsRemaining--; - } - if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) { - // If not a retry code, return immediately instead of retrying - return response; - } - numTries += 1; - if (numTries < maxTries) { - await response.readBody(); - await this._performExponentialBackoff(numTries); - } - } - return response; - } - /** - * Needs to be called if keepAlive is set to true in request options. - */ - dispose() { - if (this._agent) { - this._agent.destroy(); - } - this._disposed = true; - } - /** - * Raw request. - * @param info - * @param data - */ - requestRaw(info, data) { - return new Promise((resolve, reject) => { - let callbackForResult = function (err, res) { - if (err) { - reject(err); - } - resolve(res); - }; - this.requestRawWithCallback(info, data, callbackForResult); - }); - } - /** - * Raw request with callback. - * @param info - * @param data - * @param onResult - */ - requestRawWithCallback(info, data, onResult) { - let socket; - if (typeof data === 'string') { - info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); - } - let callbackCalled = false; - let handleResult = (err, res) => { - if (!callbackCalled) { - callbackCalled = true; - onResult(err, res); - } - }; - let req = info.httpModule.request(info.options, (msg) => { - let res = new HttpClientResponse(msg); - handleResult(null, res); - }); - req.on('socket', sock => { - socket = sock; - }); - // If we ever get disconnected, we want the socket to timeout eventually - req.setTimeout(this._socketTimeout || 3 * 60000, () => { - if (socket) { - socket.end(); - } - handleResult(new Error('Request timeout: ' + info.options.path), null); - }); - req.on('error', function (err) { - // err has statusCode property - // res should have headers - handleResult(err, null); - }); - if (data && typeof data === 'string') { - req.write(data, 'utf8'); - } - if (data && typeof data !== 'string') { - data.on('close', function () { - req.end(); - }); - data.pipe(req); - } - else { - req.end(); - } - } - /** - * Gets an http agent. This function is useful when you need an http agent that handles - * routing through a proxy server - depending upon the url and proxy environment variables. - * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com - */ - getAgent(serverUrl) { - let parsedUrl = url.parse(serverUrl); - return this._getAgent(parsedUrl); - } - _prepareRequest(method, requestUrl, headers) { - const info = {}; - info.parsedUrl = requestUrl; - const usingSsl = info.parsedUrl.protocol === 'https:'; - info.httpModule = usingSsl ? https : http; - const defaultPort = usingSsl ? 443 : 80; - info.options = {}; - info.options.host = info.parsedUrl.hostname; - info.options.port = info.parsedUrl.port - ? parseInt(info.parsedUrl.port) - : defaultPort; - info.options.path = - (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); - info.options.method = method; - info.options.headers = this._mergeHeaders(headers); - if (this.userAgent != null) { - info.options.headers['user-agent'] = this.userAgent; - } - info.options.agent = this._getAgent(info.parsedUrl); - // gives handlers an opportunity to participate - if (this.handlers) { - this.handlers.forEach(handler => { - handler.prepareRequest(info.options); - }); - } - return info; - } - _mergeHeaders(headers) { - const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); - if (this.requestOptions && this.requestOptions.headers) { - return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers)); - } - return lowercaseKeys(headers || {}); - } - _getExistingOrDefaultHeader(additionalHeaders, header, _default) { - const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); - let clientHeader; - if (this.requestOptions && this.requestOptions.headers) { - clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; - } - return additionalHeaders[header] || clientHeader || _default; - } - _getAgent(parsedUrl) { - let agent; - let proxyUrl = pm.getProxyUrl(parsedUrl); - let useProxy = proxyUrl && proxyUrl.hostname; - if (this._keepAlive && useProxy) { - agent = this._proxyAgent; - } - if (this._keepAlive && !useProxy) { - agent = this._agent; - } - // if agent is already assigned use that agent. - if (!!agent) { - return agent; - } - const usingSsl = parsedUrl.protocol === 'https:'; - let maxSockets = 100; - if (!!this.requestOptions) { - maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; - } - if (useProxy) { - // If using proxy, need tunnel - if (!tunnel) { - tunnel = __webpack_require__(413); - } - const agentOptions = { - maxSockets: maxSockets, - keepAlive: this._keepAlive, - proxy: { - proxyAuth: proxyUrl.auth, - host: proxyUrl.hostname, - port: proxyUrl.port - } - }; - let tunnelAgent; - const overHttps = proxyUrl.protocol === 'https:'; - if (usingSsl) { - tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; - } - else { - tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; - } - agent = tunnelAgent(agentOptions); - this._proxyAgent = agent; - } - // if reusing agent across request and tunneling agent isn't assigned create a new agent - if (this._keepAlive && !agent) { - const options = { keepAlive: this._keepAlive, maxSockets: maxSockets }; - agent = usingSsl ? new https.Agent(options) : new http.Agent(options); - this._agent = agent; - } - // if not using private agent and tunnel agent isn't setup then use global agent - if (!agent) { - agent = usingSsl ? https.globalAgent : http.globalAgent; - } - if (usingSsl && this._ignoreSslError) { - // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process - // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options - // we have to cast it to any and change it directly - agent.options = Object.assign(agent.options || {}, { - rejectUnauthorized: false - }); - } - return agent; - } - _performExponentialBackoff(retryNumber) { - retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); - const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); - return new Promise(resolve => setTimeout(() => resolve(), ms)); - } - static dateTimeDeserializer(key, value) { - if (typeof value === 'string') { - let a = new Date(value); - if (!isNaN(a.valueOf())) { - return a; - } - } - return value; - } - async _processResponse(res, options) { - return new Promise(async (resolve, reject) => { - const statusCode = res.message.statusCode; - const response = { - statusCode: statusCode, - result: null, - headers: {} - }; - // not found leads to null obj returned - if (statusCode == HttpCodes.NotFound) { - resolve(response); - } - let obj; - let contents; - // get the result from the body - try { - contents = await res.readBody(); - if (contents && contents.length > 0) { - if (options && options.deserializeDates) { - obj = JSON.parse(contents, HttpClient.dateTimeDeserializer); - } - else { - obj = JSON.parse(contents); - } - response.result = obj; - } - response.headers = res.message.headers; - } - catch (err) { - // Invalid resource (contents not json); leaving result obj null - } - // note that 3xx redirects are handled by the http layer. - if (statusCode > 299) { - let msg; - // if exception/error in body, attempt to get better error - if (obj && obj.message) { - msg = obj.message; - } - else if (contents && contents.length > 0) { - // it may be the case that the exception is in the body message as string - msg = contents; - } - else { - msg = 'Failed request: (' + statusCode + ')'; - } - let err = new Error(msg); - // attach statusCode and body obj (if available) to the error object - err['statusCode'] = statusCode; - if (response.result) { - err['result'] = response.result; - } - reject(err); - } - else { - resolve(response); - } - }); - } -} -exports.HttpClient = HttpClient; - - -/***/ }), - -/***/ 541: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(113); -const util_1 = __webpack_require__(918); -const infra_1 = __webpack_require__(23); -const CreateAlgorithm_1 = __webpack_require__(86); -const OrderedSetAlgorithm_1 = __webpack_require__(146); -const DOMAlgorithm_1 = __webpack_require__(304); -const MutationAlgorithm_1 = __webpack_require__(479); -const ElementAlgorithm_1 = __webpack_require__(33); -/** - * Replaces the contents of the given node with a single text node. - * - * @param string - node contents - * @param parent - a node - */ -function node_stringReplaceAll(str, parent) { - /** - * 1. Let node be null. - * 2. If string is not the empty string, then set node to a new Text node - * whose data is string and node document is parent’s node document. - * 3. Replace all with node within parent. - */ - let node = null; - if (str !== '') { - node = CreateAlgorithm_1.create_text(parent._nodeDocument, str); - } - MutationAlgorithm_1.mutation_replaceAll(node, parent); -} -exports.node_stringReplaceAll = node_stringReplaceAll; -/** - * Clones a node. - * - * @param node - a node to clone - * @param document - the document to own the cloned node - * @param cloneChildrenFlag - whether to clone node's children - */ -function node_clone(node, document = null, cloneChildrenFlag = false) { - /** - * 1. If document is not given, let document be node’s node document. - */ - if (document === null) - document = node._nodeDocument; - let copy; - if (util_1.Guard.isElementNode(node)) { - /** - * 2. If node is an element, then: - * 2.1. Let copy be the result of creating an element, given document, - * node’s local name, node’s namespace, node’s namespace prefix, - * and node’s is value, with the synchronous custom elements flag unset. - * 2.2. For each attribute in node’s attribute list: - * 2.2.1. Let copyAttribute be a clone of attribute. - * 2.2.2. Append copyAttribute to copy. - */ - copy = ElementAlgorithm_1.element_createAnElement(document, node._localName, node._namespace, node._namespacePrefix, node._is, false); - for (const attribute of node._attributeList) { - const copyAttribute = node_clone(attribute, document); - ElementAlgorithm_1.element_append(copyAttribute, copy); - } - } - else { - /** - * 3. Otherwise, let copy be a node that implements the same interfaces as - * node, and fulfills these additional requirements, switching on node: - * - Document - * Set copy’s encoding, content type, URL, origin, type, and mode, to those - * of node. - * - DocumentType - * Set copy’s name, public ID, and system ID, to those of node. - * - Attr - * Set copy’s namespace, namespace prefix, local name, and value, to - * those of node. - * - Text - * - Comment - * Set copy’s data, to that of node. - * - ProcessingInstruction - * Set copy’s target and data to those of node. - * - Any other node - */ - if (util_1.Guard.isDocumentNode(node)) { - const doc = CreateAlgorithm_1.create_document(); - doc._encoding = node._encoding; - doc._contentType = node._contentType; - doc._URL = node._URL; - doc._origin = node._origin; - doc._type = node._type; - doc._mode = node._mode; - copy = doc; - } - else if (util_1.Guard.isDocumentTypeNode(node)) { - const doctype = CreateAlgorithm_1.create_documentType(document, node._name, node._publicId, node._systemId); - copy = doctype; - } - else if (util_1.Guard.isAttrNode(node)) { - const attr = CreateAlgorithm_1.create_attr(document, node.localName); - attr._namespace = node._namespace; - attr._namespacePrefix = node._namespacePrefix; - attr._value = node._value; - copy = attr; - } - else if (util_1.Guard.isExclusiveTextNode(node)) { - copy = CreateAlgorithm_1.create_text(document, node._data); - } - else if (util_1.Guard.isCDATASectionNode(node)) { - copy = CreateAlgorithm_1.create_cdataSection(document, node._data); - } - else if (util_1.Guard.isCommentNode(node)) { - copy = CreateAlgorithm_1.create_comment(document, node._data); - } - else if (util_1.Guard.isProcessingInstructionNode(node)) { - copy = CreateAlgorithm_1.create_processingInstruction(document, node._target, node._data); - } - else if (util_1.Guard.isDocumentFragmentNode(node)) { - copy = CreateAlgorithm_1.create_documentFragment(document); - } - else { - copy = Object.create(node); - } - } - /** - * 4. Set copy’s node document and document to copy, if copy is a document, - * and set copy’s node document to document otherwise. - */ - if (util_1.Guard.isDocumentNode(copy)) { - copy._nodeDocument = copy; - document = copy; - } - else { - copy._nodeDocument = document; - } - /** - * 5. Run any cloning steps defined for node in other applicable - * specifications and pass copy, node, document and the clone children flag - * if set, as parameters. - */ - if (dom_1.dom.features.steps) { - DOMAlgorithm_1.dom_runCloningSteps(copy, node, document, cloneChildrenFlag); - } - /** - * 6. If the clone children flag is set, clone all the children of node and - * append them to copy, with document as specified and the clone children - * flag being set. - */ - if (cloneChildrenFlag) { - for (const child of node._children) { - const childCopy = node_clone(child, document, true); - MutationAlgorithm_1.mutation_append(childCopy, copy); - } - } - /** - * 7. Return copy. - */ - return copy; -} -exports.node_clone = node_clone; -/** - * Determines if two nodes can be considered equal. - * - * @param a - node to compare - * @param b - node to compare - */ -function node_equals(a, b) { - /** - * 1. A and B’s nodeType attribute value is identical. - */ - if (a._nodeType !== b._nodeType) - return false; - /** - * 2. The following are also equal, depending on A: - * - DocumentType - * Its name, public ID, and system ID. - * - Element - * Its namespace, namespace prefix, local name, and its attribute list’s size. - * - Attr - * Its namespace, local name, and value. - * - ProcessingInstruction - * Its target and data. - * - Text - * - Comment - * Its data. - */ - if (util_1.Guard.isDocumentTypeNode(a) && util_1.Guard.isDocumentTypeNode(b)) { - if (a._name !== b._name || a._publicId !== b._publicId || - a._systemId !== b._systemId) - return false; - } - else if (util_1.Guard.isElementNode(a) && util_1.Guard.isElementNode(b)) { - if (a._namespace !== b._namespace || a._namespacePrefix !== b._namespacePrefix || - a._localName !== b._localName || - a._attributeList.length !== b._attributeList.length) - return false; - } - else if (util_1.Guard.isAttrNode(a) && util_1.Guard.isAttrNode(b)) { - if (a._namespace !== b._namespace || a._localName !== b._localName || - a._value !== b._value) - return false; - } - else if (util_1.Guard.isProcessingInstructionNode(a) && util_1.Guard.isProcessingInstructionNode(b)) { - if (a._target !== b._target || a._data !== b._data) - return false; - } - else if (util_1.Guard.isCharacterDataNode(a) && util_1.Guard.isCharacterDataNode(b)) { - if (a._data !== b._data) - return false; - } - /** - * 3. If A is an element, each attribute in its attribute list has an attribute - * that equals an attribute in B’s attribute list. - */ - if (util_1.Guard.isElementNode(a) && util_1.Guard.isElementNode(b)) { - const attrMap = {}; - for (const attrA of a._attributeList) { - attrMap[attrA._localName] = attrA; - } - for (const attrB of b._attributeList) { - const attrA = attrMap[attrB._localName]; - if (!attrA) - return false; - if (!node_equals(attrA, attrB)) - return false; - } - } - /** - * 4. A and B have the same number of children. - * 5. Each child of A equals the child of B at the identical index. - */ - if (a._children.size !== b._children.size) - return false; - const itA = a._children[Symbol.iterator](); - const itB = b._children[Symbol.iterator](); - let resultA = itA.next(); - let resultB = itB.next(); - while (!resultA.done && !resultB.done) { - const child1 = resultA.value; - const child2 = resultB.value; - if (!node_equals(child1, child2)) - return false; - resultA = itA.next(); - resultB = itB.next(); - } - return true; -} -exports.node_equals = node_equals; -/** - * Returns a collection of elements with the given qualified name which are - * descendants of the given root node. - * See: https://dom.spec.whatwg.org/#concept-getelementsbytagname - * - * @param qualifiedName - qualified name - * @param root - root node - */ -function node_listOfElementsWithQualifiedName(qualifiedName, root) { - /** - * 1. If qualifiedName is "*" (U+002A), return a HTMLCollection rooted at - * root, whose filter matches only descendant elements. - * 2. Otherwise, if root’s node document is an HTML document, return a - * HTMLCollection rooted at root, whose filter matches the following - * descendant elements: - * 2.1. Whose namespace is the HTML namespace and whose qualified name is - * qualifiedName, in ASCII lowercase. - * 2.2. Whose namespace is not the HTML namespace and whose qualified name - * is qualifiedName. - * 3. Otherwise, return a HTMLCollection rooted at root, whose filter - * matches descendant elements whose qualified name is qualifiedName. - */ - if (qualifiedName === "*") { - return CreateAlgorithm_1.create_htmlCollection(root); - } - else if (root._nodeDocument._type === "html") { - return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { - if (ele._namespace === infra_1.namespace.HTML && - ele._qualifiedName === qualifiedName.toLowerCase()) { - return true; - } - else if (ele._namespace !== infra_1.namespace.HTML && - ele._qualifiedName === qualifiedName) { - return true; - } - else { - return false; - } - }); - } - else { - return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { - return (ele._qualifiedName === qualifiedName); - }); - } -} -exports.node_listOfElementsWithQualifiedName = node_listOfElementsWithQualifiedName; -/** - * Returns a collection of elements with the given namespace which are - * descendants of the given root node. - * See: https://dom.spec.whatwg.org/#concept-getelementsbytagnamens - * - * @param namespace - element namespace - * @param localName - local name - * @param root - root node - */ -function node_listOfElementsWithNamespace(namespace, localName, root) { - /** - * 1. If namespace is the empty string, set it to null. - * 2. If both namespace and localName are "*" (U+002A), return a - * HTMLCollection rooted at root, whose filter matches descendant elements. - * 3. Otherwise, if namespace is "*" (U+002A), return a HTMLCollection - * rooted at root, whose filter matches descendant elements whose local - * name is localName. - * 4. Otherwise, if localName is "*" (U+002A), return a HTMLCollection - * rooted at root, whose filter matches descendant elements whose - * namespace is namespace. - * 5. Otherwise, return a HTMLCollection rooted at root, whose filter - * matches descendant elements whose namespace is namespace and local - * name is localName. - */ - if (namespace === '') - namespace = null; - if (namespace === "*" && localName === "*") { - return CreateAlgorithm_1.create_htmlCollection(root); - } - else if (namespace === "*") { - return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { - return (ele._localName === localName); - }); - } - else if (localName === "*") { - return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { - return (ele._namespace === namespace); - }); - } - else { - return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { - return (ele._localName === localName && ele._namespace === namespace); - }); - } -} -exports.node_listOfElementsWithNamespace = node_listOfElementsWithNamespace; -/** - * Returns a collection of elements with the given class names which are - * descendants of the given root node. - * See: https://dom.spec.whatwg.org/#concept-getelementsbyclassname - * - * @param namespace - element namespace - * @param localName - local name - * @param root - root node - */ -function node_listOfElementsWithClassNames(classNames, root) { - /** - * 1. Let classes be the result of running the ordered set parser - * on classNames. - * 2. If classes is the empty set, return an empty HTMLCollection. - * 3. Return a HTMLCollection rooted at root, whose filter matches - * descendant elements that have all their classes in classes. - * The comparisons for the classes must be done in an ASCII case-insensitive - * manner if root’s node document’s mode is "quirks", and in a - * case-sensitive manner otherwise. - */ - const classes = OrderedSetAlgorithm_1.orderedSet_parse(classNames); - if (classes.size === 0) { - return CreateAlgorithm_1.create_htmlCollection(root, () => false); - } - const caseSensitive = (root._nodeDocument._mode !== "quirks"); - return CreateAlgorithm_1.create_htmlCollection(root, function (ele) { - const eleClasses = ele.classList; - return OrderedSetAlgorithm_1.orderedSet_contains(eleClasses._tokenSet, classes, caseSensitive); - }); -} -exports.node_listOfElementsWithClassNames = node_listOfElementsWithClassNames; -/** - * Searches for a namespace prefix associated with the given namespace - * starting from the given element through its ancestors. - * - * @param element - an element node to start searching at - * @param namespace - namespace to search for - */ -function node_locateANamespacePrefix(element, namespace) { - /** - * 1. If element’s namespace is namespace and its namespace prefix is not - * null, then return its namespace prefix. - */ - if (element._namespace === namespace && element._namespacePrefix !== null) { - return element._namespacePrefix; - } - /** - * 2. If element has an attribute whose namespace prefix is "xmlns" and - * value is namespace, then return element’s first such attribute’s - * local name. - */ - for (let i = 0; i < element._attributeList.length; i++) { - const attr = element._attributeList[i]; - if (attr._namespacePrefix === "xmlns" && attr._value === namespace) { - return attr._localName; - } - } - /** - * 3. If element’s parent element is not null, then return the result of - * running locate a namespace prefix on that element using namespace. - */ - if (element._parent && util_1.Guard.isElementNode(element._parent)) { - return node_locateANamespacePrefix(element._parent, namespace); - } - /** - * 4. Return null. - */ - return null; -} -exports.node_locateANamespacePrefix = node_locateANamespacePrefix; -/** - * Searches for a namespace associated with the given namespace prefix - * starting from the given node through its ancestors. - * - * @param node - a node to start searching at - * @param prefix - namespace prefix to search for - */ -function node_locateANamespace(node, prefix) { - if (util_1.Guard.isElementNode(node)) { - /** - * 1. If its namespace is not null and its namespace prefix is prefix, - * then return namespace. - */ - if (node._namespace !== null && node._namespacePrefix === prefix) { - return node._namespace; - } - /** - * 2. If it has an attribute whose namespace is the XMLNS namespace, - * namespace prefix is "xmlns", and local name is prefix, or if prefix - * is null and it has an attribute whose namespace is the XMLNS namespace, - * namespace prefix is null, and local name is "xmlns", then return its - * value if it is not the empty string, and null otherwise. - */ - for (let i = 0; i < node._attributeList.length; i++) { - const attr = node._attributeList[i]; - if (attr._namespace === infra_1.namespace.XMLNS && - attr._namespacePrefix === "xmlns" && - attr._localName === prefix) { - return attr._value || null; - } - if (prefix === null && attr._namespace === infra_1.namespace.XMLNS && - attr._namespacePrefix === null && attr._localName === "xmlns") { - return attr._value || null; - } - } - /** - * 3. If its parent element is null, then return null. - */ - if (node.parentElement === null) - return null; - /** - * 4. Return the result of running locate a namespace on its parent - * element using prefix. - */ - return node_locateANamespace(node.parentElement, prefix); - } - else if (util_1.Guard.isDocumentNode(node)) { - /** - * 1. If its document element is null, then return null. - * 2. Return the result of running locate a namespace on its document - * element using prefix. - */ - if (node.documentElement === null) - return null; - return node_locateANamespace(node.documentElement, prefix); - } - else if (util_1.Guard.isDocumentTypeNode(node) || util_1.Guard.isDocumentFragmentNode(node)) { - return null; - } - else if (util_1.Guard.isAttrNode(node)) { - /** - * 1. If its element is null, then return null. - * 2. Return the result of running locate a namespace on its element - * using prefix. - */ - if (node._element === null) - return null; - return node_locateANamespace(node._element, prefix); - } - else { - /** - * 1. If its parent element is null, then return null. - * 2. Return the result of running locate a namespace on its parent - * element using prefix. - */ - if (!node._parent || !util_1.Guard.isElementNode(node._parent)) - return null; - return node_locateANamespace(node._parent, prefix); - } -} -exports.node_locateANamespace = node_locateANamespace; -//# sourceMappingURL=NodeAlgorithm.js.map - -/***/ }), - -/***/ 551: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(625); -const util_1 = __webpack_require__(592); -const __1 = __webpack_require__(255); -const algorithm_1 = __webpack_require__(163); -const infra_1 = __webpack_require__(23); -const NamespacePrefixMap_1 = __webpack_require__(392); -const LocalNameSet_1 = __webpack_require__(575); -const util_2 = __webpack_require__(918); -const XMLCBWriter_1 = __webpack_require__(190); -const JSONCBWriter_1 = __webpack_require__(781); -const events_1 = __webpack_require__(614); +var interfaces_1 = __webpack_require__(625); +var util_1 = __webpack_require__(592); +var BuilderFunctions_1 = __webpack_require__(961); +var algorithm_1 = __webpack_require__(163); +var infra_1 = __webpack_require__(23); +var NamespacePrefixMap_1 = __webpack_require__(392); +var LocalNameSet_1 = __webpack_require__(575); +var util_2 = __webpack_require__(918); +var XMLCBWriter_1 = __webpack_require__(190); +var JSONCBWriter_1 = __webpack_require__(781); +var YAMLCBWriter_1 = __webpack_require__(497); +var events_1 = __webpack_require__(614); /** * Represents a readable XML document stream. */ -class XMLBuilderCBImpl extends events_1.EventEmitter { +var XMLBuilderCBImpl = /** @class */ (function (_super) { + __extends(XMLBuilderCBImpl, _super); /** * Initializes a new instance of `XMLStream`. * @@ -21463,41 +25683,53 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { * * @returns XML stream */ - constructor(options, fragment = false) { - super(); - this._hasDeclaration = false; - this._docTypeName = ""; - this._hasDocumentElement = false; - this._currentElementSerialized = false; - this._openTags = []; - this._ended = false; - this._fragment = fragment; + function XMLBuilderCBImpl(options, fragment) { + if (fragment === void 0) { fragment = false; } + var _this = _super.call(this) || this; + _this._hasDeclaration = false; + _this._docTypeName = ""; + _this._hasDocumentElement = false; + _this._currentElementSerialized = false; + _this._openTags = []; + _this._ended = false; + _this._fragment = fragment; // provide default options - this._options = util_1.applyDefaults(options || {}, interfaces_1.DefaultXMLBuilderCBOptions); - this._builderOptions = { - defaultNamespace: this._options.defaultNamespace, - namespaceAlias: this._options.namespaceAlias + _this._options = util_1.applyDefaults(options || {}, interfaces_1.DefaultXMLBuilderCBOptions); + _this._builderOptions = { + defaultNamespace: _this._options.defaultNamespace, + namespaceAlias: _this._options.namespaceAlias }; - this._writer = this._options.format === "xml" ? new XMLCBWriter_1.XMLCBWriter(this._options) : new JSONCBWriter_1.JSONCBWriter(this._options); + if (_this._options.format === "json") { + _this._writer = new JSONCBWriter_1.JSONCBWriter(_this._options); + } + else if (_this._options.format === "yaml") { + _this._writer = new YAMLCBWriter_1.YAMLCBWriter(_this._options); + } + else { + _this._writer = new XMLCBWriter_1.XMLCBWriter(_this._options); + } // automatically create listeners for callbacks passed via options - if (this._options.data !== undefined) { - this.on("data", this._options.data); + if (_this._options.data !== undefined) { + _this.on("data", _this._options.data); } - if (this._options.end !== undefined) { - this.on("end", this._options.end); + if (_this._options.end !== undefined) { + _this.on("end", _this._options.end); } - if (this._options.error !== undefined) { - this.on("error", this._options.error); + if (_this._options.error !== undefined) { + _this.on("error", _this._options.error); } - this._prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap(); - this._prefixMap.set("xml", infra_1.namespace.XML); - this._prefixIndex = { value: 1 }; + _this._prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap(); + _this._prefixMap.set("xml", infra_1.namespace.XML); + _this._prefixIndex = { value: 1 }; + _this._push(_this._writer.frontMatter()); + return _this; } /** @inheritdoc */ - ele(p1, p2, p3) { + XMLBuilderCBImpl.prototype.ele = function (p1, p2, p3) { + var e_1, _a; // parse if JS object or XML or JSON string - if (util_1.isObject(p1) || (util_1.isString(p1) && (/^\s*/g, '>') - .replace(/\r/g, ' '); + .replace(/>/g, '>'); } else { - for (let i = 0; i < node.data.length; i++) { - const c = node.data[i]; + for (var i = 0; i < node.data.length; i++) { + var c = node.data[i]; if (c === "&") markup += "&"; else if (c === "<") @@ -21612,13 +25853,14 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { } this._push(this._writer.text(markup)); return this; - } + }; /** @inheritdoc */ - ins(target, content = '') { + XMLBuilderCBImpl.prototype.ins = function (target, content) { + if (content === void 0) { content = ''; } this._serializeOpenTag(true); - let node; + var node; try { - node = __1.fragment(this._builderOptions).ins(target, content).first().node; + node = BuilderFunctions_1.fragment(this._builderOptions).ins(target, content).first().node; } catch (err) { /* istanbul ignore next */ @@ -21636,13 +25878,13 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { } this._push(this._writer.instruction(node.target, node.data)); return this; - } + }; /** @inheritdoc */ - dat(content) { + XMLBuilderCBImpl.prototype.dat = function (content) { this._serializeOpenTag(true); - let node; + var node; try { - node = __1.fragment(this._builderOptions).dat(content).first().node; + node = BuilderFunctions_1.fragment(this._builderOptions).dat(content).first().node; } catch (err) { this.emit("error", err); @@ -21650,9 +25892,10 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { } this._push(this._writer.cdata(node.data)); return this; - } + }; /** @inheritdoc */ - dec(options = { version: "1.0" }) { + XMLBuilderCBImpl.prototype.dec = function (options) { + if (options === void 0) { options = { version: "1.0" }; } if (this._fragment) { this.emit("error", Error("Cannot insert an XML declaration into a document fragment.")); return this; @@ -21664,9 +25907,9 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { this._push(this._writer.declaration(options.version || "1.0", options.encoding, options.standalone)); this._hasDeclaration = true; return this; - } + }; /** @inheritdoc */ - dtd(options) { + XMLBuilderCBImpl.prototype.dtd = function (options) { if (this._fragment) { this.emit("error", Error("Cannot insert a DocType declaration into a document fragment.")); return this; @@ -21679,9 +25922,9 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { this.emit("error", new Error("Cannot insert DocType declaration after document element.")); return this; } - let node; + var node; try { - node = __1.create().dtd(options).first().node; + node = BuilderFunctions_1.create().dtd(options).first().node; } catch (err) { this.emit("error", err); @@ -21700,45 +25943,45 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { this._docTypeName = options.name; this._push(this._writer.docType(options.name, node.publicId, node.systemId)); return this; - } + }; /** @inheritdoc */ - up() { + XMLBuilderCBImpl.prototype.up = function () { this._serializeOpenTag(false); this._serializeCloseTag(); return this; - } + }; /** @inheritdoc */ - end() { + XMLBuilderCBImpl.prototype.end = function () { this._serializeOpenTag(false); while (this._openTags.length > 0) { this._serializeCloseTag(); } this._push(null); return this; - } + }; /** * Serializes the opening tag of an element node. * * @param hasChildren - whether the element node has child nodes */ - _serializeOpenTag(hasChildren) { + XMLBuilderCBImpl.prototype._serializeOpenTag = function (hasChildren) { if (this._currentElementSerialized) return; if (this._currentElement === undefined) return; - const node = this._currentElement.node; + var node = this._currentElement.node; if (this._options.wellFormed && (node.localName.indexOf(":") !== -1 || !algorithm_1.xml_isName(node.localName))) { this.emit("error", new Error("Node local name contains invalid characters (well-formed required).")); return; } - let qualifiedName = ""; - let ignoreNamespaceDefinitionAttribute = false; - let map = this._prefixMap.copy(); - let localPrefixesMap = {}; - let localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap); - let inheritedNS = this._openTags.length === 0 ? null : this._openTags[this._openTags.length - 1][1]; - let ns = node.namespaceURI; + var qualifiedName = ""; + var ignoreNamespaceDefinitionAttribute = false; + var map = this._prefixMap.copy(); + var localPrefixesMap = {}; + var localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap); + var inheritedNS = this._openTags.length === 0 ? null : this._openTags[this._openTags.length - 1][1]; + var ns = node.namespaceURI; if (ns === null) ns = inheritedNS; if (inheritedNS === ns) { @@ -21755,8 +25998,8 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { this._push(this._writer.openTagBegin(qualifiedName)); } else { - let prefix = node.prefix; - let candidatePrefix = null; + var prefix = node.prefix; + var candidatePrefix = null; if (prefix !== null || ns !== localDefaultNamespace) { candidatePrefix = map.get(prefix, ns); } @@ -21805,7 +26048,7 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { } } this._serializeAttributes(node, map, this._prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, this._options.wellFormed); - const isHTML = (ns === infra_1.namespace.HTML); + var isHTML = (ns === infra_1.namespace.HTML); if (isHTML && !hasChildren && XMLBuilderCBImpl._VoidElementNames.has(node.localName)) { this._push(this._writer.openTagEnd(qualifiedName, true, true)); @@ -21836,19 +26079,19 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { * Calls following this will either serialize child nodes or close this tag. */ this._writer.level++; - } + }; /** * Serializes the closing tag of an element node. */ - _serializeCloseTag() { + XMLBuilderCBImpl.prototype._serializeCloseTag = function () { this._writer.level--; - const lastEle = this._openTags.pop(); + var lastEle = this._openTags.pop(); /* istanbul ignore next */ if (lastEle === undefined) { this.emit("error", new Error("Last element is undefined.")); return; } - const [qualifiedName, ns, map, hasChildren] = lastEle; + var _a = __read(lastEle, 4), qualifiedName = _a[0], ns = _a[1], map = _a[2], hasChildren = _a[3]; /** * Restore original values of inherited namespace and prefix map. */ @@ -21857,13 +26100,13 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { return; this._push(this._writer.closeTag(qualifiedName)); this._writer.endElement(qualifiedName); - } + }; /** * Pushes data to internal buffer. * * @param data - data */ - _push(data) { + XMLBuilderCBImpl.prototype._push = function (data) { if (data === null) { this._ended = true; this.emit("end"); @@ -21875,32 +26118,53 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { this._writer.hasData = true; this.emit("data", data, this._writer.level); } - } + }; /** * Reads and serializes an XML tree. * * @param node - root node */ - _fromNode(node) { + XMLBuilderCBImpl.prototype._fromNode = function (node) { + var e_2, _a, e_3, _b; if (util_2.Guard.isElementNode(node)) { - const name = node.prefix ? node.prefix + ":" + node.localName : node.localName; + var name = node.prefix ? node.prefix + ":" + node.localName : node.localName; if (node.namespaceURI !== null) { this.ele(node.namespaceURI, name); } else { this.ele(name); } - for (const attr of node.attributes) { - const name = attr.prefix ? attr.prefix + ":" + attr.localName : attr.localName; - if (attr.namespaceURI !== null) { - this.att(attr.namespaceURI, name, attr.value); - } - else { - this.att(name, attr.value); + try { + for (var _c = __values(node.attributes), _d = _c.next(); !_d.done; _d = _c.next()) { + var attr = _d.value; + var name_1 = attr.prefix ? attr.prefix + ":" + attr.localName : attr.localName; + if (attr.namespaceURI !== null) { + this.att(attr.namespaceURI, name_1, attr.value); + } + else { + this.att(name_1, attr.value); + } } } - for (const child of node.childNodes) { - this._fromNode(child); + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_d && !_d.done && (_a = _c.return)) _a.call(_c); + } + finally { if (e_2) throw e_2.error; } + } + try { + for (var _e = __values(node.childNodes), _f = _e.next(); !_f.done; _f = _e.next()) { + var child = _f.value; + this._fromNode(child); + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (_f && !_f.done && (_b = _e.return)) _b.call(_e); + } + finally { if (e_3) throw e_3.error; } } this.up(); } @@ -21916,7 +26180,7 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { else if (util_2.Guard.isProcessingInstructionNode(node)) { this.ins(node.target, node.data); } - } + }; /** * Produces an XML serialization of the attributes of an element node. * @@ -21928,81 +26192,92 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { * attributes * @param requireWellFormed - whether to check conformance */ - _serializeAttributes(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) { - const localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined; - for (const attr of node.attributes) { - // Optimize common case - if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) { - this._push(this._writer.attribute(attr.localName, this._serializeAttributeValue(attr.value, this._options.wellFormed))); - continue; - } - if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) { - this.emit("error", new Error("Element contains duplicate attributes (well-formed required).")); - return; - } - if (requireWellFormed && localNameSet) - localNameSet.set(attr.namespaceURI, attr.localName); - let attributeNamespace = attr.namespaceURI; - let candidatePrefix = null; - if (attributeNamespace !== null) { - candidatePrefix = map.get(attr.prefix, attributeNamespace); - if (attributeNamespace === infra_1.namespace.XMLNS) { - if (attr.value === infra_1.namespace.XML || - (attr.prefix === null && ignoreNamespaceDefinitionAttribute) || - (attr.prefix !== null && (!(attr.localName in localPrefixesMap) || - localPrefixesMap[attr.localName] !== attr.value) && - map.has(attr.localName, attr.value))) - continue; - if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) { - this.emit("error", new Error("XMLNS namespace is reserved (well-formed required).")); - return; - } - if (requireWellFormed && attr.value === '') { - this.emit("error", new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required).")); - return; - } - if (attr.prefix === 'xmlns') - candidatePrefix = 'xmlns'; - /** - * _Note:_ The (candidatePrefix === null) check is not in the spec. - * We deviate from the spec here. Otherwise a prefix is generated for - * all attributes with namespaces. - */ + XMLBuilderCBImpl.prototype._serializeAttributes = function (node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) { + var e_4, _a; + var localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined; + try { + for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) { + var attr = _c.value; + // Optimize common case + if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) { + this._push(this._writer.attribute(attr.localName, this._serializeAttributeValue(attr.value, this._options.wellFormed))); + continue; } - else if (candidatePrefix === null) { - if (attr.prefix !== null && - (!map.hasPrefix(attr.prefix) || - map.has(attr.prefix, attributeNamespace))) { + if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) { + this.emit("error", new Error("Element contains duplicate attributes (well-formed required).")); + return; + } + if (requireWellFormed && localNameSet) + localNameSet.set(attr.namespaceURI, attr.localName); + var attributeNamespace = attr.namespaceURI; + var candidatePrefix = null; + if (attributeNamespace !== null) { + candidatePrefix = map.get(attr.prefix, attributeNamespace); + if (attributeNamespace === infra_1.namespace.XMLNS) { + if (attr.value === infra_1.namespace.XML || + (attr.prefix === null && ignoreNamespaceDefinitionAttribute) || + (attr.prefix !== null && (!(attr.localName in localPrefixesMap) || + localPrefixesMap[attr.localName] !== attr.value) && + map.has(attr.localName, attr.value))) + continue; + if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) { + this.emit("error", new Error("XMLNS namespace is reserved (well-formed required).")); + return; + } + if (requireWellFormed && attr.value === '') { + this.emit("error", new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required).")); + return; + } + if (attr.prefix === 'xmlns') + candidatePrefix = 'xmlns'; /** - * Check if we can use the attribute's own prefix. - * We deviate from the spec here. - * TODO: This is not an efficient way of searching for prefixes. - * Follow developments to the spec. + * _Note:_ The (candidatePrefix === null) check is not in the spec. + * We deviate from the spec here. Otherwise a prefix is generated for + * all attributes with namespaces. */ - candidatePrefix = attr.prefix; } - else { - candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex); + else if (candidatePrefix === null) { + if (attr.prefix !== null && + (!map.hasPrefix(attr.prefix) || + map.has(attr.prefix, attributeNamespace))) { + /** + * Check if we can use the attribute's own prefix. + * We deviate from the spec here. + * TODO: This is not an efficient way of searching for prefixes. + * Follow developments to the spec. + */ + candidatePrefix = attr.prefix; + } + else { + candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex); + } + this._push(this._writer.attribute("xmlns:" + candidatePrefix, this._serializeAttributeValue(attributeNamespace, this._options.wellFormed))); } - this._push(this._writer.attribute("xmlns:" + candidatePrefix, this._serializeAttributeValue(attributeNamespace, this._options.wellFormed))); } + if (requireWellFormed && (attr.localName.indexOf(":") !== -1 || + !algorithm_1.xml_isName(attr.localName) || + (attr.localName === "xmlns" && attributeNamespace === null))) { + this.emit("error", new Error("Attribute local name contains invalid characters (well-formed required).")); + return; + } + this._push(this._writer.attribute((candidatePrefix !== null ? candidatePrefix + ":" : "") + attr.localName, this._serializeAttributeValue(attr.value, this._options.wellFormed))); } - if (requireWellFormed && (attr.localName.indexOf(":") !== -1 || - !algorithm_1.xml_isName(attr.localName) || - (attr.localName === "xmlns" && attributeNamespace === null))) { - this.emit("error", new Error("Attribute local name contains invalid characters (well-formed required).")); - return; - } - this._push(this._writer.attribute((candidatePrefix !== null ? candidatePrefix + ":" : "") + attr.localName, this._serializeAttributeValue(attr.value, this._options.wellFormed))); } - } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_4) throw e_4.error; } + } + }; /** * Produces an XML serialization of an attribute value. * * @param value - attribute value * @param requireWellFormed - whether to check conformance */ - _serializeAttributeValue(value, requireWellFormed) { + XMLBuilderCBImpl.prototype._serializeAttributeValue = function (value, requireWellFormed) { if (requireWellFormed && value !== null && !algorithm_1.xml_isLegalChar(value)) { this.emit("error", new Error("Invalid characters in attribute value.")); return ""; @@ -22012,15 +26287,13 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { if (this._options.noDoubleEncoding) { return value.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&') .replace(//g, '>') + .replace(/"/g, '"'); } else { - let result = ""; - for (let i = 0; i < value.length; i++) { - const c = value[i]; + var result = ""; + for (var i = 0; i < value.length; i++) { + var c = value[i]; if (c === "\"") result += """; else if (c === "&") @@ -22034,7 +26307,7 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { } return result; } - } + }; /** * Records namespace information for the given element and returns the * default namespace attribute value. @@ -22043,35 +26316,46 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { * @param map - namespace prefix map * @param localPrefixesMap - local prefixes map */ - _recordNamespaceInformation(node, map, localPrefixesMap) { - let defaultNamespaceAttrValue = null; - for (const attr of node.attributes) { - let attributeNamespace = attr.namespaceURI; - let attributePrefix = attr.prefix; - if (attributeNamespace === infra_1.namespace.XMLNS) { - if (attributePrefix === null) { - defaultNamespaceAttrValue = attr.value; - continue; - } - else { - let prefixDefinition = attr.localName; - let namespaceDefinition = attr.value; - if (namespaceDefinition === infra_1.namespace.XML) { + XMLBuilderCBImpl.prototype._recordNamespaceInformation = function (node, map, localPrefixesMap) { + var e_5, _a; + var defaultNamespaceAttrValue = null; + try { + for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) { + var attr = _c.value; + var attributeNamespace = attr.namespaceURI; + var attributePrefix = attr.prefix; + if (attributeNamespace === infra_1.namespace.XMLNS) { + if (attributePrefix === null) { + defaultNamespaceAttrValue = attr.value; continue; } - if (namespaceDefinition === '') { - namespaceDefinition = null; + else { + var prefixDefinition = attr.localName; + var namespaceDefinition = attr.value; + if (namespaceDefinition === infra_1.namespace.XML) { + continue; + } + if (namespaceDefinition === '') { + namespaceDefinition = null; + } + if (map.has(prefixDefinition, namespaceDefinition)) { + continue; + } + map.set(prefixDefinition, namespaceDefinition); + localPrefixesMap[prefixDefinition] = namespaceDefinition || ''; } - if (map.has(prefixDefinition, namespaceDefinition)) { - continue; - } - map.set(prefixDefinition, namespaceDefinition); - localPrefixesMap[prefixDefinition] = namespaceDefinition || ''; } } } + catch (e_5_1) { e_5 = { error: e_5_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_5) throw e_5.error; } + } return defaultNamespaceAttrValue; - } + }; /** * Generates a new prefix for the given namespace. * @@ -22079,66 +26363,135 @@ class XMLBuilderCBImpl extends events_1.EventEmitter { * @param prefixMap - namespace prefix map * @param prefixIndex - generated namespace prefix index */ - _generatePrefix(newNamespace, prefixMap, prefixIndex) { - let generatedPrefix = "ns" + prefixIndex.value; + XMLBuilderCBImpl.prototype._generatePrefix = function (newNamespace, prefixMap, prefixIndex) { + var generatedPrefix = "ns" + prefixIndex.value; prefixIndex.value++; prefixMap.set(generatedPrefix, newNamespace); return generatedPrefix; - } + }; /** * Determines if the namespace prefix map was modified from its original. * * @param originalMap - original namespace prefix map * @param newMap - new namespace prefix map */ - _isPrefixMapModified(originalMap, newMap) { - const items1 = originalMap._items; - const items2 = newMap._items; - const nullItems1 = originalMap._nullItems; - const nullItems2 = newMap._nullItems; - for (const key in items2) { - const arr1 = items1[key]; + XMLBuilderCBImpl.prototype._isPrefixMapModified = function (originalMap, newMap) { + var items1 = originalMap._items; + var items2 = newMap._items; + var nullItems1 = originalMap._nullItems; + var nullItems2 = newMap._nullItems; + for (var key in items2) { + var arr1 = items1[key]; if (arr1 === undefined) return true; - const arr2 = items2[key]; + var arr2 = items2[key]; if (arr1.length !== arr2.length) return true; - for (let i = 0; i < arr1.length; i++) { + for (var i = 0; i < arr1.length; i++) { if (arr1[i] !== arr2[i]) return true; } } if (nullItems1.length !== nullItems2.length) return true; - for (let i = 0; i < nullItems1.length; i++) { + for (var i = 0; i < nullItems1.length; i++) { if (nullItems1[i] !== nullItems2[i]) return true; } return false; - } -} + }; + XMLBuilderCBImpl._VoidElementNames = new Set(['area', 'base', 'basefont', + 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen', + 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']); + return XMLBuilderCBImpl; +}(events_1.EventEmitter)); exports.XMLBuilderCBImpl = XMLBuilderCBImpl; -XMLBuilderCBImpl._VoidElementNames = new Set(['area', 'base', 'basefont', - 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen', - 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']); //# sourceMappingURL=XMLBuilderCBImpl.js.map /***/ }), +/* 552 */, +/* 553 */, +/* 554 */, +/* 555 */, +/* 556 */ +/***/ (function(module) { -/***/ 558: +"use strict"; +// YAML error class. http://stackoverflow.com/questions/8458984 +// + + +function YAMLException(reason, mark) { + // Super constructor + Error.call(this); + + this.name = 'YAMLException'; + this.reason = reason; + this.mark = mark; + this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : ''); + + // Include stack trace in error object + if (Error.captureStackTrace) { + // Chrome and NodeJS + Error.captureStackTrace(this, this.constructor); + } else { + // FF, IE 10+ and Safari 6+. Fallback for others + this.stack = (new Error()).stack || ''; + } +} + + +// Inherit from Error +YAMLException.prototype = Object.create(Error.prototype); +YAMLException.prototype.constructor = YAMLException; + + +YAMLException.prototype.toString = function toString(compact) { + var result = this.name + ': '; + + result += this.reason || '(unknown reason)'; + + if (!compact && this.mark) { + result += ' ' + this.mark.toString(); + } + + return result; +}; + + +module.exports = YAMLException; + + +/***/ }), +/* 557 */, +/* 558 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const NodeImpl_1 = __webpack_require__(935); -const WebIDLAlgorithm_1 = __webpack_require__(495); +var interfaces_1 = __webpack_require__(970); +var NodeImpl_1 = __webpack_require__(935); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** * Represents an object providing methods which are not dependent on * any particular document */ -class DocumentTypeImpl extends NodeImpl_1.NodeImpl { +var DocumentTypeImpl = /** @class */ (function (_super) { + __extends(DocumentTypeImpl, _super); /** * Initializes a new instance of `DocumentType`. * @@ -22146,30 +26499,61 @@ class DocumentTypeImpl extends NodeImpl_1.NodeImpl { * @param publicId - `PUBLIC` identifier * @param systemId - `SYSTEM` identifier */ - constructor(name, publicId, systemId) { - super(); - this._name = ''; - this._publicId = ''; - this._systemId = ''; - this._name = name; - this._publicId = publicId; - this._systemId = systemId; + function DocumentTypeImpl(name, publicId, systemId) { + var _this = _super.call(this) || this; + _this._name = ''; + _this._publicId = ''; + _this._systemId = ''; + _this._name = name; + _this._publicId = publicId; + _this._systemId = systemId; + return _this; } - /** @inheritdoc */ - get name() { return this._name; } - /** @inheritdoc */ - get publicId() { return this._publicId; } - /** @inheritdoc */ - get systemId() { return this._systemId; } + Object.defineProperty(DocumentTypeImpl.prototype, "name", { + /** @inheritdoc */ + get: function () { return this._name; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentTypeImpl.prototype, "publicId", { + /** @inheritdoc */ + get: function () { return this._publicId; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentTypeImpl.prototype, "systemId", { + /** @inheritdoc */ + get: function () { return this._systemId; }, + enumerable: true, + configurable: true + }); // MIXIN: ChildNode /* istanbul ignore next */ - before(...nodes) { throw new Error("Mixin: ChildNode not implemented."); } + DocumentTypeImpl.prototype.before = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ChildNode not implemented."); + }; /* istanbul ignore next */ - after(...nodes) { throw new Error("Mixin: ChildNode not implemented."); } + DocumentTypeImpl.prototype.after = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ChildNode not implemented."); + }; /* istanbul ignore next */ - replaceWith(...nodes) { throw new Error("Mixin: ChildNode not implemented."); } + DocumentTypeImpl.prototype.replaceWith = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ChildNode not implemented."); + }; /* istanbul ignore next */ - remove() { throw new Error("Mixin: ChildNode not implemented."); } + DocumentTypeImpl.prototype.remove = function () { throw new Error("Mixin: ChildNode not implemented."); }; /** * Creates a new `DocumentType`. * @@ -22178,12 +26562,15 @@ class DocumentTypeImpl extends NodeImpl_1.NodeImpl { * @param publicId - `PUBLIC` identifier * @param systemId - `SYSTEM` identifier */ - static _create(document, name, publicId = '', systemId = '') { - const node = new DocumentTypeImpl(name, publicId, systemId); + DocumentTypeImpl._create = function (document, name, publicId, systemId) { + if (publicId === void 0) { publicId = ''; } + if (systemId === void 0) { systemId = ''; } + var node = new DocumentTypeImpl(name, publicId, systemId); node._nodeDocument = document; return node; - } -} + }; + return DocumentTypeImpl; +}(NodeImpl_1.NodeImpl)); exports.DocumentTypeImpl = DocumentTypeImpl; /** * Initialize prototype properties @@ -22192,114 +26579,75 @@ WebIDLAlgorithm_1.idl_defineConst(DocumentTypeImpl.prototype, "_nodeType", inter //# sourceMappingURL=DocumentTypeImpl.js.map /***/ }), - -/***/ 568: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents an object cache with a size limit. - */ -class ObjectCache { - /** - * Initializes a new instance of `ObjectCache`. - * - * @param limit - maximum number of items to keep in the cache. When the limit - * is exceeded the first item is removed from the cache. - */ - constructor(limit = 1000) { - this._items = new Set(); - this._limit = limit; - } - /** - * Adds a new item to the cache. - * - * @param item - an item - */ - add(item) { - this._items.add(item); - if (this._items.size > this._limit) { - const it = this._items.values().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - } - /** - * Removes an item from the cache. - * - * @param item - an item - */ - remove(item) { - this._items.delete(item); - } - /** - * Removes all items from the cache. - */ - clear() { - this._items.clear(); - } - /** - * Gets the number of items in the cache. - */ - get length() { return this._items.size; } - /** - * Iterates through the items in the cache. - */ - *entries() { - yield* this; - } - /** @inheritdoc */ - *[Symbol.iterator]() { - for (const item of this._items) { - yield item; - } - } -} -exports.ObjectCache = ObjectCache; -//# sourceMappingURL=ObjectCache.js.map - -/***/ }), - -/***/ 574: +/* 559 */, +/* 560 */, +/* 561 */, +/* 562 */, +/* 563 */, +/* 564 */, +/* 565 */, +/* 566 */, +/* 567 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(918); -const algorithm_1 = __webpack_require__(163); +var XMLReader_1 = __webpack_require__(771); +exports.XMLReader = XMLReader_1.XMLReader; +var ObjectReader_1 = __webpack_require__(50); +exports.ObjectReader = ObjectReader_1.ObjectReader; +var JSONReader_1 = __webpack_require__(112); +exports.JSONReader = JSONReader_1.JSONReader; +var YAMLReader_1 = __webpack_require__(865); +exports.YAMLReader = YAMLReader_1.YAMLReader; +//# sourceMappingURL=index.js.map + +/***/ }), +/* 568 */, +/* 569 */, +/* 570 */, +/* 571 */, +/* 572 */, +/* 573 */, +/* 574 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var util_1 = __webpack_require__(918); +var algorithm_1 = __webpack_require__(163); /** * Represents a mixin that extends non-element parent nodes. This mixin * is implemented by {@link Document} and {@link DocumentFragment}. */ -class NonElementParentNodeImpl { +var NonElementParentNodeImpl = /** @class */ (function () { + function NonElementParentNodeImpl() { + } /** @inheritdoc */ - getElementById(id) { + NonElementParentNodeImpl.prototype.getElementById = function (id) { /** * The getElementById(elementId) method, when invoked, must return the first * element, in tree order, within the context object’s descendants, * whose ID is elementId, and null if there is no such element otherwise. */ - let ele = algorithm_1.tree_getFirstDescendantNode(util_1.Cast.asNode(this), false, false, (e) => util_1.Guard.isElementNode(e)); + var ele = algorithm_1.tree_getFirstDescendantNode(util_1.Cast.asNode(this), false, false, function (e) { return util_1.Guard.isElementNode(e); }); while (ele !== null) { if (ele._uniqueIdentifier === id) { return ele; } - ele = algorithm_1.tree_getNextDescendantNode(util_1.Cast.asNode(this), ele, false, false, (e) => util_1.Guard.isElementNode(e)); + ele = algorithm_1.tree_getNextDescendantNode(util_1.Cast.asNode(this), ele, false, false, function (e) { return util_1.Guard.isElementNode(e); }); } return null; - } -} + }; + return NonElementParentNodeImpl; +}()); exports.NonElementParentNodeImpl = NonElementParentNodeImpl; //# sourceMappingURL=NonElementParentNodeImpl.js.map /***/ }), - -/***/ 575: +/* 575 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -22314,8 +26662,8 @@ Object.defineProperty(exports, "__esModule", { value: true }); * This can occur when two otherwise identical attributes on the same * element differ only by their prefix values. */ -class LocalNameSet { - constructor() { +var LocalNameSet = /** @class */ (function () { + function LocalNameSet() { // tuple storage this._items = {}; this._nullItems = {}; @@ -22326,7 +26674,7 @@ class LocalNameSet { * @param ns - namespace URI * @param localName - attribute local name */ - set(ns, localName) { + LocalNameSet.prototype.set = function (ns, localName) { if (ns === null) { this._nullItems[localName] = true; } @@ -22337,14 +26685,14 @@ class LocalNameSet { this._items[ns] = {}; this._items[ns][localName] = true; } - } + }; /** * Determines if the given tuple exists in the set. * * @param ns - namespace URI * @param localName - attribute local name */ - has(ns, localName) { + LocalNameSet.prototype.has = function (ns, localName) { if (ns === null) { return this._nullItems[localName] === true; } @@ -22354,47 +26702,75 @@ class LocalNameSet { else { return false; } - } -} + }; + return LocalNameSet; +}()); exports.LocalNameSet = LocalNameSet; //# sourceMappingURL=LocalNameSet.js.map /***/ }), - -/***/ 581: +/* 576 */, +/* 577 */, +/* 578 */, +/* 579 */, +/* 580 */, +/* 581 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const DocumentFragmentImpl_1 = __webpack_require__(796); -const util_1 = __webpack_require__(337); -const algorithm_1 = __webpack_require__(163); +var DocumentFragmentImpl_1 = __webpack_require__(796); +var util_1 = __webpack_require__(592); +var algorithm_1 = __webpack_require__(163); /** * Represents a shadow root. */ -class ShadowRootImpl extends DocumentFragmentImpl_1.DocumentFragmentImpl { +var ShadowRootImpl = /** @class */ (function (_super) { + __extends(ShadowRootImpl, _super); /** * Initializes a new instance of `ShadowRoot`. * * @param host - shadow root's host element * @param mode - shadow root's mode */ - constructor(host, mode) { - super(); - this._host = host; - this._mode = mode; + function ShadowRootImpl(host, mode) { + var _this = _super.call(this) || this; + _this._host = host; + _this._mode = mode; + return _this; } - /** @inheritdoc */ - get mode() { return this._mode; } - /** @inheritdoc */ - get host() { return this._host; } + Object.defineProperty(ShadowRootImpl.prototype, "mode", { + /** @inheritdoc */ + get: function () { return this._mode; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ShadowRootImpl.prototype, "host", { + /** @inheritdoc */ + get: function () { return this._host; }, + enumerable: true, + configurable: true + }); /** * Gets the parent event target for the given event. * * @param event - an event */ - _getTheParent(event) { + ShadowRootImpl.prototype._getTheParent = function (event) { /** * A shadow root’s get the parent algorithm, given an event, returns null * if event’s composed flag is unset and shadow root is the root of @@ -22408,7 +26784,7 @@ class ShadowRootImpl extends DocumentFragmentImpl_1.DocumentFragmentImpl { else { return this._host; } - } + }; // MIXIN: DocumentOrShadowRoot // No elements /** @@ -22417,20 +26793,209 @@ class ShadowRootImpl extends DocumentFragmentImpl_1.DocumentFragmentImpl { * @param document - owner document * @param host - shadow root's host element */ - static _create(document, host) { + ShadowRootImpl._create = function (document, host) { return new ShadowRootImpl(host, "closed"); - } -} + }; + return ShadowRootImpl; +}(DocumentFragmentImpl_1.DocumentFragmentImpl)); exports.ShadowRootImpl = ShadowRootImpl; //# sourceMappingURL=ShadowRootImpl.js.map /***/ }), - -/***/ 592: +/* 582 */, +/* 583 */, +/* 584 */ /***/ (function(__unusedmodule, exports, __webpack_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.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.AdoptDistribution = void 0; +const core = __importStar(__webpack_require__(470)); +const tc = __importStar(__webpack_require__(139)); +const fs_1 = __importDefault(__webpack_require__(747)); +const path_1 = __importDefault(__webpack_require__(622)); +const semver_1 = __importDefault(__webpack_require__(876)); +const base_installer_1 = __webpack_require__(83); +const constants_1 = __webpack_require__(211); +const util_1 = __webpack_require__(322); +class AdoptDistribution extends base_installer_1.JavaBase { + constructor(installerOptions) { + super('Adopt', installerOptions); + } + findPackageForDownload(version) { + return __awaiter(this, void 0, void 0, function* () { + const availableVersionsRaw = yield this.getAvailableVersions(); + const availableVersionsWithBinaries = availableVersionsRaw + .filter(item => item.binaries.length > 0) + .map(item => { + return { + version: item.version_data.semver, + url: item.binaries[0].package.link + }; + }); + const satisfiedVersions = availableVersionsWithBinaries + .filter(item => util_1.isVersionSatisfies(version, item.version)) + .sort((a, b) => { + return -semver_1.default.compareBuild(a.version, b.version); + }); + const resolvedFullVersion = satisfiedVersions.length > 0 ? satisfiedVersions[0] : null; + if (!resolvedFullVersion) { + const availableOptions = availableVersionsWithBinaries.map(item => item.version).join(', '); + const availableOptionsMessage = availableOptions + ? `\nAvailable versions: ${availableOptions}` + : ''; + throw new Error(`Could not find satisfied version for SemVer '${version}'. ${availableOptionsMessage}`); + } + return resolvedFullVersion; + }); + } + downloadTool(javaRelease) { + return __awaiter(this, void 0, void 0, function* () { + let javaPath; + let extractedJavaPath; + core.info(`Downloading Java ${javaRelease.version} (${this.distribution}) from ${javaRelease.url} ...`); + const javaArchivePath = yield tc.downloadTool(javaRelease.url); + core.info(`Extracting Java archive...`); + let extension = util_1.getDownloadArchiveExtension(); + extractedJavaPath = yield util_1.extractJdkFile(javaArchivePath, extension); + const archiveName = fs_1.default.readdirSync(extractedJavaPath)[0]; + const archivePath = path_1.default.join(extractedJavaPath, archiveName); + const version = this.getToolcacheVersionName(javaRelease.version); + javaPath = yield tc.cacheDir(archivePath, this.toolcacheFolderName, version, this.architecture); + if (process.platform === 'darwin') { + javaPath = path_1.default.join(javaPath, constants_1.MACOS_JAVA_CONTENT_POSTFIX); + } + return { version: javaRelease.version, path: javaPath }; + }); + } + getAvailableVersions() { + return __awaiter(this, void 0, void 0, function* () { + const platform = this.getPlatformOption(); + const arch = this.architecture; + const imageType = this.packageType; + const versionRange = encodeURI('[1.0,100.0]'); // retrieve all available versions + const releaseType = this.stable ? 'ga' : 'ea'; + console.time('adopt-retrieve-available-versions'); + const baseRequestArguments = [ + `project=jdk`, + 'vendor=adoptopenjdk', + `heap_size=normal`, + `jvm_impl=hotspot`, + 'sort_method=DEFAULT', + 'sort_order=DESC', + `os=${platform}`, + `architecture=${arch}`, + `image_type=${imageType}`, + `release_type=${releaseType}` + ].join('&'); + // need to iterate through all pages to retrieve the list of all versions + // Adopt API doesn't provide way to retrieve the count of pages to iterate so infinity loop + let page_index = 0; + const availableVersions = []; + while (true) { + const requestArguments = `${baseRequestArguments}&page_size=20&page=${page_index}`; + const availableVersionsUrl = `https://api.adoptopenjdk.net/v3/assets/version/${versionRange}?${requestArguments}`; + if (core.isDebug() && page_index === 0) { + // url is identical except page_index so print it once for debug + core.debug(`Gathering available versions from '${availableVersionsUrl}'`); + } + const paginationPage = (yield this.http.getJson(availableVersionsUrl)).result; + if (paginationPage === null || paginationPage.length === 0) { + // break infinity loop because we have reached end of pagination + break; + } + availableVersions.push(...paginationPage); + page_index++; + } + if (core.isDebug()) { + core.startGroup('Print information about available versions'); + console.timeEnd('adopt-retrieve-available-versions'); + console.log(`Available versions: [${availableVersions.length}]`); + console.log(availableVersions.map(item => item.version_data.semver).join(', ')); + core.endGroup(); + } + return availableVersions; + }); + } + getPlatformOption() { + // Adopt has own platform names so need to map them + switch (process.platform) { + case 'darwin': + return 'mac'; + case 'win32': + return 'windows'; + default: + return process.platform; + } + } +} +exports.AdoptDistribution = AdoptDistribution; + + +/***/ }), +/* 585 */, +/* 586 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const lt = (a, b, loose) => compare(a, b, loose) < 0 +module.exports = lt + + +/***/ }), +/* 587 */, +/* 588 */, +/* 589 */, +/* 590 */, +/* 591 */, +/* 592 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); var FixedSizeSet_1 = __webpack_require__(704); exports.FixedSizeSet = FixedSizeSet_1.FixedSizeSet; @@ -22440,6 +27005,8 @@ var CompareCache_1 = __webpack_require__(524); exports.CompareCache = CompareCache_1.CompareCache; var Lazy_1 = __webpack_require__(947); exports.Lazy = Lazy_1.Lazy; +var StringWalker_1 = __webpack_require__(47); +exports.StringWalker = StringWalker_1.StringWalker; /** * Applies the mixin to a given class. * @@ -22449,19 +27016,25 @@ exports.Lazy = Lazy_1.Lazy; * functions whose names are in this array will be kept by prepending an * underscore to their names. */ -function applyMixin(baseClass, mixinClass, ...overrides) { - Object.getOwnPropertyNames(mixinClass.prototype).forEach(name => { - if (overrides.includes(name)) { - const orgPropDesc = Object.getOwnPropertyDescriptor(baseClass.prototype, name); - /* istanbul ignore else */ - if (orgPropDesc) { - Object.defineProperty(baseClass.prototype, "_" + name, orgPropDesc); +function applyMixin(baseClass, mixinClass) { + var overrides = []; + for (var _i = 2; _i < arguments.length; _i++) { + overrides[_i - 2] = arguments[_i]; + } + Object.getOwnPropertyNames(mixinClass.prototype).forEach(function (name) { + if (name !== "constructor") { + if (overrides.indexOf(name) !== -1) { + var orgPropDesc = Object.getOwnPropertyDescriptor(baseClass.prototype, name); + /* istanbul ignore else */ + if (orgPropDesc) { + Object.defineProperty(baseClass.prototype, "_" + name, orgPropDesc); + } + } + var propDesc = Object.getOwnPropertyDescriptor(mixinClass.prototype, name); + /* istanbul ignore else */ + if (propDesc) { + Object.defineProperty(baseClass.prototype, name, propDesc); } - } - const propDesc = Object.getOwnPropertyDescriptor(mixinClass.prototype, name); - /* istanbul ignore else */ - if (propDesc) { - Object.defineProperty(baseClass.prototype, name, propDesc); } }); } @@ -22474,9 +27047,10 @@ exports.applyMixin = applyMixin; * @param overwrite - if set to `true` defaults object always overwrites object * values, whether they are `undefined` or not. */ -function applyDefaults(obj, defaults, overwrite = false) { - const result = clone(obj || {}); - forEachObject(defaults, (key, val) => { +function applyDefaults(obj, defaults, overwrite) { + if (overwrite === void 0) { overwrite = false; } + var result = clone(obj || {}); + forEachObject(defaults, function (key, val) { if (isPlainObject(val)) { result[key] = applyDefaults(result[key], val, overwrite); } @@ -22509,10 +27083,10 @@ exports.forEachArray = forEachArray; */ function forEachObject(obj, callback, thisArg) { if (isMap(obj)) { - obj.forEach((value, key) => callback.call(thisArg, key, value)); + obj.forEach(function (value, key) { return callback.call(thisArg, key, value); }); } else { - for (const key in obj) { + for (var key in obj) { /* istanbul ignore else */ if (obj.hasOwnProperty(key)) { callback.call(thisArg, key, obj[key]); @@ -22585,22 +27159,33 @@ exports.removeObjectValue = removeObjectValue; * @param obj - an object */ function clone(obj) { + var e_1, _a; if (isFunction(obj)) { return obj; } else if (isArray(obj)) { - const result = []; - for (const item of obj) { - result.push(clone(item)); + var result = []; + try { + for (var obj_1 = __values(obj), obj_1_1 = obj_1.next(); !obj_1_1.done; obj_1_1 = obj_1.next()) { + var item = obj_1_1.value; + result.push(clone(item)); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (obj_1_1 && !obj_1_1.done && (_a = obj_1.return)) _a.call(obj_1); + } + finally { if (e_1) throw e_1.error; } } return result; } else if (isObject(obj)) { - const result = {}; - for (const key in obj) { + var result = {}; + for (var key in obj) { /* istanbul ignore next */ if (obj.hasOwnProperty(key)) { - const val = obj[key]; + var val = obj[key]; result[key] = clone(val); } } @@ -22655,7 +27240,7 @@ exports.isFunction = isFunction; * @param x - a variable to type check */ function isObject(x) { - const type = typeof x; + var type = typeof x; return !!x && (type === 'function' || type === 'object'); } exports.isObject = isObject; @@ -22702,7 +27287,7 @@ function isEmpty(x) { return !x.size; } else if (isObject(x)) { - for (const key in x) { + for (var key in x) { if (x.hasOwnProperty(key)) { return false; } @@ -22719,8 +27304,8 @@ exports.isEmpty = isEmpty; */ function isPlainObject(x) { if (isObject(x)) { - const proto = Object.getPrototypeOf(x); - const ctor = proto.constructor; + var proto = Object.getPrototypeOf(x); + var ctor = proto.constructor; return proto && ctor && (typeof ctor === 'function') && (ctor instanceof ctor) && (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object)); @@ -22755,10 +27340,10 @@ exports.getValue = getValue; * @param input - a string */ function utf8Encode(input) { - const bytes = new Uint8Array(input.length * 4); - let byteIndex = 0; - for (let i = 0; i < input.length; i++) { - let char = input.charCodeAt(i); + var bytes = new Uint8Array(input.length * 4); + var byteIndex = 0; + for (var i = 0; i < input.length; i++) { + var char = input.charCodeAt(i); if (char < 128) { bytes[byteIndex++] = char; continue; @@ -22771,7 +27356,7 @@ function utf8Encode(input) { if (++i >= input.length) { throw new Error("Incomplete surrogate pair."); } - const c2 = input.charCodeAt(i); + var c2 = input.charCodeAt(i); if (c2 < 0xdc00 || c2 > 0xdfff) { throw new Error("Invalid surrogate character."); } @@ -22795,8 +27380,8 @@ exports.utf8Encode = utf8Encode; * @param bytes - a byte sequence */ function utf8Decode(bytes) { - let result = ""; - let i = 0; + var result = ""; + var i = 0; while (i < bytes.length) { var c = bytes[i++]; if (c > 127) { @@ -22840,84 +27425,118 @@ exports.utf8Decode = utf8Decode; //# sourceMappingURL=index.js.map /***/ }), +/* 593 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 595: +const compareBuild = __webpack_require__(16) +const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose)) +module.exports = rsort + + +/***/ }), +/* 594 */, +/* 595 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(625); -const util_1 = __webpack_require__(592); -const writers_1 = __webpack_require__(95); -const interfaces_2 = __webpack_require__(970); -const util_2 = __webpack_require__(918); -const algorithm_1 = __webpack_require__(163); -const dom_1 = __webpack_require__(743); -const infra_1 = __webpack_require__(23); +var interfaces_1 = __webpack_require__(625); +var util_1 = __webpack_require__(592); +var writers_1 = __webpack_require__(95); +var interfaces_2 = __webpack_require__(970); +var util_2 = __webpack_require__(918); +var algorithm_1 = __webpack_require__(163); +var dom_1 = __webpack_require__(743); +var infra_1 = __webpack_require__(23); +var readers_1 = __webpack_require__(567); /** * Represents a wrapper that extends XML nodes to implement easy to use and * chainable document builder methods. */ -class XMLBuilderImpl { +var XMLBuilderImpl = /** @class */ (function () { /** * Initializes a new instance of `XMLBuilderNodeImpl`. * * @param domNode - the DOM node to wrap */ - constructor(domNode) { + function XMLBuilderImpl(domNode) { this._domNode = domNode; } + Object.defineProperty(XMLBuilderImpl.prototype, "node", { + /** @inheritdoc */ + get: function () { return this._domNode; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(XMLBuilderImpl.prototype, "options", { + /** @inheritdoc */ + get: function () { return this._options; }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get node() { return this._domNode; } - /** @inheritdoc */ - set(options) { + XMLBuilderImpl.prototype.set = function (options) { this._options = util_1.applyDefaults(util_1.applyDefaults(this._options, options, true), // apply user settings interfaces_1.DefaultBuilderOptions); // provide defaults return this; - } + }; /** @inheritdoc */ - ele(p1, p2, p3) { - let namespace; - let name; - let attributes; - let lastChild = null; - if (util_1.isString(p1) && /^\s*" + p1 + ""; - const domParser = dom_1.createParser(); - const doc = domParser.parseFromString(dom_1.sanitizeInput(contents, this._options.invalidCharReplacement), "text/xml"); - /* istanbul ignore next */ - if (doc.documentElement === null) { - throw new Error("Document element is null."); - } - dom_1.throwIfParserError(doc); - for (const child of doc.documentElement.childNodes) { - const newChild = doc.importNode(child, true); - lastChild = new XMLBuilderImpl(newChild); - this._domNode.appendChild(newChild); - } - if (lastChild === null) { - throw new Error("Could not create any elements with: " + p1.toString() + ". " + this._debugInfo()); - } - return lastChild; - } - else if (util_1.isString(p1) && /^\s*[\{\[]/.test(p1)) { - // parse JSON string - const obj = JSON.parse(p1); - return this.ele(obj); - } - else if (util_1.isObject(p1)) { + XMLBuilderImpl.prototype.ele = function (p1, p2, p3) { + var _a, _b, _c; + var namespace; + var name; + var attributes; + if (util_1.isObject(p1)) { // ele(obj: ExpandObject) - [namespace, name, attributes] = [undefined, p1, undefined]; + return new readers_1.ObjectReader(this._options).parse(this, p1); } - else if ((p1 === null || util_1.isString(p1)) && util_1.isString(p2)) { + else if (p1 !== null && /^\s* lastChild = this.ele(item), this); + // create a child element node + var childNode = (namespace !== undefined && namespace !== null ? + this._doc.createElementNS(namespace, name) : + this._doc.createElement(name)); + this.node.appendChild(childNode); + var builder = new XMLBuilderImpl(childNode); + // update doctype node if the new node is the document element node + var oldDocType = this._doc.doctype; + if (childNode === this._doc.documentElement && oldDocType !== null) { + var docType = this._doc.implementation.createDocumentType(this._doc.documentElement.tagName, oldDocType.publicId, oldDocType.systemId); + this._doc.replaceChild(docType, oldDocType); } - else if (util_1.isMap(name) || util_1.isObject(name)) { - // expand if object - util_1.forEachObject(name, (key, val) => { - if (util_1.isFunction(val)) { - // evaluate if function - val = val.apply(this); - } - if (!this._options.ignoreConverters && key.indexOf(this._options.convert.att) === 0) { - // assign attributes - if (key === this._options.convert.att) { - lastChild = this.att(val); - } - else { - lastChild = this.att(key.substr(this._options.convert.att.length), val); - } - } - else if (!this._options.ignoreConverters && key.indexOf(this._options.convert.text) === 0) { - // text node - if (util_1.isMap(val) || util_1.isObject(val)) { - // if the key is #text expand child nodes under this node to support mixed content - lastChild = this.ele(val); - } - else { - lastChild = this.txt(val); - } - } - else if (!this._options.ignoreConverters && key.indexOf(this._options.convert.cdata) === 0) { - // cdata node - if (util_1.isArray(val) || util_1.isSet(val)) { - util_1.forEachArray(val, item => lastChild = this.dat(item), this); - } - else { - lastChild = this.dat(val); - } - } - else if (!this._options.ignoreConverters && key.indexOf(this._options.convert.comment) === 0) { - // comment node - if (util_1.isArray(val) || util_1.isSet(val)) { - util_1.forEachArray(val, item => lastChild = this.com(item), this); - } - else { - lastChild = this.com(val); - } - } - else if (!this._options.ignoreConverters && key.indexOf(this._options.convert.ins) === 0) { - // processing instruction - if (util_1.isString(val)) { - const insIndex = val.indexOf(' '); - const insTarget = (insIndex === -1 ? val : val.substr(0, insIndex)); - const insValue = (insIndex === -1 ? '' : val.substr(insIndex + 1)); - lastChild = this.ins(insTarget, insValue); - } - else { - lastChild = this.ins(val); - } - } - else if ((util_1.isArray(val) || util_1.isSet(val)) && util_1.isEmpty(val)) { - // skip empty arrays - lastChild = this._dummy(); - } - else if ((util_1.isMap(val) || util_1.isObject(val)) && util_1.isEmpty(val)) { - // empty objects produce one node - lastChild = this.ele(key); - } - else if (!this._options.keepNullNodes && (val == null)) { - // skip null and undefined nodes - lastChild = this._dummy(); - } - else if (util_1.isArray(val) || util_1.isSet(val)) { - // expand list by creating child nodes - util_1.forEachArray(val, item => { - const childNode = {}; - childNode[key] = item; - lastChild = this.ele(childNode); - }, this); - } - else if (util_1.isMap(val) || util_1.isObject(val)) { - // create a parent node - lastChild = this.ele(key); - // expand child nodes under parent - lastChild.ele(val); - } - else if (val) { - // leaf element node with a single text node - lastChild = this.ele(key); - lastChild.txt(val); - } - else { - // leaf element node - lastChild = this.ele(key); - } - }, this); + // create attributes + if (attributes && !util_1.isEmpty(attributes)) { + builder.att(attributes); } - else { - [namespace, name] = this._extractNamespace(dom_1.sanitizeInput(namespace, this._options.invalidCharReplacement), dom_1.sanitizeInput(name, this._options.invalidCharReplacement), true); - // inherit namespace from parent - if (namespace === undefined) { - const [prefix] = algorithm_1.namespace_extractQName(name); - namespace = this.node.lookupNamespaceURI(prefix); - } - // create a child element node - const childNode = (namespace !== undefined && namespace !== null ? - this._doc.createElementNS(namespace, name) : - this._doc.createElement(name)); - this.node.appendChild(childNode); - lastChild = new XMLBuilderImpl(childNode); - // update doctype node if the new node is the document element node - const oldDocType = this._doc.doctype; - if (childNode === this._doc.documentElement && oldDocType !== null) { - const docType = this._doc.implementation.createDocumentType(this._doc.documentElement.tagName, oldDocType.publicId, oldDocType.systemId); - this._doc.replaceChild(docType, oldDocType); - } - // create attributes - if (attributes && !util_1.isEmpty(attributes)) { - lastChild.att(attributes); - } - } - if (lastChild === null) { - throw new Error("Could not create any elements with: " + name.toString() + ". " + this._debugInfo()); - } - return lastChild; - } + return builder; + }; /** @inheritdoc */ - remove() { - const parent = this.up(); + XMLBuilderImpl.prototype.remove = function () { + var parent = this.up(); parent.node.removeChild(this.node); return parent; - } + }; /** @inheritdoc */ - att(p1, p2, p3) { + XMLBuilderImpl.prototype.att = function (p1, p2, p3) { + var _a, _b, _c; + var _this = this; if (util_1.isMap(p1) || util_1.isObject(p1)) { // att(obj: AttributesObject) // expand if object - util_1.forEachObject(p1, (attName, attValue) => this.att(attName, attValue), this); + util_1.forEachObject(p1, function (attName, attValue) { return _this.att(attName, attValue); }, this); return this; } // get primitive values @@ -23075,16 +27591,16 @@ class XMLBuilderImpl { p2 = util_1.getValue(p2 + ""); if (p3 !== undefined && p3 !== null) p3 = util_1.getValue(p3 + ""); - let namespace; - let name; - let value; + var namespace; + var name; + var value; if ((p1 === null || util_1.isString(p1)) && util_1.isString(p2) && (p3 === null || util_1.isString(p3))) { // att(namespace: string, name: string, value: string) - [namespace, name, value] = [p1, p2, p3]; + _a = __read([p1, p2, p3], 3), namespace = _a[0], name = _a[1], value = _a[2]; } else if (util_1.isString(p1) && (p2 == null || util_1.isString(p2))) { // ele(name: string, value: string) - [namespace, name, value] = [undefined, p1, p2]; + _b = __read([undefined, p1, p2], 3), namespace = _b[0], name = _b[1], value = _b[2]; } else { throw new Error("Attribute name and value not specified. " + this._debugInfo()); @@ -23100,16 +27616,16 @@ class XMLBuilderImpl { if (!util_2.Guard.isElementNode(this.node)) { throw new Error("An attribute can only be assigned to an element node."); } - let ele = this.node; - [namespace, name] = this._extractNamespace(namespace, name, false); + var ele = this.node; + _c = __read(this._extractNamespace(namespace, name, false), 2), namespace = _c[0], name = _c[1]; name = dom_1.sanitizeInput(name, this._options.invalidCharReplacement); namespace = dom_1.sanitizeInput(namespace, this._options.invalidCharReplacement); value = dom_1.sanitizeInput(value, this._options.invalidCharReplacement); - const [prefix, localName] = algorithm_1.namespace_extractQName(name); - const [elePrefix, eleLocalName] = algorithm_1.namespace_extractQName(ele.prefix ? ele.prefix + ':' + ele.localName : ele.localName); + var _d = __read(algorithm_1.namespace_extractQName(name), 2), prefix = _d[0], localName = _d[1]; + var _e = __read(algorithm_1.namespace_extractQName(ele.prefix ? ele.prefix + ':' + ele.localName : ele.localName), 1), elePrefix = _e[0]; // check if this is a namespace declaration attribute // assign a new element namespace if it wasn't previously assigned - let eleNamespace = null; + var eleNamespace = null; if (prefix === "xmlns") { namespace = infra_1.namespace.XMLNS; if (ele.namespaceURI === null && elePrefix === localName) { @@ -23123,21 +27639,8 @@ class XMLBuilderImpl { // re-create the element node if its namespace changed // we can't simply change the namespaceURI since its read-only if (eleNamespace !== null) { - const newEle = algorithm_1.create_element(this._doc, eleLocalName, eleNamespace, elePrefix); - for (const attr of ele.attributes) { - newEle.setAttributeNodeNS(attr.cloneNode()); - } - for (const childNode of ele.childNodes) { - newEle.appendChild(childNode.cloneNode()); - } - const parent = ele.parentNode; - /* istanbul ignore next */ - if (parent === null) { - throw new Error("Parent node is null." + this._debugInfo()); - } - parent.replaceChild(newEle, ele); - this._domNode = newEle; - ele = newEle; + this._updateNamespace(eleNamespace); + ele = this.node; } if (namespace !== undefined) { ele.setAttributeNS(namespace, name, value); @@ -23146,9 +27649,10 @@ class XMLBuilderImpl { ele.setAttribute(name, value); } return this; - } + }; /** @inheritdoc */ - removeAtt(p1, p2) { + XMLBuilderImpl.prototype.removeAtt = function (p1, p2) { + var _this = this; if (!util_2.Guard.isElementNode(this.node)) { throw new Error("An attribute can only be removed from an element node."); } @@ -23157,8 +27661,8 @@ class XMLBuilderImpl { if (p2 !== undefined) { p2 = util_1.getValue(p2); } - let namespace; - let name; + var namespace; + var name; if (p1 !== null && p2 === undefined) { name = p1; } @@ -23172,7 +27676,9 @@ class XMLBuilderImpl { if (util_1.isArray(name) || util_1.isSet(name)) { // removeAtt(names: string[]) // removeAtt(namespace: string, names: string[]) - util_1.forEachArray(name, attName => namespace === undefined ? this.removeAtt(attName) : this.removeAtt(namespace, attName), this); + util_1.forEachArray(name, function (attName) { + return namespace === undefined ? _this.removeAtt(attName) : _this.removeAtt(namespace, attName); + }, this); } else if (namespace !== undefined) { // removeAtt(namespace: string, name: string) @@ -23186,63 +27692,65 @@ class XMLBuilderImpl { this.node.removeAttribute(name); } return this; - } + }; /** @inheritdoc */ - txt(content) { - const child = this._doc.createTextNode(dom_1.sanitizeInput(content, this._options.invalidCharReplacement)); + XMLBuilderImpl.prototype.txt = function (content) { + var child = this._doc.createTextNode(dom_1.sanitizeInput(content, this._options.invalidCharReplacement)); this.node.appendChild(child); return this; - } + }; /** @inheritdoc */ - com(content) { - const child = this._doc.createComment(dom_1.sanitizeInput(content, this._options.invalidCharReplacement)); + XMLBuilderImpl.prototype.com = function (content) { + var child = this._doc.createComment(dom_1.sanitizeInput(content, this._options.invalidCharReplacement)); this.node.appendChild(child); return this; - } + }; /** @inheritdoc */ - dat(content) { - const child = this._doc.createCDATASection(dom_1.sanitizeInput(content, this._options.invalidCharReplacement)); + XMLBuilderImpl.prototype.dat = function (content) { + var child = this._doc.createCDATASection(dom_1.sanitizeInput(content, this._options.invalidCharReplacement)); this.node.appendChild(child); return this; - } + }; /** @inheritdoc */ - ins(target, content = '') { + XMLBuilderImpl.prototype.ins = function (target, content) { + var _this = this; + if (content === void 0) { content = ''; } if (util_1.isArray(target) || util_1.isSet(target)) { - util_1.forEachArray(target, item => { + util_1.forEachArray(target, function (item) { item += ""; - const insIndex = item.indexOf(' '); - const insTarget = (insIndex === -1 ? item : item.substr(0, insIndex)); - const insValue = (insIndex === -1 ? '' : item.substr(insIndex + 1)); - this.ins(insTarget, insValue); + var insIndex = item.indexOf(' '); + var insTarget = (insIndex === -1 ? item : item.substr(0, insIndex)); + var insValue = (insIndex === -1 ? '' : item.substr(insIndex + 1)); + _this.ins(insTarget, insValue); }, this); } else if (util_1.isMap(target) || util_1.isObject(target)) { - util_1.forEachObject(target, (insTarget, insValue) => this.ins(insTarget, insValue), this); + util_1.forEachObject(target, function (insTarget, insValue) { return _this.ins(insTarget, insValue); }, this); } else { - const child = this._doc.createProcessingInstruction(dom_1.sanitizeInput(target, this._options.invalidCharReplacement), dom_1.sanitizeInput(content, this._options.invalidCharReplacement)); + var child = this._doc.createProcessingInstruction(dom_1.sanitizeInput(target, this._options.invalidCharReplacement), dom_1.sanitizeInput(content, this._options.invalidCharReplacement)); this.node.appendChild(child); } return this; - } + }; /** @inheritdoc */ - dec(options) { + XMLBuilderImpl.prototype.dec = function (options) { this._options.version = options.version || "1.0"; this._options.encoding = options.encoding; this._options.standalone = options.standalone; return this; - } + }; /** @inheritdoc */ - dtd(options) { - const name = dom_1.sanitizeInput((options && options.name) || (this._doc.documentElement ? this._doc.documentElement.tagName : "ROOT"), this._options.invalidCharReplacement); - const pubID = dom_1.sanitizeInput((options && options.pubID) || "", this._options.invalidCharReplacement); - const sysID = dom_1.sanitizeInput((options && options.sysID) || "", this._options.invalidCharReplacement); + XMLBuilderImpl.prototype.dtd = function (options) { + var name = dom_1.sanitizeInput((options && options.name) || (this._doc.documentElement ? this._doc.documentElement.tagName : "ROOT"), this._options.invalidCharReplacement); + var pubID = dom_1.sanitizeInput((options && options.pubID) || "", this._options.invalidCharReplacement); + var sysID = dom_1.sanitizeInput((options && options.sysID) || "", this._options.invalidCharReplacement); // name must match document element if (this._doc.documentElement !== null && name !== this._doc.documentElement.tagName) { throw new Error("DocType name does not match document element name."); } // create doctype node - const docType = this._doc.implementation.createDocumentType(name, pubID, sysID); + var docType = this._doc.implementation.createDocumentType(name, pubID, sysID); if (this._doc.doctype !== null) { // replace existing doctype this._doc.replaceChild(docType, this._doc.doctype); @@ -23252,197 +27760,242 @@ class XMLBuilderImpl { this._doc.insertBefore(docType, this._doc.documentElement); } return this; - } + }; /** @inheritdoc */ - import(node) { - const hostNode = this._domNode; - const hostDoc = this._doc; - const importedNode = node.node; + XMLBuilderImpl.prototype.import = function (node) { + var e_1, _a; + var hostNode = this._domNode; + var hostDoc = this._doc; + var importedNode = node.node; if (util_2.Guard.isDocumentNode(importedNode)) { // import document node - const elementNode = importedNode.documentElement; + var elementNode = importedNode.documentElement; if (elementNode === null) { throw new Error("Imported document has no document element node. " + this._debugInfo()); } - const clone = hostDoc.importNode(elementNode, true); + var clone = hostDoc.importNode(elementNode, true); hostNode.appendChild(clone); + var _b = __read(algorithm_1.namespace_extractQName(clone.prefix ? clone.prefix + ':' + clone.localName : clone.localName), 1), prefix = _b[0]; + var namespace = hostNode.lookupNamespaceURI(prefix); + new XMLBuilderImpl(clone)._updateNamespace(namespace); } else if (util_2.Guard.isDocumentFragmentNode(importedNode)) { - // import child nodes - for (const childNode of importedNode.childNodes) { - const clone = hostDoc.importNode(childNode, true); - hostNode.appendChild(clone); + try { + // import child nodes + for (var _c = __values(importedNode.childNodes), _d = _c.next(); !_d.done; _d = _c.next()) { + var childNode = _d.value; + var clone = hostDoc.importNode(childNode, true); + hostNode.appendChild(clone); + if (util_2.Guard.isElementNode(clone)) { + var _e = __read(algorithm_1.namespace_extractQName(clone.prefix ? clone.prefix + ':' + clone.localName : clone.localName), 1), prefix = _e[0]; + var namespace = hostNode.lookupNamespaceURI(prefix); + new XMLBuilderImpl(clone)._updateNamespace(namespace); + } + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_d && !_d.done && (_a = _c.return)) _a.call(_c); + } + finally { if (e_1) throw e_1.error; } } } else { // import node - const clone = hostDoc.importNode(importedNode, true); + var clone = hostDoc.importNode(importedNode, true); hostNode.appendChild(clone); + if (util_2.Guard.isElementNode(clone)) { + var _f = __read(algorithm_1.namespace_extractQName(clone.prefix ? clone.prefix + ':' + clone.localName : clone.localName), 1), prefix = _f[0]; + var namespace = hostNode.lookupNamespaceURI(prefix); + new XMLBuilderImpl(clone)._updateNamespace(namespace); + } } return this; - } + }; /** @inheritdoc */ - doc() { + XMLBuilderImpl.prototype.doc = function () { if (this._doc._isFragment) { - let node = this.node; + var node = this.node; while (node && node.nodeType !== interfaces_2.NodeType.DocumentFragment) { node = node.parentNode; } /* istanbul ignore next */ if (node === null) { - throw new Error("Node has no parent node while searching for document fragment ancestor."); + throw new Error("Node has no parent node while searching for document fragment ancestor. " + this._debugInfo()); } return new XMLBuilderImpl(node); } else { return new XMLBuilderImpl(this._doc); } - } + }; /** @inheritdoc */ - root() { - const ele = this._doc.documentElement; + XMLBuilderImpl.prototype.root = function () { + var ele = this._doc.documentElement; if (!ele) { throw new Error("Document root element is null. " + this._debugInfo()); } return new XMLBuilderImpl(ele); - } + }; /** @inheritdoc */ - up() { - const parent = this._domNode.parentNode; + XMLBuilderImpl.prototype.up = function () { + var parent = this._domNode.parentNode; if (!parent) { throw new Error("Parent node is null. " + this._debugInfo()); } return new XMLBuilderImpl(parent); - } + }; /** @inheritdoc */ - prev() { - const node = this._domNode.previousSibling; + XMLBuilderImpl.prototype.prev = function () { + var node = this._domNode.previousSibling; if (!node) { throw new Error("Previous sibling node is null. " + this._debugInfo()); } return new XMLBuilderImpl(node); - } + }; /** @inheritdoc */ - next() { - const node = this._domNode.nextSibling; + XMLBuilderImpl.prototype.next = function () { + var node = this._domNode.nextSibling; if (!node) { throw new Error("Next sibling node is null. " + this._debugInfo()); } return new XMLBuilderImpl(node); - } + }; /** @inheritdoc */ - first() { - const node = this._domNode.firstChild; + XMLBuilderImpl.prototype.first = function () { + var node = this._domNode.firstChild; if (!node) { throw new Error("First child node is null. " + this._debugInfo()); } return new XMLBuilderImpl(node); - } + }; /** @inheritdoc */ - last() { - const node = this._domNode.lastChild; + XMLBuilderImpl.prototype.last = function () { + var node = this._domNode.lastChild; if (!node) { throw new Error("Last child node is null. " + this._debugInfo()); } return new XMLBuilderImpl(node); - } + }; /** @inheritdoc */ - each(callback, self = false, recursive = false, thisArg) { - let result = this._getFirstDescendantNode(this._domNode, self, recursive); + XMLBuilderImpl.prototype.each = function (callback, self, recursive, thisArg) { + if (self === void 0) { self = false; } + if (recursive === void 0) { recursive = false; } + var result = this._getFirstDescendantNode(this._domNode, self, recursive); while (result[0]) { + var nextResult = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]); callback.call(thisArg, new XMLBuilderImpl(result[0]), result[1], result[2]); - result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]); + result = nextResult; } return this; - } + }; /** @inheritdoc */ - map(callback, self = false, recursive = false, thisArg) { - let result = []; - this.each((node, index, level) => result.push(callback.call(thisArg, node, index, level)), self, recursive); + XMLBuilderImpl.prototype.map = function (callback, self, recursive, thisArg) { + if (self === void 0) { self = false; } + if (recursive === void 0) { recursive = false; } + var result = []; + this.each(function (node, index, level) { + return result.push(callback.call(thisArg, node, index, level)); + }, self, recursive); return result; - } + }; /** @inheritdoc */ - reduce(callback, initialValue, self = false, recursive = false, thisArg) { - let value = initialValue; - this.each((node, index, level) => value = callback.call(thisArg, value, node, index, level), self, recursive); + XMLBuilderImpl.prototype.reduce = function (callback, initialValue, self, recursive, thisArg) { + if (self === void 0) { self = false; } + if (recursive === void 0) { recursive = false; } + var value = initialValue; + this.each(function (node, index, level) { + return value = callback.call(thisArg, value, node, index, level); + }, self, recursive); return value; - } + }; /** @inheritdoc */ - find(predicate, self = false, recursive = false, thisArg) { - let result = this._getFirstDescendantNode(this._domNode, self, recursive); + XMLBuilderImpl.prototype.find = function (predicate, self, recursive, thisArg) { + if (self === void 0) { self = false; } + if (recursive === void 0) { recursive = false; } + var result = this._getFirstDescendantNode(this._domNode, self, recursive); while (result[0]) { - const builder = new XMLBuilderImpl(result[0]); + var builder = new XMLBuilderImpl(result[0]); if (predicate.call(thisArg, builder, result[1], result[2])) { return builder; } result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]); } return undefined; - } + }; /** @inheritdoc */ - filter(predicate, self = false, recursive = false, thisArg) { - let result = []; - this.each((node, index, level) => { + XMLBuilderImpl.prototype.filter = function (predicate, self, recursive, thisArg) { + if (self === void 0) { self = false; } + if (recursive === void 0) { recursive = false; } + var result = []; + this.each(function (node, index, level) { if (predicate.call(thisArg, node, index, level)) { result.push(node); } }, self, recursive); return result; - } + }; /** @inheritdoc */ - every(predicate, self = false, recursive = false, thisArg) { - let result = this._getFirstDescendantNode(this._domNode, self, recursive); + XMLBuilderImpl.prototype.every = function (predicate, self, recursive, thisArg) { + if (self === void 0) { self = false; } + if (recursive === void 0) { recursive = false; } + var result = this._getFirstDescendantNode(this._domNode, self, recursive); while (result[0]) { - const builder = new XMLBuilderImpl(result[0]); + var builder = new XMLBuilderImpl(result[0]); if (!predicate.call(thisArg, builder, result[1], result[2])) { return false; } result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]); } return true; - } + }; /** @inheritdoc */ - some(predicate, self = false, recursive = false, thisArg) { - let result = this._getFirstDescendantNode(this._domNode, self, recursive); + XMLBuilderImpl.prototype.some = function (predicate, self, recursive, thisArg) { + if (self === void 0) { self = false; } + if (recursive === void 0) { recursive = false; } + var result = this._getFirstDescendantNode(this._domNode, self, recursive); while (result[0]) { - const builder = new XMLBuilderImpl(result[0]); + var builder = new XMLBuilderImpl(result[0]); if (predicate.call(thisArg, builder, result[1], result[2])) { return true; } result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]); } return false; - } + }; /** @inheritdoc */ - toArray(self = false, recursive = false) { - let result = []; - this.each(node => result.push(node), self, recursive); + XMLBuilderImpl.prototype.toArray = function (self, recursive) { + if (self === void 0) { self = false; } + if (recursive === void 0) { recursive = false; } + var result = []; + this.each(function (node) { return result.push(node); }, self, recursive); return result; - } + }; /** @inheritdoc */ - toString(writerOptions) { + XMLBuilderImpl.prototype.toString = function (writerOptions) { writerOptions = writerOptions || {}; if (writerOptions.format === undefined) { writerOptions.format = "xml"; } return this._serialize(writerOptions); - } + }; /** @inheritdoc */ - toObject(writerOptions) { + XMLBuilderImpl.prototype.toObject = function (writerOptions) { writerOptions = writerOptions || {}; if (writerOptions.format === undefined) { writerOptions.format = "object"; } return this._serialize(writerOptions); - } + }; /** @inheritdoc */ - end(writerOptions) { + XMLBuilderImpl.prototype.end = function (writerOptions) { writerOptions = writerOptions || {}; if (writerOptions.format === undefined) { writerOptions.format = "xml"; } return this.doc()._serialize(writerOptions); - } + }; /** * Gets the next descendant of the given node of the tree rooted at `root` * in depth-first pre-order. Returns a three-tuple with @@ -23453,14 +28006,14 @@ class XMLBuilderImpl { * @param recursive - whether to visit all descendant nodes in tree-order or * only the immediate child nodes */ - _getFirstDescendantNode(root, self, recursive) { + XMLBuilderImpl.prototype._getFirstDescendantNode = function (root, self, recursive) { if (self) return [this._domNode, 0, 0]; else if (recursive) return this._getNextDescendantNode(root, root, recursive, 0, 0); else return [this._domNode.firstChild, 0, 1]; - } + }; /** * Gets the next descendant of the given node of the tree rooted at `root` * in depth-first pre-order. Returns a three-tuple with @@ -23473,7 +28026,7 @@ class XMLBuilderImpl { * @param index - child node index * @param level - current depth of the XML tree */ - _getNextDescendantNode(root, node, recursive, index, level) { + XMLBuilderImpl.prototype._getNextDescendantNode = function (root, node, recursive, index, level) { if (recursive) { // traverse child nodes if (node.firstChild) @@ -23484,7 +28037,7 @@ class XMLBuilderImpl { if (node.nextSibling) return [node.nextSibling, index + 1, level]; // traverse parent's next sibling - let parent = node.parentNode; + var parent = node.parentNode; while (parent && parent !== root) { if (parent.nextSibling) return [parent.nextSibling, algorithm_1.tree_index(parent.nextSibling), level - 1]; @@ -23499,57 +28052,48 @@ class XMLBuilderImpl { return [node.nextSibling, index + 1, level]; } return [null, -1, -1]; - } + }; /** * Converts the node into its string or object representation. * * @param options - serialization options */ - _serialize(writerOptions) { + XMLBuilderImpl.prototype._serialize = function (writerOptions) { if (writerOptions.format === "xml") { - const writer = new writers_1.XMLWriter(this._options); - return writer.serialize(this.node, writerOptions); + var writer = new writers_1.XMLWriter(this._options, writerOptions); + return writer.serialize(this.node); } else if (writerOptions.format === "map") { - const writer = new writers_1.MapWriter(this._options); - return writer.serialize(this.node, writerOptions); + var writer = new writers_1.MapWriter(this._options, writerOptions); + return writer.serialize(this.node); } else if (writerOptions.format === "object") { - const writer = new writers_1.ObjectWriter(this._options); - return writer.serialize(this.node, writerOptions); + var writer = new writers_1.ObjectWriter(this._options, writerOptions); + return writer.serialize(this.node); } else if (writerOptions.format === "json") { - const writer = new writers_1.JSONWriter(this._options); - return writer.serialize(this.node, writerOptions); + var writer = new writers_1.JSONWriter(this._options, writerOptions); + return writer.serialize(this.node); + } + else if (writerOptions.format === "yaml") { + var writer = new writers_1.YAMLWriter(this._options, writerOptions); + return writer.serialize(this.node); } else { throw new Error("Invalid writer format: " + writerOptions.format + ". " + this._debugInfo()); } - } - /** - * Creates a dummy element node without adding it to the list of child nodes. - * - * Dummy nodes are special nodes representing a node with a `null` value. - * Dummy nodes are created while recursively building the XML tree. Simply - * skipping `null` values doesn't work because that would break the recursive - * chain. - * - * @returns the new dummy element node - */ - _dummy() { - return new XMLBuilderImpl(this._doc.createElement('dummy_node')); - } + }; /** * Extracts a namespace and name from the given string. * * @param namespace - namespace * @param name - a string containing both a name and namespace separated by an - * '@' character + * `'@'` character * @param ele - `true` if this is an element namespace; otherwise `false` */ - _extractNamespace(namespace, name, ele) { + XMLBuilderImpl.prototype._extractNamespace = function (namespace, name, ele) { // extract from name - const atIndex = name.indexOf("@"); + var atIndex = name.indexOf("@"); if (atIndex > 0) { if (namespace === undefined) namespace = name.slice(atIndex + 1); @@ -23561,99 +28105,201 @@ class XMLBuilderImpl { } else if (namespace !== null && namespace[0] === "@") { // look-up namespace aliases - const alias = namespace.slice(1); + var alias = namespace.slice(1); namespace = this._options.namespaceAlias[alias]; if (namespace === undefined) { throw new Error("Namespace alias `" + alias + "` is not defined. " + this._debugInfo()); } } return [namespace, name]; - } + }; /** - * Returns the document owning this node. + * Updates the element's namespace. + * + * @param ns - new namespace */ - get _doc() { - const node = this.node; - if (util_2.Guard.isDocumentNode(node)) { - return node; - } - else { - const docNode = node.ownerDocument; + XMLBuilderImpl.prototype._updateNamespace = function (ns) { + var e_2, _a, e_3, _b; + var ele = this._domNode; + if (util_2.Guard.isElementNode(ele) && ns !== null && ele.namespaceURI !== ns) { + var _c = __read(algorithm_1.namespace_extractQName(ele.prefix ? ele.prefix + ':' + ele.localName : ele.localName), 2), elePrefix = _c[0], eleLocalName = _c[1]; + // re-create the element node if its namespace changed + // we can't simply change the namespaceURI since its read-only + var newEle = algorithm_1.create_element(this._doc, eleLocalName, ns, elePrefix); + try { + for (var _d = __values(ele.attributes), _e = _d.next(); !_e.done; _e = _d.next()) { + var attr = _e.value; + var attrQName = attr.prefix ? attr.prefix + ':' + attr.localName : attr.localName; + var _f = __read(algorithm_1.namespace_extractQName(attrQName), 1), attrPrefix = _f[0]; + var newAttrNS = attr.namespaceURI; + if (newAttrNS === null && attrPrefix !== null) { + newAttrNS = ele.lookupNamespaceURI(attrPrefix); + } + if (newAttrNS === null) { + newEle.setAttribute(attrQName, attr.value); + } + else { + newEle.setAttributeNS(newAttrNS, attrQName, attr.value); + } + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_e && !_e.done && (_a = _d.return)) _a.call(_d); + } + finally { if (e_2) throw e_2.error; } + } + // replace the new node in parent node + var parent = ele.parentNode; /* istanbul ignore next */ - if (!docNode) - throw new Error("Owner document is null. " + this._debugInfo()); - return docNode; + if (parent === null) { + throw new Error("Parent node is null." + this._debugInfo()); + } + parent.replaceChild(newEle, ele); + this._domNode = newEle; + try { + // check child nodes + for (var _g = __values(ele.childNodes), _h = _g.next(); !_h.done; _h = _g.next()) { + var childNode = _h.value; + var newChildNode = childNode.cloneNode(true); + newEle.appendChild(newChildNode); + if (util_2.Guard.isElementNode(newChildNode)) { + var _j = __read(algorithm_1.namespace_extractQName(newChildNode.prefix ? newChildNode.prefix + ':' + newChildNode.localName : newChildNode.localName), 1), newChildNodePrefix = _j[0]; + var newChildNodeNS = newEle.lookupNamespaceURI(newChildNodePrefix); + new XMLBuilderImpl(newChildNode)._updateNamespace(newChildNodeNS); + } + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (_h && !_h.done && (_b = _g.return)) _b.call(_g); + } + finally { if (e_3) throw e_3.error; } + } } - } + }; + Object.defineProperty(XMLBuilderImpl.prototype, "_doc", { + /** + * Returns the document owning this node. + */ + get: function () { + var node = this.node; + if (util_2.Guard.isDocumentNode(node)) { + return node; + } + else { + var docNode = node.ownerDocument; + /* istanbul ignore next */ + if (!docNode) + throw new Error("Owner document is null. " + this._debugInfo()); + return docNode; + } + }, + enumerable: true, + configurable: true + }); /** * Returns debug information for this node. * * @param name - node name */ - _debugInfo(name) { - const node = this.node; - const parentNode = node.parentNode; + XMLBuilderImpl.prototype._debugInfo = function (name) { + var node = this.node; + var parentNode = node.parentNode; name = name || node.nodeName; - const parentName = parentNode ? parentNode.nodeName : ''; + var parentName = parentNode ? parentNode.nodeName : ''; if (!parentName) { return "node: <" + name + ">"; } else { return "node: <" + name + ">, parent: <" + parentName + ">"; } - } - /** - * Gets or sets builder options. - */ - get _options() { - const doc = this._doc; - /* istanbul ignore next */ - if (doc._xmlBuilderOptions === undefined) { - throw new Error("Builder options is not set."); - } - return doc._xmlBuilderOptions; - } - set _options(value) { - const doc = this._doc; - doc._xmlBuilderOptions = value; - } -} + }; + Object.defineProperty(XMLBuilderImpl.prototype, "_options", { + /** + * Gets or sets builder options. + */ + get: function () { + var doc = this._doc; + /* istanbul ignore next */ + if (doc._xmlBuilderOptions === undefined) { + throw new Error("Builder options is not set."); + } + return doc._xmlBuilderOptions; + }, + set: function (value) { + var doc = this._doc; + doc._xmlBuilderOptions = value; + }, + enumerable: true, + configurable: true + }); + return XMLBuilderImpl; +}()); exports.XMLBuilderImpl = XMLBuilderImpl; //# sourceMappingURL=XMLBuilderImpl.js.map /***/ }), - -/***/ 597: +/* 596 */, +/* 597 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const DOMException_1 = __webpack_require__(35); -const util_1 = __webpack_require__(918); -const algorithm_1 = __webpack_require__(163); +var DOMException_1 = __webpack_require__(35); +var util_1 = __webpack_require__(918); +var algorithm_1 = __webpack_require__(163); /** * Represents a target to which an event can be dispatched. */ -class EventTargetImpl { +var EventTargetImpl = /** @class */ (function () { /** * Initializes a new instance of `EventTarget`. */ - constructor() { } - get _eventListenerList() { - return this.__eventListenerList || (this.__eventListenerList = []); - } - get _eventHandlerMap() { - return this.__eventHandlerMap || (this.__eventHandlerMap = {}); + function EventTargetImpl() { } + Object.defineProperty(EventTargetImpl.prototype, "_eventListenerList", { + get: function () { + return this.__eventListenerList || (this.__eventListenerList = []); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EventTargetImpl.prototype, "_eventHandlerMap", { + get: function () { + return this.__eventHandlerMap || (this.__eventHandlerMap = {}); + }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - addEventListener(type, callback, options = { passive: false, once: false, capture: false }) { + EventTargetImpl.prototype.addEventListener = function (type, callback, options) { + if (options === void 0) { options = { passive: false, once: false, capture: false }; } /** * 1. Let capture, passive, and once be the result of flattening more options. */ - const [capture, passive, once] = algorithm_1.eventTarget_flattenMore(options); + var _a = __read(algorithm_1.eventTarget_flattenMore(options), 3), capture = _a[0], passive = _a[1], once = _a[2]; // convert callback function to EventListener, return if null - let listenerCallback; + var listenerCallback; if (!callback) { return; } @@ -23676,9 +28322,9 @@ class EventTargetImpl { once: once, removed: false }); - } + }; /** @inheritdoc */ - removeEventListener(type, callback, options = { capture: false }) { + EventTargetImpl.prototype.removeEventListener = function (type, callback, options) { /** * TODO: Implement realms * 1. If the context object’s relevant global object is a @@ -23686,10 +28332,11 @@ class EventTargetImpl { * script resource’s has ever been evaluated flag is set, then throw * a TypeError. [SERVICE-WORKERS] */ + if (options === void 0) { options = { capture: false }; } /** * 2. Let capture be the result of flattening options. */ - const capture = algorithm_1.eventTarget_flatten(options); + var capture = algorithm_1.eventTarget_flatten(options); if (!callback) return; /** @@ -23697,8 +28344,8 @@ class EventTargetImpl { * whose type is type, callback is callback, and capture is capture, then * remove an event listener with the context object and that event listener. */ - for (let i = 0; i < this._eventListenerList.length; i++) { - const entry = this._eventListenerList[i]; + for (var i = 0; i < this._eventListenerList.length; i++) { + var entry = this._eventListenerList[i]; if (entry.type !== type || entry.capture !== capture) continue; if (util_1.Guard.isEventListener(callback) && entry.callback === callback) { @@ -23710,9 +28357,9 @@ class EventTargetImpl { break; } } - } + }; /** @inheritdoc */ - dispatchEvent(event) { + EventTargetImpl.prototype.dispatchEvent = function (event) { /** * 1. If event’s dispatch flag is set, or if its initialized flag is not * set, then throw an "InvalidStateError" DOMException. @@ -23724,71 +28371,547 @@ class EventTargetImpl { } event._isTrusted = false; return algorithm_1.event_dispatch(event, this); - } + }; /** @inheritdoc */ - _getTheParent(event) { + EventTargetImpl.prototype._getTheParent = function (event) { return null; - } -} + }; + return EventTargetImpl; +}()); exports.EventTargetImpl = EventTargetImpl; //# sourceMappingURL=EventTargetImpl.js.map /***/ }), - -/***/ 605: +/* 598 */, +/* 599 */, +/* 600 */, +/* 601 */, +/* 602 */, +/* 603 */, +/* 604 */, +/* 605 */ /***/ (function(module) { module.exports = require("http"); /***/ }), +/* 606 */, +/* 607 */, +/* 608 */, +/* 609 */, +/* 610 */, +/* 611 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 609: -/***/ (function(__unusedmodule, exports) { +"use strict"; +// Standard YAML's Core schema. +// http://www.yaml.org/spec/1.2/spec.html#id2804923 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, Core schema has no distinctions from JSON schema is JS-YAML. + + + + + +var Schema = __webpack_require__(733); + + +module.exports = new Schema({ + include: [ + __webpack_require__(720) + ] +}); + + +/***/ }), +/* 612 */ +/***/ (function(module, __unusedexports, __webpack_require__) { "use strict"; -Object.defineProperty(exports, "__esModule", { value: true }); -exports.HTML = "http://www.w3.org/1999/xhtml"; -exports.XML = "http://www.w3.org/XML/1998/namespace"; -exports.XMLNS = "http://www.w3.org/2000/xmlns/"; -exports.MathML = "http://www.w3.org/1998/Math/MathML"; -exports.SVG = "http://www.w3.org/2000/svg"; -exports.XLink = "http://www.w3.org/1999/xlink"; -//# sourceMappingURL=Namespace.js.map +module.exports = Yallist + +Yallist.Node = Node +Yallist.create = Yallist + +function Yallist (list) { + var self = this + if (!(self instanceof Yallist)) { + self = new Yallist() + } + + self.tail = null + self.head = null + self.length = 0 + + if (list && typeof list.forEach === 'function') { + list.forEach(function (item) { + self.push(item) + }) + } else if (arguments.length > 0) { + for (var i = 0, l = arguments.length; i < l; i++) { + self.push(arguments[i]) + } + } + + return self +} + +Yallist.prototype.removeNode = function (node) { + if (node.list !== this) { + throw new Error('removing node which does not belong to this list') + } + + var next = node.next + var prev = node.prev + + if (next) { + next.prev = prev + } + + if (prev) { + prev.next = next + } + + if (node === this.head) { + this.head = next + } + if (node === this.tail) { + this.tail = prev + } + + node.list.length-- + node.next = null + node.prev = null + node.list = null + + return next +} + +Yallist.prototype.unshiftNode = function (node) { + if (node === this.head) { + return + } + + if (node.list) { + node.list.removeNode(node) + } + + var head = this.head + node.list = this + node.next = head + if (head) { + head.prev = node + } + + this.head = node + if (!this.tail) { + this.tail = node + } + this.length++ +} + +Yallist.prototype.pushNode = function (node) { + if (node === this.tail) { + return + } + + if (node.list) { + node.list.removeNode(node) + } + + var tail = this.tail + node.list = this + node.prev = tail + if (tail) { + tail.next = node + } + + this.tail = node + if (!this.head) { + this.head = node + } + this.length++ +} + +Yallist.prototype.push = function () { + for (var i = 0, l = arguments.length; i < l; i++) { + push(this, arguments[i]) + } + return this.length +} + +Yallist.prototype.unshift = function () { + for (var i = 0, l = arguments.length; i < l; i++) { + unshift(this, arguments[i]) + } + return this.length +} + +Yallist.prototype.pop = function () { + if (!this.tail) { + return undefined + } + + var res = this.tail.value + this.tail = this.tail.prev + if (this.tail) { + this.tail.next = null + } else { + this.head = null + } + this.length-- + return res +} + +Yallist.prototype.shift = function () { + if (!this.head) { + return undefined + } + + var res = this.head.value + this.head = this.head.next + if (this.head) { + this.head.prev = null + } else { + this.tail = null + } + this.length-- + return res +} + +Yallist.prototype.forEach = function (fn, thisp) { + thisp = thisp || this + for (var walker = this.head, i = 0; walker !== null; i++) { + fn.call(thisp, walker.value, i, this) + walker = walker.next + } +} + +Yallist.prototype.forEachReverse = function (fn, thisp) { + thisp = thisp || this + for (var walker = this.tail, i = this.length - 1; walker !== null; i--) { + fn.call(thisp, walker.value, i, this) + walker = walker.prev + } +} + +Yallist.prototype.get = function (n) { + for (var i = 0, walker = this.head; walker !== null && i < n; i++) { + // abort out of the list early if we hit a cycle + walker = walker.next + } + if (i === n && walker !== null) { + return walker.value + } +} + +Yallist.prototype.getReverse = function (n) { + for (var i = 0, walker = this.tail; walker !== null && i < n; i++) { + // abort out of the list early if we hit a cycle + walker = walker.prev + } + if (i === n && walker !== null) { + return walker.value + } +} + +Yallist.prototype.map = function (fn, thisp) { + thisp = thisp || this + var res = new Yallist() + for (var walker = this.head; walker !== null;) { + res.push(fn.call(thisp, walker.value, this)) + walker = walker.next + } + return res +} + +Yallist.prototype.mapReverse = function (fn, thisp) { + thisp = thisp || this + var res = new Yallist() + for (var walker = this.tail; walker !== null;) { + res.push(fn.call(thisp, walker.value, this)) + walker = walker.prev + } + return res +} + +Yallist.prototype.reduce = function (fn, initial) { + var acc + var walker = this.head + if (arguments.length > 1) { + acc = initial + } else if (this.head) { + walker = this.head.next + acc = this.head.value + } else { + throw new TypeError('Reduce of empty list with no initial value') + } + + for (var i = 0; walker !== null; i++) { + acc = fn(acc, walker.value, i) + walker = walker.next + } + + return acc +} + +Yallist.prototype.reduceReverse = function (fn, initial) { + var acc + var walker = this.tail + if (arguments.length > 1) { + acc = initial + } else if (this.tail) { + walker = this.tail.prev + acc = this.tail.value + } else { + throw new TypeError('Reduce of empty list with no initial value') + } + + for (var i = this.length - 1; walker !== null; i--) { + acc = fn(acc, walker.value, i) + walker = walker.prev + } + + return acc +} + +Yallist.prototype.toArray = function () { + var arr = new Array(this.length) + for (var i = 0, walker = this.head; walker !== null; i++) { + arr[i] = walker.value + walker = walker.next + } + return arr +} + +Yallist.prototype.toArrayReverse = function () { + var arr = new Array(this.length) + for (var i = 0, walker = this.tail; walker !== null; i++) { + arr[i] = walker.value + walker = walker.prev + } + return arr +} + +Yallist.prototype.slice = function (from, to) { + to = to || this.length + if (to < 0) { + to += this.length + } + from = from || 0 + if (from < 0) { + from += this.length + } + var ret = new Yallist() + if (to < from || to < 0) { + return ret + } + if (from < 0) { + from = 0 + } + if (to > this.length) { + to = this.length + } + for (var i = 0, walker = this.head; walker !== null && i < from; i++) { + walker = walker.next + } + for (; walker !== null && i < to; i++, walker = walker.next) { + ret.push(walker.value) + } + return ret +} + +Yallist.prototype.sliceReverse = function (from, to) { + to = to || this.length + if (to < 0) { + to += this.length + } + from = from || 0 + if (from < 0) { + from += this.length + } + var ret = new Yallist() + if (to < from || to < 0) { + return ret + } + if (from < 0) { + from = 0 + } + if (to > this.length) { + to = this.length + } + for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) { + walker = walker.prev + } + for (; walker !== null && i > from; i--, walker = walker.prev) { + ret.push(walker.value) + } + return ret +} + +Yallist.prototype.splice = function (start, deleteCount, ...nodes) { + if (start > this.length) { + start = this.length - 1 + } + if (start < 0) { + start = this.length + start; + } + + for (var i = 0, walker = this.head; walker !== null && i < start; i++) { + walker = walker.next + } + + var ret = [] + for (var i = 0; walker && i < deleteCount; i++) { + ret.push(walker.value) + walker = this.removeNode(walker) + } + if (walker === null) { + walker = this.tail + } + + if (walker !== this.head && walker !== this.tail) { + walker = walker.prev + } + + for (var i = 0; i < nodes.length; i++) { + walker = insert(this, walker, nodes[i]) + } + return ret; +} + +Yallist.prototype.reverse = function () { + var head = this.head + var tail = this.tail + for (var walker = head; walker !== null; walker = walker.prev) { + var p = walker.prev + walker.prev = walker.next + walker.next = p + } + this.head = tail + this.tail = head + return this +} + +function insert (self, node, value) { + var inserted = node === self.head ? + new Node(value, null, node, self) : + new Node(value, node, node.next, self) + + if (inserted.next === null) { + self.tail = inserted + } + if (inserted.prev === null) { + self.head = inserted + } + + self.length++ + + return inserted +} + +function push (self, item) { + self.tail = new Node(item, self.tail, null, self) + if (!self.head) { + self.head = self.tail + } + self.length++ +} + +function unshift (self, item) { + self.head = new Node(item, null, self.head, self) + if (!self.tail) { + self.tail = self.head + } + self.length++ +} + +function Node (value, prev, next, list) { + if (!(this instanceof Node)) { + return new Node(value, prev, next, list) + } + + this.list = list + this.value = value + + if (prev) { + prev.next = this + this.prev = prev + } else { + this.prev = null + } + + if (next) { + next.prev = this + this.next = next + } else { + this.next = null + } +} + +try { + // add if support for Symbol.iterator is present + __webpack_require__(396)(Yallist) +} catch (er) {} + /***/ }), - -/***/ 614: +/* 613 */, +/* 614 */ /***/ (function(module) { module.exports = require("events"); /***/ }), - -/***/ 619: +/* 615 */, +/* 616 */, +/* 617 */, +/* 618 */, +/* 619 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const CharacterDataImpl_1 = __webpack_require__(43); -const WebIDLAlgorithm_1 = __webpack_require__(495); +var interfaces_1 = __webpack_require__(970); +var CharacterDataImpl_1 = __webpack_require__(43); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** * Represents a processing instruction node. */ -class ProcessingInstructionImpl extends CharacterDataImpl_1.CharacterDataImpl { +var ProcessingInstructionImpl = /** @class */ (function (_super) { + __extends(ProcessingInstructionImpl, _super); /** * Initializes a new instance of `ProcessingInstruction`. */ - constructor(target, data) { - super(data); - this._target = target; + function ProcessingInstructionImpl(target, data) { + var _this = _super.call(this, data) || this; + _this._target = target; + return _this; } - /** - * Gets the target of the {@link ProcessingInstruction} node. - */ - get target() { return this._target; } + Object.defineProperty(ProcessingInstructionImpl.prototype, "target", { + /** + * Gets the target of the {@link ProcessingInstruction} node. + */ + get: function () { return this._target; }, + enumerable: true, + configurable: true + }); /** * Creates a new `ProcessingInstruction`. * @@ -23796,12 +28919,13 @@ class ProcessingInstructionImpl extends CharacterDataImpl_1.CharacterDataImpl { * @param target - instruction target * @param data - node contents */ - static _create(document, target, data) { - const node = new ProcessingInstructionImpl(target, data); + ProcessingInstructionImpl._create = function (document, target, data) { + var node = new ProcessingInstructionImpl(target, data); node._nodeDocument = document; return node; - } -} + }; + return ProcessingInstructionImpl; +}(CharacterDataImpl_1.CharacterDataImpl)); exports.ProcessingInstructionImpl = ProcessingInstructionImpl; /** * Initialize prototype properties @@ -23810,15 +28934,17 @@ WebIDLAlgorithm_1.idl_defineConst(ProcessingInstructionImpl.prototype, "_nodeTyp //# sourceMappingURL=ProcessingInstructionImpl.js.map /***/ }), - -/***/ 622: +/* 620 */, +/* 621 */, +/* 622 */ /***/ (function(module) { module.exports = require("path"); /***/ }), - -/***/ 625: +/* 623 */, +/* 624 */, +/* 625 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -23853,7 +28979,8 @@ exports.DefaultBuilderOptions = { svg: "http://www.w3.org/2000/svg", xlink: "http://www.w3.org/1999/xlink" }, - invalidCharReplacement: undefined + invalidCharReplacement: undefined, + parser: undefined }; /** * Contains keys of `XMLBuilderOptions`. @@ -23898,49 +29025,163 @@ exports.DefaultXMLBuilderCBOptions = { //# sourceMappingURL=interfaces.js.map /***/ }), +/* 626 */, +/* 627 */, +/* 628 */, +/* 629 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 631: +"use strict"; + + +var Type = __webpack_require__(945); + +function resolveJavascriptRegExp(data) { + if (data === null) return false; + if (data.length === 0) return false; + + var regexp = data, + tail = /\/([gim]*)$/.exec(data), + modifiers = ''; + + // if regexp starts with '/' it can have modifiers and must be properly closed + // `/foo/gim` - modifiers tail can be maximum 3 chars + if (regexp[0] === '/') { + if (tail) modifiers = tail[1]; + + if (modifiers.length > 3) return false; + // if expression starts with /, is should be properly terminated + if (regexp[regexp.length - modifiers.length - 1] !== '/') return false; + } + + return true; +} + +function constructJavascriptRegExp(data) { + var regexp = data, + tail = /\/([gim]*)$/.exec(data), + modifiers = ''; + + // `/foo/gim` - tail can be maximum 4 chars + if (regexp[0] === '/') { + if (tail) modifiers = tail[1]; + regexp = regexp.slice(1, regexp.length - modifiers.length - 1); + } + + return new RegExp(regexp, modifiers); +} + +function representJavascriptRegExp(object /*, style*/) { + var result = '/' + object.source + '/'; + + if (object.global) result += 'g'; + if (object.multiline) result += 'm'; + if (object.ignoreCase) result += 'i'; + + return result; +} + +function isRegExp(object) { + return Object.prototype.toString.call(object) === '[object RegExp]'; +} + +module.exports = new Type('tag:yaml.org,2002:js/regexp', { + kind: 'scalar', + resolve: resolveJavascriptRegExp, + construct: constructJavascriptRegExp, + predicate: isRegExp, + represent: representJavascriptRegExp +}); + + +/***/ }), +/* 630 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const rcompare = (a, b, loose) => compare(b, a, loose) +module.exports = rcompare + + +/***/ }), +/* 631 */ /***/ (function(module) { module.exports = require("net"); /***/ }), +/* 632 */, +/* 633 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 636: +"use strict"; + + +var Type = __webpack_require__(945); + +function resolveYamlMerge(data) { + return data === '<<' || data === null; +} + +module.exports = new Type('tag:yaml.org,2002:merge', { + kind: 'scalar', + resolve: resolveYamlMerge +}); + + +/***/ }), +/* 634 */, +/* 635 */, +/* 636 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const _1 = __webpack_require__(113); -const util_1 = __webpack_require__(337); -const algorithm_1 = __webpack_require__(163); +var DOMImpl_1 = __webpack_require__(648); +var util_1 = __webpack_require__(592); +var algorithm_1 = __webpack_require__(163); /** * Represents an ordered set of nodes. */ -class NodeListImpl { +var NodeListImpl = /** @class */ (function () { /** * Initializes a new instance of `NodeList`. * * @param root - root node */ - constructor(root) { + function NodeListImpl(root) { this._live = true; this._filter = null; this._length = 0; this._root = root; return new Proxy(this, this); } + Object.defineProperty(NodeListImpl.prototype, "length", { + /** @inheritdoc */ + get: function () { + /** + * The length attribute must return the number of nodes represented + * by the collection. + */ + return this._root._children.size; + }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get length() { - /** - * The length attribute must return the number of nodes represented - * by the collection. - */ - return this._root._children.size; - } - /** @inheritdoc */ - item(index) { + NodeListImpl.prototype.item = function (index) { /** * The item(index) method must return the indexth node in the collection. * If there is no indexth node in the collection, then the method must @@ -23949,8 +29190,8 @@ class NodeListImpl { if (index < 0 || index > this.length - 1) return null; if (index < this.length / 2) { - let i = 0; - let node = this._root._firstChild; + var i = 0; + var node = this._root._firstChild; while (node !== null && i !== index) { node = node._nextSibling; i++; @@ -23958,20 +29199,21 @@ class NodeListImpl { return node; } else { - let i = this.length - 1; - let node = this._root._lastChild; + var i = this.length - 1; + var node = this._root._lastChild; while (node !== null && i !== index) { node = node._previousSibling; i--; } return node; } - } + }; /** @inheritdoc */ - keys() { - return { - [Symbol.iterator]: function () { - let index = 0; + NodeListImpl.prototype.keys = function () { + var _a; + return _a = {}, + _a[Symbol.iterator] = function () { + var index = 0; return { next: function () { if (index === this.length) { @@ -23982,31 +29224,33 @@ class NodeListImpl { } }.bind(this) }; - }.bind(this) - }; - } + }.bind(this), + _a; + }; /** @inheritdoc */ - values() { - return { - [Symbol.iterator]: function () { - const it = this[Symbol.iterator](); + NodeListImpl.prototype.values = function () { + var _a; + return _a = {}, + _a[Symbol.iterator] = function () { + var it = this[Symbol.iterator](); return { - next() { + next: function () { return it.next(); } }; - }.bind(this) - }; - } + }.bind(this), + _a; + }; /** @inheritdoc */ - entries() { - return { - [Symbol.iterator]: function () { - const it = this[Symbol.iterator](); - let index = 0; + NodeListImpl.prototype.entries = function () { + var _a; + return _a = {}, + _a[Symbol.iterator] = function () { + var it = this[Symbol.iterator](); + var index = 0; return { - next() { - const itResult = it.next(); + next: function () { + var itResult = it.next(); if (itResult.done) { return { done: true, value: null }; } @@ -24015,48 +29259,59 @@ class NodeListImpl { } } }; - }.bind(this) - }; - } + }.bind(this), + _a; + }; /** @inheritdoc */ - [Symbol.iterator]() { + NodeListImpl.prototype[Symbol.iterator] = function () { return this._root._children[Symbol.iterator](); - } + }; /** @inheritdoc */ - forEach(callback, thisArg) { + NodeListImpl.prototype.forEach = function (callback, thisArg) { + var e_1, _a; if (thisArg === undefined) { - thisArg = _1.dom.window; + thisArg = DOMImpl_1.dom.window; } - let index = 0; - for (const node of this._root._children) { - callback.call(thisArg, node, index++, this); + var index = 0; + try { + for (var _b = __values(this._root._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var node = _c.value; + callback.call(thisArg, node, index++, this); + } } - } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + }; /** * Implements a proxy get trap to provide array-like access. */ - get(target, key, receiver) { + NodeListImpl.prototype.get = function (target, key, receiver) { if (!util_1.isString(key)) { return Reflect.get(target, key, receiver); } - const index = Number(key); + var index = Number(key); if (isNaN(index)) { return Reflect.get(target, key, receiver); } return target.item(index) || undefined; - } + }; /** * Implements a proxy set trap to provide array-like access. */ - set(target, key, value, receiver) { + NodeListImpl.prototype.set = function (target, key, value, receiver) { if (!util_1.isString(key)) { return Reflect.set(target, key, value, receiver); } - const index = Number(key); + var index = Number(key); if (isNaN(index)) { return Reflect.set(target, key, value, receiver); } - const node = target.item(index) || undefined; + var node = target.item(index) || undefined; if (!node) return false; if (node._parent) { @@ -24066,92 +29321,121 @@ class NodeListImpl { else { return false; } - } + }; /** * Creates a new `NodeList`. * * @param root - root node */ - static _create(root) { + NodeListImpl._create = function (root) { return new NodeListImpl(root); - } -} + }; + return NodeListImpl; +}()); exports.NodeListImpl = NodeListImpl; //# sourceMappingURL=NodeListImpl.js.map /***/ }), - -/***/ 642: +/* 637 */, +/* 638 */, +/* 639 */, +/* 640 */, +/* 641 */, +/* 642 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const algorithm_1 = __webpack_require__(163); -const XMLParserImpl_1 = __webpack_require__(468); +var algorithm_1 = __webpack_require__(163); +var XMLParserImpl_1 = __webpack_require__(468); /** * Represents a parser for XML and HTML content. * * See: https://w3c.github.io/DOM-Parsing/#the-domparser-interface */ -class DOMParserImpl { +var DOMParserImpl = /** @class */ (function () { + function DOMParserImpl() { + } /** @inheritdoc */ - parseFromString(source, mimeType) { + DOMParserImpl.prototype.parseFromString = function (source, mimeType) { if (mimeType === "text/html") throw new Error('HTML parser not implemented.'); try { - const parser = new XMLParserImpl_1.XMLParserImpl(); - const doc = parser.parse(source); + var parser = new XMLParserImpl_1.XMLParserImpl(); + var doc = parser.parse(source); doc._contentType = mimeType; return doc; } catch (e) { - const errorNS = "http://www.mozilla.org/newlayout/xml/parsererror.xml"; - const doc = algorithm_1.create_xmlDocument(); - const root = doc.createElementNS(errorNS, "parsererror"); - const ele = doc.createElementNS(errorNS, "error"); + var errorNS = "http://www.mozilla.org/newlayout/xml/parsererror.xml"; + var doc = algorithm_1.create_xmlDocument(); + var root = doc.createElementNS(errorNS, "parsererror"); + var ele = doc.createElementNS(errorNS, "error"); ele.setAttribute("message", e.message); root.appendChild(ele); doc.appendChild(root); return doc; } - } -} + }; + return DOMParserImpl; +}()); exports.DOMParserImpl = DOMParserImpl; //# sourceMappingURL=DOMParserImpl.js.map /***/ }), - -/***/ 646: +/* 643 */, +/* 644 */, +/* 645 */, +/* 646 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const TraverserImpl_1 = __webpack_require__(487); -const algorithm_1 = __webpack_require__(163); +var interfaces_1 = __webpack_require__(970); +var TraverserImpl_1 = __webpack_require__(487); +var algorithm_1 = __webpack_require__(163); /** * Represents the nodes of a subtree and a position within them. */ -class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl { +var TreeWalkerImpl = /** @class */ (function (_super) { + __extends(TreeWalkerImpl, _super); /** * Initializes a new instance of `TreeWalker`. */ - constructor(root, current) { - super(root); - this._current = current; + function TreeWalkerImpl(root, current) { + var _this = _super.call(this, root) || this; + _this._current = current; + return _this; } + Object.defineProperty(TreeWalkerImpl.prototype, "currentNode", { + /** @inheritdoc */ + get: function () { return this._current; }, + set: function (value) { this._current = value; }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get currentNode() { return this._current; } - set currentNode(value) { this._current = value; } - /** @inheritdoc */ - parentNode() { + TreeWalkerImpl.prototype.parentNode = function () { /** * 1. Let node be the context object’s current. * 2. While node is non-null and is not the context object’s root: */ - let node = this._current; + var node = this._current; while (node !== null && node !== this._root) { /** * 2.1. Set node to node’s parent. @@ -24170,44 +29454,44 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl { * 3. Return null. */ return null; - } + }; /** @inheritdoc */ - firstChild() { + TreeWalkerImpl.prototype.firstChild = function () { /** * The firstChild() method, when invoked, must traverse children with the * context object and first. */ return algorithm_1.treeWalker_traverseChildren(this, true); - } + }; /** @inheritdoc */ - lastChild() { + TreeWalkerImpl.prototype.lastChild = function () { /** * The lastChild() method, when invoked, must traverse children with the * context object and last. */ return algorithm_1.treeWalker_traverseChildren(this, false); - } + }; /** @inheritdoc */ - nextSibling() { + TreeWalkerImpl.prototype.nextSibling = function () { /** * The nextSibling() method, when invoked, must traverse siblings with the * context object and next. */ return algorithm_1.treeWalker_traverseSiblings(this, true); - } + }; /** @inheritdoc */ - previousNode() { + TreeWalkerImpl.prototype.previousNode = function () { /** * 1. Let node be the context object’s current. * 2. While node is not the context object’s root: */ - let node = this._current; + var node = this._current; while (node !== this._root) { /** * 2.1. Let sibling be node’s previous sibling. * 2.2. While sibling is non-null: */ - let sibling = node._previousSibling; + var sibling = node._previousSibling; while (sibling) { /** * 2.2.1. Set node to sibling. @@ -24215,7 +29499,7 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl { * object. */ node = sibling; - let result = algorithm_1.traversal_filter(this, node); + var result = algorithm_1.traversal_filter(this, node); /** * 2.2.3. While result is not FILTER_REJECT and node has a child: */ @@ -24266,24 +29550,24 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl { * 3. Return null. */ return null; - } + }; /** @inheritdoc */ - previousSibling() { + TreeWalkerImpl.prototype.previousSibling = function () { /** * The previousSibling() method, when invoked, must traverse siblings with * the context object and previous. */ return algorithm_1.treeWalker_traverseSiblings(this, false); - } + }; /** @inheritdoc */ - nextNode() { + TreeWalkerImpl.prototype.nextNode = function () { /** * 1. Let node be the context object’s current. * 2. Let result be FILTER_ACCEPT. * 3. While true: */ - let node = this._current; - let result = interfaces_1.FilterResult.Accept; + var node = this._current; + var result = interfaces_1.FilterResult.Accept; while (true) { /** * 3.1. While result is not FILTER_REJECT and node has a child: @@ -24308,8 +29592,8 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl { * 3.3. Let temporary be node. * 3.4. While temporary is non-null: */ - let sibling = null; - let temporary = node; + var sibling = null; + var temporary = node; while (temporary !== null) { /** * 3.4.1. If temporary is the context object’s root, then return null. @@ -24342,38 +29626,39 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl { return node; } } - } + }; /** * Creates a new `TreeWalker`. * * @param root - iterator's root node * @param current - current node */ - static _create(root, current) { + TreeWalkerImpl._create = function (root, current) { return new TreeWalkerImpl(root, current); - } -} + }; + return TreeWalkerImpl; +}(TraverserImpl_1.TraverserImpl)); exports.TreeWalkerImpl = TreeWalkerImpl; //# sourceMappingURL=TreeWalkerImpl.js.map /***/ }), - -/***/ 648: +/* 647 */, +/* 648 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(337); -const algorithm_1 = __webpack_require__(163); +var util_1 = __webpack_require__(592); +var CreateAlgorithm_1 = __webpack_require__(86); /** * Represents an object implementing DOM algorithms. */ -class DOMImpl { +var DOMImpl = /** @class */ (function () { /** * Initializes a new instance of `DOM`. */ - constructor() { + function DOMImpl() { this._features = { mutationObservers: true, customElements: true, @@ -24390,52 +29675,73 @@ class DOMImpl { * @param features - DOM features supported by algorithms. All features are * enabled by default unless explicity disabled. */ - setFeatures(features) { + DOMImpl.prototype.setFeatures = function (features) { if (features === undefined) features = true; if (util_1.isObject(features)) { - for (const key in features) { + for (var key in features) { this._features[key] = features[key] || false; } } else { // enable/disable all features - for (const key in this._features) { + for (var key in this._features) { this._features[key] = features; } } - } - /** - * Gets DOM algorithm features. - */ - get features() { return this._features; } - /** - * Gets the DOM window. - */ - get window() { - if (this._window === null) { - this._window = algorithm_1.create_window(); - } - return this._window; - } - /** - * Gets the global node compare cache. - */ - get compareCache() { return this._compareCache; } - /** - * Gets the global range list. - */ - get rangeList() { return this._rangeList; } - /** - * Returns the instance of `DOM`. - */ - static get instance() { - if (!DOMImpl._instance) { - DOMImpl._instance = new DOMImpl(); - } - return DOMImpl._instance; - } -} + }; + Object.defineProperty(DOMImpl.prototype, "features", { + /** + * Gets DOM algorithm features. + */ + get: function () { return this._features; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DOMImpl.prototype, "window", { + /** + * Gets the DOM window. + */ + get: function () { + if (this._window === null) { + this._window = CreateAlgorithm_1.create_window(); + } + return this._window; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DOMImpl.prototype, "compareCache", { + /** + * Gets the global node compare cache. + */ + get: function () { return this._compareCache; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DOMImpl.prototype, "rangeList", { + /** + * Gets the global range list. + */ + get: function () { return this._rangeList; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DOMImpl, "instance", { + /** + * Returns the instance of `DOM`. + */ + get: function () { + if (!DOMImpl._instance) { + DOMImpl._instance = new DOMImpl(); + } + return DOMImpl._instance; + }, + enumerable: true, + configurable: true + }); + return DOMImpl; +}()); /** * Represents an object implementing DOM algorithms. */ @@ -24443,14 +29749,90 @@ exports.dom = DOMImpl.instance; //# sourceMappingURL=DOMImpl.js.map /***/ }), +/* 649 */, +/* 650 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 657: +const parse = __webpack_require__(830) +const prerelease = (version, options) => { + const parsed = parse(version, options) + return (parsed && parsed.prerelease.length) ? parsed.prerelease : null +} +module.exports = prerelease + + +/***/ }), +/* 651 */, +/* 652 */, +/* 653 */, +/* 654 */, +/* 655 */, +/* 656 */, +/* 657 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(68); +var util_1 = __webpack_require__(592); /** * Adds the given item to the end of the list. * @@ -24468,7 +29850,7 @@ exports.append = append; * @param listB - a list containing items to append to `listA` */ function extend(listA, listB) { - listA.push(...listB); + listA.push.apply(listA, __spread(listB)); } exports.extend = extend; /** @@ -24490,18 +29872,29 @@ exports.prepend = prepend; * @param item - an item */ function replace(list, conditionOrItem, newItem) { - let i = 0; - for (const oldItem of list) { - if (util_1.isFunction(conditionOrItem)) { - if (!!conditionOrItem.call(null, oldItem)) { - list[i] = newItem; + var e_1, _a; + var i = 0; + try { + for (var list_1 = __values(list), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) { + var oldItem = list_1_1.value; + if (util_1.isFunction(conditionOrItem)) { + if (!!conditionOrItem.call(null, oldItem)) { + list[i] = newItem; + } } + else if (oldItem === conditionOrItem) { + list[i] = newItem; + return; + } + i++; } - else if (oldItem === conditionOrItem) { - list[i] = newItem; - return; + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (list_1_1 && !list_1_1.done && (_a = list_1.return)) _a.call(list_1); } - i++; + finally { if (e_1) throw e_1.error; } } } exports.replace = replace; @@ -24523,9 +29916,9 @@ exports.insert = insert; * to remove */ function remove(list, conditionOrItem) { - let i = list.length; + var i = list.length; while (i--) { - const oldItem = list[i]; + var oldItem = list[i]; if (util_1.isFunction(conditionOrItem)) { if (!!conditionOrItem.call(null, oldItem)) { list.splice(i, 1); @@ -24553,15 +29946,26 @@ exports.empty = empty; * @param conditionOrItem - an item to a condition to match */ function contains(list, conditionOrItem) { - for (const oldItem of list) { - if (util_1.isFunction(conditionOrItem)) { - if (!!conditionOrItem.call(null, oldItem)) { + var e_2, _a; + try { + for (var list_2 = __values(list), list_2_1 = list_2.next(); !list_2_1.done; list_2_1 = list_2.next()) { + var oldItem = list_2_1.value; + if (util_1.isFunction(conditionOrItem)) { + if (!!conditionOrItem.call(null, oldItem)) { + return true; + } + } + else if (oldItem === conditionOrItem) { return true; } } - else if (oldItem === conditionOrItem) { - return true; + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (list_2_1 && !list_2_1.done && (_a = list_2.return)) _a.call(list_2); } + finally { if (e_2) throw e_2.error; } } return false; } @@ -24573,16 +29977,27 @@ exports.contains = contains; * @param condition - an optional condition to match */ function size(list, condition) { + var e_3, _a; if (condition === undefined) { return list.length; } else { - let count = 0; - for (const item of list) { - if (!!condition.call(null, item)) { - count++; + var count = 0; + try { + for (var list_3 = __values(list), list_3_1 = list_3.next(); !list_3_1.done; list_3_1 = list_3.next()) { + var item = list_3_1.value; + if (!!condition.call(null, item)) { + count++; + } } } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (list_3_1 && !list_3_1.done && (_a = list_3.return)) _a.call(list_3); + } + finally { if (e_3) throw e_3.error; } + } return count; } } @@ -24602,17 +30017,46 @@ exports.isEmpty = isEmpty; * @param list - a list * @param condition - an optional condition to match */ -function* forEach(list, condition) { - if (condition === undefined) { - yield* list; - } - else { - for (const item of list) { - if (!!condition.call(null, item)) { - yield item; - } +function forEach(list, condition) { + var list_4, list_4_1, item, e_4_1; + var e_4, _a; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + if (!(condition === undefined)) return [3 /*break*/, 2]; + return [5 /*yield**/, __values(list)]; + case 1: + _b.sent(); + return [3 /*break*/, 9]; + case 2: + _b.trys.push([2, 7, 8, 9]); + list_4 = __values(list), list_4_1 = list_4.next(); + _b.label = 3; + case 3: + if (!!list_4_1.done) return [3 /*break*/, 6]; + item = list_4_1.value; + if (!!!condition.call(null, item)) return [3 /*break*/, 5]; + return [4 /*yield*/, item]; + case 4: + _b.sent(); + _b.label = 5; + case 5: + list_4_1 = list_4.next(); + return [3 /*break*/, 3]; + case 6: return [3 /*break*/, 9]; + case 7: + e_4_1 = _b.sent(); + e_4 = { error: e_4_1 }; + return [3 /*break*/, 9]; + case 8: + try { + if (list_4_1 && !list_4_1.done && (_a = list_4.return)) _a.call(list_4); + } + finally { if (e_4) throw e_4.error; } + return [7 /*endfinally*/]; + case 9: return [2 /*return*/]; } - } + }); } exports.forEach = forEach; /** @@ -24621,7 +30065,7 @@ exports.forEach = forEach; * @param list - a list */ function clone(list) { - return new Array(...list); + return new (Array.bind.apply(Array, __spread([void 0], list)))(); } exports.clone = clone; /** @@ -24633,7 +30077,9 @@ exports.clone = clone; * is less than its second argument, and `false` otherwise. */ function sortInAscendingOrder(list, lessThanAlgo) { - return list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1); + return list.sort(function (itemA, itemB) { + return lessThanAlgo.call(null, itemA, itemB) ? -1 : 1; + }); } exports.sortInAscendingOrder = sortInAscendingOrder; /** @@ -24645,45 +30091,670 @@ exports.sortInAscendingOrder = sortInAscendingOrder; * is less than its second argument, and `false` otherwise. */ function sortInDescendingOrder(list, lessThanAlgo) { - return list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1); + return list.sort(function (itemA, itemB) { + return lessThanAlgo.call(null, itemA, itemB) ? 1 : -1; + }); } exports.sortInDescendingOrder = sortInDescendingOrder; //# sourceMappingURL=List.js.map /***/ }), - -/***/ 661: +/* 658 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const DocumentImpl_1 = __webpack_require__(488); +const os = __importStar(__webpack_require__(87)); +const events = __importStar(__webpack_require__(614)); +const child = __importStar(__webpack_require__(129)); +const path = __importStar(__webpack_require__(622)); +const io = __importStar(__webpack_require__(1)); +const ioUtil = __importStar(__webpack_require__(672)); +/* 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); + } + } + _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)}`; + } + } + } + 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}`; + } + } + 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); + } + strBuffer = s; + } + catch (err) { + // streaming lines to console is best effort. Don't fail a build. + this._debug(`error processing line. Failed with error ${err}`); + } + } + _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) { + // 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(''); + } + _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; + } + _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* () { + // 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) => { + 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); + }); + const fileName = this._getSpawnFileName(); + const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); + const 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); + } + this._processLineBuffer(data, stdbuffer, (line) => { + if (this.options.listeners && this.options.listeners.stdline) { + this.options.listeners.stdline(line); + } + }); + }); + } + const 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); + } + 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); + } + }); + }); + } +} +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 += '\\'; + } + 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; +} +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'); + } + 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 = setTimeout(ExecState.HandleTimeout, this.delay, this); + } + } + _debug(message) { + this.emit('debug', message); + } + _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; + } + 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 / + 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 + +/***/ }), +/* 659 */, +/* 660 */, +/* 661 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var DocumentImpl_1 = __webpack_require__(488); /** * Represents an XML document. */ -class XMLDocumentImpl extends DocumentImpl_1.DocumentImpl { +var XMLDocumentImpl = /** @class */ (function (_super) { + __extends(XMLDocumentImpl, _super); /** * Initializes a new instance of `XMLDocument`. */ - constructor() { - super(); + function XMLDocumentImpl() { + return _super.call(this) || this; } -} + return XMLDocumentImpl; +}(DocumentImpl_1.DocumentImpl)); exports.XMLDocumentImpl = XMLDocumentImpl; //# sourceMappingURL=XMLDocumentImpl.js.map /***/ }), - -/***/ 664: +/* 662 */, +/* 663 */, +/* 664 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const DOMException_1 = __webpack_require__(35); -const infra_1 = __webpack_require__(23); -const XMLAlgorithm_1 = __webpack_require__(442); +var DOMException_1 = __webpack_require__(35); +var infra_1 = __webpack_require__(23); +var XMLAlgorithm_1 = __webpack_require__(442); /** * Validates the given qualified name. * @@ -24696,9 +30767,9 @@ function namespace_validate(qualifiedName) { * production. */ if (!XMLAlgorithm_1.xml_isName(qualifiedName)) - throw new DOMException_1.InvalidCharacterError(`Invalid XML name: ${qualifiedName}`); + throw new DOMException_1.InvalidCharacterError("Invalid XML name: " + qualifiedName); if (!XMLAlgorithm_1.xml_isQName(qualifiedName)) - throw new DOMException_1.InvalidCharacterError(`Invalid XML qualified name: ${qualifiedName}.`); + throw new DOMException_1.InvalidCharacterError("Invalid XML qualified name: " + qualifiedName + "."); } exports.namespace_validate = namespace_validate; /** @@ -24732,19 +30803,19 @@ function namespace_validateAndExtract(namespace, qualifiedName) { if (!namespace) namespace = null; namespace_validate(qualifiedName); - const parts = qualifiedName.split(':'); - const prefix = (parts.length === 2 ? parts[0] : null); - const localName = (parts.length === 2 ? parts[1] : qualifiedName); + var parts = qualifiedName.split(':'); + var prefix = (parts.length === 2 ? parts[0] : null); + var localName = (parts.length === 2 ? parts[1] : qualifiedName); if (prefix && namespace === null) throw new DOMException_1.NamespaceError("Qualified name includes a prefix but the namespace is null."); if (prefix === "xml" && namespace !== infra_1.namespace.XML) - throw new DOMException_1.NamespaceError(`Qualified name includes the "xml" prefix but the namespace is not the XML namespace.`); + throw new DOMException_1.NamespaceError("Qualified name includes the \"xml\" prefix but the namespace is not the XML namespace."); if (namespace !== infra_1.namespace.XMLNS && (prefix === "xmlns" || qualifiedName === "xmlns")) - throw new DOMException_1.NamespaceError(`Qualified name includes the "xmlns" prefix but the namespace is not the XMLNS namespace.`); + throw new DOMException_1.NamespaceError("Qualified name includes the \"xmlns\" prefix but the namespace is not the XMLNS namespace."); if (namespace === infra_1.namespace.XMLNS && (prefix !== "xmlns" && qualifiedName !== "xmlns")) - throw new DOMException_1.NamespaceError(`Qualified name does not include the "xmlns" prefix but the namespace is the XMLNS namespace.`); + throw new DOMException_1.NamespaceError("Qualified name does not include the \"xmlns\" prefix but the namespace is the XMLNS namespace."); return [namespace, prefix, localName]; } exports.namespace_validateAndExtract = namespace_validateAndExtract; @@ -24757,447 +30828,28 @@ exports.namespace_validateAndExtract = namespace_validateAndExtract; */ function namespace_extractQName(qualifiedName) { namespace_validate(qualifiedName); - const parts = qualifiedName.split(':'); - const prefix = (parts.length === 2 ? parts[0] : null); - const localName = (parts.length === 2 ? parts[1] : qualifiedName); + var parts = qualifiedName.split(':'); + var prefix = (parts.length === 2 ? parts[0] : null); + var localName = (parts.length === 2 ? parts[1] : qualifiedName); return [prefix, localName]; } exports.namespace_extractQName = namespace_extractQName; //# sourceMappingURL=NamespaceAlgorithm.js.map /***/ }), - -/***/ 665: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const CodePoints_1 = __webpack_require__(780); -const ByteSequence_1 = __webpack_require__(425); -const Byte_1 = __webpack_require__(15); -const util_1 = __webpack_require__(42); -/** - * Determines if the string `a` is a code unit prefix of string `b`. - * - * @param a - a string - * @param b - a string - */ -function isCodeUnitPrefix(a, b) { - /** - * 1. Let i be 0. - * 2. While true: - * 2.1. Let aCodeUnit be the ith code unit of a if i is less than a’s length; - * otherwise null. - * 2.2. Let bCodeUnit be the ith code unit of b if i is less than b’s length; - * otherwise null. - * 2.3. If bCodeUnit is null, then return true. - * 2.4. Return false if aCodeUnit is different from bCodeUnit. - * 2.5. Set i to i + 1. - */ - let i = 0; - while (true) { - const aCodeUnit = i < a.length ? a.charCodeAt(i) : null; - const bCodeUnit = i < b.length ? b.charCodeAt(i) : null; - if (aCodeUnit === null) - return true; - if (aCodeUnit !== bCodeUnit) - return false; - i++; - } -} -exports.isCodeUnitPrefix = isCodeUnitPrefix; -/** - * Determines if the string `a` is a code unit less than string `b`. - * - * @param a - a string - * @param b - a string - */ -function isCodeUnitLessThan(a, b) { - /** - * 1. If b is a code unit prefix of a, then return false. - * 2. If a is a code unit prefix of b, then return true. - * 3. Let n be the smallest index such that the nth code unit of a is - * different from the nth code unit of b. (There has to be such an index, - * since neither string is a prefix of the other.) - * 4. If the nth code unit of a is less than the nth code unit of b, then - * return true. - * 5. Return false. - */ - if (isCodeUnitPrefix(b, a)) - return false; - if (isCodeUnitPrefix(a, b)) - return true; - for (let i = 0; i < Math.min(a.length, b.length); i++) { - const aCodeUnit = a.charCodeAt(i); - const bCodeUnit = b.charCodeAt(i); - if (aCodeUnit === bCodeUnit) - continue; - return (aCodeUnit < bCodeUnit); - } - /* istanbul ignore next */ - return false; -} -exports.isCodeUnitLessThan = isCodeUnitLessThan; -/** - * Isomorphic encodes the given string. - * - * @param str - a string - */ -function isomorphicEncode(str) { - /** - * 1. Assert: input contains no code points greater than U+00FF. - * 2. Return a byte sequence whose length is equal to input’s length and whose - * bytes have the same values as input’s code points, in the same order. - */ - const codePoints = Array.from(str); - const bytes = new Uint8Array(codePoints.length); - let i = 0; - for (const codePoint of str) { - const byte = codePoint.codePointAt(0); - console.assert(byte !== undefined && byte <= 0x00FF, "isomorphicEncode requires string bytes to be less than or equal to 0x00FF."); - if (byte !== undefined && byte <= 0x00FF) { - bytes[i++] = byte; - } - } - return bytes; -} -exports.isomorphicEncode = isomorphicEncode; -/** - * Determines if the given string is An ASCII string. - * - * @param str - a string - */ -function isASCIIString(str) { - /** - * An ASCII string is a string whose code points are all ASCII code points. - */ - return /^[\u0000-\u007F]*$/.test(str); -} -exports.isASCIIString = isASCIIString; -/** - * Converts all uppercase ASCII code points to lowercase. - * - * @param str - a string - */ -function asciiLowercase(str) { - /** - * To ASCII lowercase a string, replace all ASCII upper alphas in the string - * with their corresponding code point in ASCII lower alpha. - */ - let result = ""; - for (const c of str) { - const code = c.codePointAt(0); - if (code !== undefined && code >= 0x41 && code <= 0x5A) { - result += String.fromCodePoint(code + 0x20); - } - else { - result += c; - } - } - return result; -} -exports.asciiLowercase = asciiLowercase; -/** - * Converts all uppercase ASCII code points to uppercase. - * - * @param str - a string - */ -function asciiUppercase(str) { - /** - * To ASCII uppercase a string, replace all ASCII lower alphas in the string - * with their corresponding code point in ASCII upper alpha. - */ - let result = ""; - for (const c of str) { - const code = c.codePointAt(0); - if (code !== undefined && code >= 0x61 && code <= 0x7A) { - result += String.fromCodePoint(code - 0x20); - } - else { - result += c; - } - } - return result; -} -exports.asciiUppercase = asciiUppercase; -/** - * Compares two ASCII strings case-insensitively. - * - * @param a - a string - * @param b - a string - */ -function asciiCaseInsensitiveMatch(a, b) { - /** - * A string A is an ASCII case-insensitive match for a string B, if the ASCII - * lowercase of A is the ASCII lowercase of B. - */ - return asciiLowercase(a) === asciiLowercase(b); -} -exports.asciiCaseInsensitiveMatch = asciiCaseInsensitiveMatch; -/** - * ASCII encodes a string. - * - * @param str - a string - */ -function asciiEncode(str) { - /** - * 1. Assert: input is an ASCII string. - * 2. Return the isomorphic encoding of input. - */ - console.assert(isASCIIString(str), "asciiEncode requires an ASCII string."); - return isomorphicEncode(str); -} -exports.asciiEncode = asciiEncode; -/** - * ASCII decodes a byte sequence. - * - * @param bytes - a byte sequence - */ -function asciiDecode(bytes) { - /** - * 1. Assert: All bytes in input are ASCII bytes. - * 2. Return the isomorphic decoding of input. - */ - for (const byte of bytes) { - console.assert(Byte_1.isASCIIByte(byte), "asciiDecode requires an ASCII byte sequence."); - } - return ByteSequence_1.isomorphicDecode(bytes); -} -exports.asciiDecode = asciiDecode; -/** - * Strips newline characters from a string. - * - * @param str - a string - */ -function stripNewlines(str) { - /** - * To strip newlines from a string, remove any U+000A LF and U+000D CR code - * points from the string. - */ - return str.replace(/[\n\r]/g, ""); -} -exports.stripNewlines = stripNewlines; -/** - * Normalizes newline characters in a string by converting consecutive - * carriage-return newline characters and also single carriage return characters - * into a single newline. - * - * @param str - a string - */ -function normalizeNewlines(str) { - /** - * To normalize newlines in a string, replace every U+000D CR U+000A LF code - * point pair with a single U+000A LF code point, and then replace every - * remaining U+000D CR code point with a U+000A LF code point. - */ - return str.replace(/\r\n/g, "\n").replace(/\r/g, "\n"); -} -exports.normalizeNewlines = normalizeNewlines; -/** - * Removes leading and trailing whitespace characters from a string. - * - * @param str - a string - */ -function stripLeadingAndTrailingASCIIWhitespace(str) { - /** - * To strip leading and trailing ASCII whitespace from a string, remove all - * ASCII whitespace that are at the start or the end of the string. - */ - return str.replace(/^[\t\n\f\r ]+/, "").replace(/[\t\n\f\r ]+$/, ""); -} -exports.stripLeadingAndTrailingASCIIWhitespace = stripLeadingAndTrailingASCIIWhitespace; -/** - * Removes consecutive newline characters from a string. - * - * @param str - a string - */ -function stripAndCollapseASCIIWhitespace(str) { - /** - * To strip and collapse ASCII whitespace in a string, replace any sequence of - * one or more consecutive code points that are ASCII whitespace in the string - * with a single U+0020 SPACE code point, and then remove any leading and - * trailing ASCII whitespace from that string. - */ - return stripLeadingAndTrailingASCIIWhitespace(str.replace(/[\t\n\f\r ]{2,}/g, " ")); -} -exports.stripAndCollapseASCIIWhitespace = stripAndCollapseASCIIWhitespace; -/** - * Collects a sequence of code points matching a given condition from the input - * string. - * - * @param condition - a condition to match - * @param input - a string - * @param options - starting position - */ -function collectASequenceOfCodePoints(condition, input, options) { - /** - * 1. Let result be the empty string. - * 2. While position doesn’t point past the end of input and the code point at - * position within input meets the condition condition: - * 2.1. Append that code point to the end of result. - * 2.2. Advance position by 1. - * 3. Return result. - */ - if (!util_1.isArray(input)) - return collectASequenceOfCodePoints(condition, Array.from(input), options); - let result = ""; - while (options.position < input.length && !!condition.call(null, input[options.position])) { - result += input[options.position]; - options.position++; - } - return result; -} -exports.collectASequenceOfCodePoints = collectASequenceOfCodePoints; -/** - * Skips over ASCII whitespace. - * - * @param input - input string - * @param options - starting position - */ -function skipASCIIWhitespace(input, options) { - /** - * To skip ASCII whitespace within a string input given a position variable - * position, collect a sequence of code points that are ASCII whitespace from - * input given position. The collected code points are not used, but position - * is still updated. - */ - collectASequenceOfCodePoints(str => CodePoints_1.ASCIIWhiteSpace.test(str), input, options); -} -exports.skipASCIIWhitespace = skipASCIIWhitespace; -/** - * Solits a string at the given delimiter. - * - * @param input - input string - * @param delimiter - a delimiter string - */ -function strictlySplit(input, delimiter) { - /** - * 1. Let position be a position variable for input, initially pointing at the - * start of input. - * 2. Let tokens be a list of strings, initially empty. - * 3. Let token be the result of collecting a sequence of code points that are - * not equal to delimiter from input, given position. - * 4. Append token to tokens. - * 5. While position is not past the end of input: - * 5.1. Assert: the code point at position within input is delimiter. - * 5.2. Advance position by 1. - * 5.3. Let token be the result of collecting a sequence of code points that - * are not equal to delimiter from input, given position. - * 5.4. Append token to tokens. - * 6. Return tokens. - */ - if (!util_1.isArray(input)) - return strictlySplit(Array.from(input), delimiter); - const options = { position: 0 }; - const tokens = []; - let token = collectASequenceOfCodePoints(str => delimiter !== str, input, options); - tokens.push(token); - while (options.position < input.length) { - console.assert(input[options.position] === delimiter, "strictlySplit found no delimiter in input string."); - options.position++; - token = collectASequenceOfCodePoints(str => delimiter !== str, input, options); - tokens.push(token); - } - return tokens; -} -exports.strictlySplit = strictlySplit; -/** - * Splits a string on ASCII whitespace. - * - * @param input - a string - */ -function splitAStringOnASCIIWhitespace(input) { - /** - * 1. Let position be a position variable for input, initially pointing at the - * start of input. - * 2. Let tokens be a list of strings, initially empty. - * 3. Skip ASCII whitespace within input given position. - * 4. While position is not past the end of input: - * 4.1. Let token be the result of collecting a sequence of code points that - * are not ASCII whitespace from input, given position. - * 4.2. Append token to tokens. - * 4.3. Skip ASCII whitespace within input given position. - * 5. Return tokens. - */ - if (!util_1.isArray(input)) - return splitAStringOnASCIIWhitespace(Array.from(input)); - const options = { position: 0 }; - const tokens = []; - skipASCIIWhitespace(input, options); - while (options.position < input.length) { - const token = collectASequenceOfCodePoints(str => !CodePoints_1.ASCIIWhiteSpace.test(str), input, options); - tokens.push(token); - skipASCIIWhitespace(input, options); - } - return tokens; -} -exports.splitAStringOnASCIIWhitespace = splitAStringOnASCIIWhitespace; -/** - * Splits a string on commas. - * - * @param input - a string - */ -function splitAStringOnCommas(input) { - /** - * 1. Let position be a position variable for input, initially pointing at the - * start of input. - * 2. Let tokens be a list of strings, initially empty. - * 3. While position is not past the end of input: - * 3.1. Let token be the result of collecting a sequence of code points that - * are not U+002C (,) from input, given position. - * 3.2. Strip leading and trailing ASCII whitespace from token. - * 3.3. Append token to tokens. - * 3.4. If position is not past the end of input, then: - * 3.4.1. Assert: the code point at position within input is U+002C (,). - * 3.4.2. Advance position by 1. - * 4. Return tokens. - */ - if (!util_1.isArray(input)) - return splitAStringOnCommas(Array.from(input)); - const options = { position: 0 }; - const tokens = []; - while (options.position < input.length) { - const token = collectASequenceOfCodePoints(str => str !== ',', input, options); - tokens.push(stripLeadingAndTrailingASCIIWhitespace(token)); - if (options.position < input.length) { - console.assert(input[options.position] === ',', "splitAStringOnCommas found no delimiter in input string."); - options.position++; - } - } - return tokens; -} -exports.splitAStringOnCommas = splitAStringOnCommas; -/** - * Concatenates a list of strings with the given separator. - * - * @param list - a list of strings - * @param separator - a separator string - */ -function concatenate(list, separator = "") { - /** - * 1. If list is empty, then return the empty string. - * 2. If separator is not given, then set separator to the empty string. - * 3. Return a string whose contents are list’s items, in order, separated - * from each other by separator. - */ - if (list.length === 0) - return ""; - return list.join(separator); -} -exports.concatenate = concatenate; -//# sourceMappingURL=String.js.map - -/***/ }), - -/***/ 669: +/* 665 */, +/* 666 */, +/* 667 */, +/* 668 */, +/* 669 */ /***/ (function(module) { module.exports = require("util"); /***/ }), - -/***/ 672: +/* 670 */, +/* 671 */, +/* 672 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; @@ -25398,8 +31050,876 @@ function isUnixExecutable(stats) { //# sourceMappingURL=io-util.js.map /***/ }), +/* 673 */, +/* 674 */, +/* 675 */, +/* 676 */, +/* 677 */, +/* 678 */, +/* 679 */, +/* 680 */, +/* 681 */, +/* 682 */, +/* 683 */, +/* 684 */, +/* 685 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 686: +"use strict"; + + +/*eslint-disable no-use-before-define*/ + +var common = __webpack_require__(740); +var YAMLException = __webpack_require__(556); +var DEFAULT_FULL_SCHEMA = __webpack_require__(910); +var DEFAULT_SAFE_SCHEMA = __webpack_require__(723); + +var _toString = Object.prototype.toString; +var _hasOwnProperty = Object.prototype.hasOwnProperty; + +var CHAR_TAB = 0x09; /* Tab */ +var CHAR_LINE_FEED = 0x0A; /* LF */ +var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */ +var CHAR_SPACE = 0x20; /* Space */ +var CHAR_EXCLAMATION = 0x21; /* ! */ +var CHAR_DOUBLE_QUOTE = 0x22; /* " */ +var CHAR_SHARP = 0x23; /* # */ +var CHAR_PERCENT = 0x25; /* % */ +var CHAR_AMPERSAND = 0x26; /* & */ +var CHAR_SINGLE_QUOTE = 0x27; /* ' */ +var CHAR_ASTERISK = 0x2A; /* * */ +var CHAR_COMMA = 0x2C; /* , */ +var CHAR_MINUS = 0x2D; /* - */ +var CHAR_COLON = 0x3A; /* : */ +var CHAR_EQUALS = 0x3D; /* = */ +var CHAR_GREATER_THAN = 0x3E; /* > */ +var CHAR_QUESTION = 0x3F; /* ? */ +var CHAR_COMMERCIAL_AT = 0x40; /* @ */ +var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */ +var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */ +var CHAR_GRAVE_ACCENT = 0x60; /* ` */ +var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */ +var CHAR_VERTICAL_LINE = 0x7C; /* | */ +var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */ + +var ESCAPE_SEQUENCES = {}; + +ESCAPE_SEQUENCES[0x00] = '\\0'; +ESCAPE_SEQUENCES[0x07] = '\\a'; +ESCAPE_SEQUENCES[0x08] = '\\b'; +ESCAPE_SEQUENCES[0x09] = '\\t'; +ESCAPE_SEQUENCES[0x0A] = '\\n'; +ESCAPE_SEQUENCES[0x0B] = '\\v'; +ESCAPE_SEQUENCES[0x0C] = '\\f'; +ESCAPE_SEQUENCES[0x0D] = '\\r'; +ESCAPE_SEQUENCES[0x1B] = '\\e'; +ESCAPE_SEQUENCES[0x22] = '\\"'; +ESCAPE_SEQUENCES[0x5C] = '\\\\'; +ESCAPE_SEQUENCES[0x85] = '\\N'; +ESCAPE_SEQUENCES[0xA0] = '\\_'; +ESCAPE_SEQUENCES[0x2028] = '\\L'; +ESCAPE_SEQUENCES[0x2029] = '\\P'; + +var DEPRECATED_BOOLEANS_SYNTAX = [ + 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON', + 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF' +]; + +function compileStyleMap(schema, map) { + var result, keys, index, length, tag, style, type; + + if (map === null) return {}; + + result = {}; + keys = Object.keys(map); + + for (index = 0, length = keys.length; index < length; index += 1) { + tag = keys[index]; + style = String(map[tag]); + + if (tag.slice(0, 2) === '!!') { + tag = 'tag:yaml.org,2002:' + tag.slice(2); + } + type = schema.compiledTypeMap['fallback'][tag]; + + if (type && _hasOwnProperty.call(type.styleAliases, style)) { + style = type.styleAliases[style]; + } + + result[tag] = style; + } + + return result; +} + +function encodeHex(character) { + var string, handle, length; + + string = character.toString(16).toUpperCase(); + + if (character <= 0xFF) { + handle = 'x'; + length = 2; + } else if (character <= 0xFFFF) { + handle = 'u'; + length = 4; + } else if (character <= 0xFFFFFFFF) { + handle = 'U'; + length = 8; + } else { + throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF'); + } + + return '\\' + handle + common.repeat('0', length - string.length) + string; +} + +function State(options) { + this.schema = options['schema'] || DEFAULT_FULL_SCHEMA; + this.indent = Math.max(1, (options['indent'] || 2)); + this.noArrayIndent = options['noArrayIndent'] || false; + this.skipInvalid = options['skipInvalid'] || false; + this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']); + this.styleMap = compileStyleMap(this.schema, options['styles'] || null); + this.sortKeys = options['sortKeys'] || false; + this.lineWidth = options['lineWidth'] || 80; + this.noRefs = options['noRefs'] || false; + this.noCompatMode = options['noCompatMode'] || false; + this.condenseFlow = options['condenseFlow'] || false; + + this.implicitTypes = this.schema.compiledImplicit; + this.explicitTypes = this.schema.compiledExplicit; + + this.tag = null; + this.result = ''; + + this.duplicates = []; + this.usedDuplicates = null; +} + +// Indents every line in a string. Empty lines (\n only) are not indented. +function indentString(string, spaces) { + var ind = common.repeat(' ', spaces), + position = 0, + next = -1, + result = '', + line, + length = string.length; + + while (position < length) { + next = string.indexOf('\n', position); + if (next === -1) { + line = string.slice(position); + position = length; + } else { + line = string.slice(position, next + 1); + position = next + 1; + } + + if (line.length && line !== '\n') result += ind; + + result += line; + } + + return result; +} + +function generateNextLine(state, level) { + return '\n' + common.repeat(' ', state.indent * level); +} + +function testImplicitResolving(state, str) { + var index, length, type; + + for (index = 0, length = state.implicitTypes.length; index < length; index += 1) { + type = state.implicitTypes[index]; + + if (type.resolve(str)) { + return true; + } + } + + return false; +} + +// [33] s-white ::= s-space | s-tab +function isWhitespace(c) { + return c === CHAR_SPACE || c === CHAR_TAB; +} + +// Returns true if the character can be printed without escaping. +// From YAML 1.2: "any allowed characters known to be non-printable +// should also be escaped. [However,] This isn’t mandatory" +// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029. +function isPrintable(c) { + return (0x00020 <= c && c <= 0x00007E) + || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029) + || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */) + || (0x10000 <= c && c <= 0x10FFFF); +} + +// [34] ns-char ::= nb-char - s-white +// [27] nb-char ::= c-printable - b-char - c-byte-order-mark +// [26] b-char ::= b-line-feed | b-carriage-return +// [24] b-line-feed ::= #xA /* LF */ +// [25] b-carriage-return ::= #xD /* CR */ +// [3] c-byte-order-mark ::= #xFEFF +function isNsChar(c) { + return isPrintable(c) && !isWhitespace(c) + // byte-order-mark + && c !== 0xFEFF + // b-char + && c !== CHAR_CARRIAGE_RETURN + && c !== CHAR_LINE_FEED; +} + +// Simplified test for values allowed after the first character in plain style. +function isPlainSafe(c, prev) { + // Uses a subset of nb-char - c-flow-indicator - ":" - "#" + // where nb-char ::= c-printable - b-char - c-byte-order-mark. + return isPrintable(c) && c !== 0xFEFF + // - c-flow-indicator + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + // - ":" - "#" + // /* An ns-char preceding */ "#" + && c !== CHAR_COLON + && ((c !== CHAR_SHARP) || (prev && isNsChar(prev))); +} + +// Simplified test for values allowed as the first character in plain style. +function isPlainSafeFirst(c) { + // Uses a subset of ns-char - c-indicator + // where ns-char = nb-char - s-white. + return isPrintable(c) && c !== 0xFEFF + && !isWhitespace(c) // - s-white + // - (c-indicator ::= + // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}” + && c !== CHAR_MINUS + && c !== CHAR_QUESTION + && c !== CHAR_COLON + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"” + && c !== CHAR_SHARP + && c !== CHAR_AMPERSAND + && c !== CHAR_ASTERISK + && c !== CHAR_EXCLAMATION + && c !== CHAR_VERTICAL_LINE + && c !== CHAR_EQUALS + && c !== CHAR_GREATER_THAN + && c !== CHAR_SINGLE_QUOTE + && c !== CHAR_DOUBLE_QUOTE + // | “%” | “@” | “`”) + && c !== CHAR_PERCENT + && c !== CHAR_COMMERCIAL_AT + && c !== CHAR_GRAVE_ACCENT; +} + +// Determines whether block indentation indicator is required. +function needIndentIndicator(string) { + var leadingSpaceRe = /^\n* /; + return leadingSpaceRe.test(string); +} + +var STYLE_PLAIN = 1, + STYLE_SINGLE = 2, + STYLE_LITERAL = 3, + STYLE_FOLDED = 4, + STYLE_DOUBLE = 5; + +// Determines which scalar styles are possible and returns the preferred style. +// lineWidth = -1 => no limit. +// Pre-conditions: str.length > 0. +// Post-conditions: +// STYLE_PLAIN or STYLE_SINGLE => no \n are in the string. +// STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1). +// STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1). +function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) { + var i; + var char, prev_char; + var hasLineBreak = false; + var hasFoldableLine = false; // only checked if shouldTrackWidth + var shouldTrackWidth = lineWidth !== -1; + var previousLineBreak = -1; // count the first line correctly + var plain = isPlainSafeFirst(string.charCodeAt(0)) + && !isWhitespace(string.charCodeAt(string.length - 1)); + + if (singleLineOnly) { + // Case: no block styles. + // Check for disallowed characters to rule out plain and single. + for (i = 0; i < string.length; i++) { + char = string.charCodeAt(i); + if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + prev_char = i > 0 ? string.charCodeAt(i - 1) : null; + plain = plain && isPlainSafe(char, prev_char); + } + } else { + // Case: block styles permitted. + for (i = 0; i < string.length; i++) { + char = string.charCodeAt(i); + if (char === CHAR_LINE_FEED) { + hasLineBreak = true; + // Check if any line can be folded. + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || + // Foldable line = too long, and not more-indented. + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' '); + previousLineBreak = i; + } + } else if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + prev_char = i > 0 ? string.charCodeAt(i - 1) : null; + plain = plain && isPlainSafe(char, prev_char); + } + // in case the end is missing a \n + hasFoldableLine = hasFoldableLine || (shouldTrackWidth && + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' ')); + } + // Although every style can represent \n without escaping, prefer block styles + // for multiline, since they're more readable and they don't add empty lines. + // Also prefer folding a super-long line. + if (!hasLineBreak && !hasFoldableLine) { + // Strings interpretable as another type have to be quoted; + // e.g. the string 'true' vs. the boolean true. + return plain && !testAmbiguousType(string) + ? STYLE_PLAIN : STYLE_SINGLE; + } + // Edge case: block indentation indicator can only have one digit. + if (indentPerLevel > 9 && needIndentIndicator(string)) { + return STYLE_DOUBLE; + } + // At this point we know block styles are valid. + // Prefer literal style unless we want to fold. + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; +} + +// Note: line breaking/folding is implemented for only the folded style. +// NB. We drop the last trailing newline (if any) of a returned block scalar +// since the dumper adds its own newline. This always works: +// • No ending newline => unaffected; already using strip "-" chomping. +// • Ending newline => removed then restored. +// Importantly, this keeps the "+" chomp indicator from gaining an extra line. +function writeScalar(state, string, level, iskey) { + state.dump = (function () { + if (string.length === 0) { + return "''"; + } + if (!state.noCompatMode && + DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) { + return "'" + string + "'"; + } + + var indent = state.indent * Math.max(1, level); // no 0-indent scalars + // As indentation gets deeper, let the width decrease monotonically + // to the lower bound min(state.lineWidth, 40). + // Note that this implies + // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound. + // state.lineWidth > 40 + state.indent: width decreases until the lower bound. + // This behaves better than a constant minimum width which disallows narrower options, + // or an indent threshold which causes the width to suddenly increase. + var lineWidth = state.lineWidth === -1 + ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); + + // Without knowing if keys are implicit/explicit, assume implicit for safety. + var singleLineOnly = iskey + // No block styles in flow mode. + || (state.flowLevel > -1 && level >= state.flowLevel); + function testAmbiguity(string) { + return testImplicitResolving(state, string); + } + + switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) { + case STYLE_PLAIN: + return string; + case STYLE_SINGLE: + return "'" + string.replace(/'/g, "''") + "'"; + case STYLE_LITERAL: + return '|' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(string, indent)); + case STYLE_FOLDED: + return '>' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(foldString(string, lineWidth), indent)); + case STYLE_DOUBLE: + return '"' + escapeString(string, lineWidth) + '"'; + default: + throw new YAMLException('impossible error: invalid scalar style'); + } + }()); +} + +// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9. +function blockHeader(string, indentPerLevel) { + var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ''; + + // note the special case: the string '\n' counts as a "trailing" empty line. + var clip = string[string.length - 1] === '\n'; + var keep = clip && (string[string.length - 2] === '\n' || string === '\n'); + var chomp = keep ? '+' : (clip ? '' : '-'); + + return indentIndicator + chomp + '\n'; +} + +// (See the note for writeScalar.) +function dropEndingNewline(string) { + return string[string.length - 1] === '\n' ? string.slice(0, -1) : string; +} + +// Note: a long line without a suitable break point will exceed the width limit. +// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0. +function foldString(string, width) { + // In folded style, $k$ consecutive newlines output as $k+1$ newlines— + // unless they're before or after a more-indented line, or at the very + // beginning or end, in which case $k$ maps to $k$. + // Therefore, parse each chunk as newline(s) followed by a content line. + var lineRe = /(\n+)([^\n]*)/g; + + // first line (possibly an empty line) + var result = (function () { + var nextLF = string.indexOf('\n'); + nextLF = nextLF !== -1 ? nextLF : string.length; + lineRe.lastIndex = nextLF; + return foldLine(string.slice(0, nextLF), width); + }()); + // If we haven't reached the first content line yet, don't add an extra \n. + var prevMoreIndented = string[0] === '\n' || string[0] === ' '; + var moreIndented; + + // rest of the lines + var match; + while ((match = lineRe.exec(string))) { + var prefix = match[1], line = match[2]; + moreIndented = (line[0] === ' '); + result += prefix + + (!prevMoreIndented && !moreIndented && line !== '' + ? '\n' : '') + + foldLine(line, width); + prevMoreIndented = moreIndented; + } + + return result; +} + +// Greedy line breaking. +// Picks the longest line under the limit each time, +// otherwise settles for the shortest line over the limit. +// NB. More-indented lines *cannot* be folded, as that would add an extra \n. +function foldLine(line, width) { + if (line === '' || line[0] === ' ') return line; + + // Since a more-indented line adds a \n, breaks can't be followed by a space. + var breakRe = / [^ ]/g; // note: the match index will always be <= length-2. + var match; + // start is an inclusive index. end, curr, and next are exclusive. + var start = 0, end, curr = 0, next = 0; + var result = ''; + + // Invariants: 0 <= start <= length-1. + // 0 <= curr <= next <= max(0, length-2). curr - start <= width. + // Inside the loop: + // A match implies length >= 2, so curr and next are <= length-2. + while ((match = breakRe.exec(line))) { + next = match.index; + // maintain invariant: curr - start <= width + if (next - start > width) { + end = (curr > start) ? curr : next; // derive end <= length-2 + result += '\n' + line.slice(start, end); + // skip the space that was output as \n + start = end + 1; // derive start <= length-1 + } + curr = next; + } + + // By the invariants, start <= length-1, so there is something left over. + // It is either the whole string or a part starting from non-whitespace. + result += '\n'; + // Insert a break if the remainder is too long and there is a break available. + if (line.length - start > width && curr > start) { + result += line.slice(start, curr) + '\n' + line.slice(curr + 1); + } else { + result += line.slice(start); + } + + return result.slice(1); // drop extra \n joiner +} + +// Escapes a double-quoted string. +function escapeString(string) { + var result = ''; + var char, nextChar; + var escapeSeq; + + for (var i = 0; i < string.length; i++) { + char = string.charCodeAt(i); + // Check for surrogate pairs (reference Unicode 3.0 section "3.7 Surrogates"). + if (char >= 0xD800 && char <= 0xDBFF/* high surrogate */) { + nextChar = string.charCodeAt(i + 1); + if (nextChar >= 0xDC00 && nextChar <= 0xDFFF/* low surrogate */) { + // Combine the surrogate pair and store it escaped. + result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000); + // Advance index one extra since we already used that char here. + i++; continue; + } + } + escapeSeq = ESCAPE_SEQUENCES[char]; + result += !escapeSeq && isPrintable(char) + ? string[i] + : escapeSeq || encodeHex(char); + } + + return result; +} + +function writeFlowSequence(state, level, object) { + var _result = '', + _tag = state.tag, + index, + length; + + for (index = 0, length = object.length; index < length; index += 1) { + // Write only valid elements. + if (writeNode(state, level, object[index], false, false)) { + if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : ''); + _result += state.dump; + } + } + + state.tag = _tag; + state.dump = '[' + _result + ']'; +} + +function writeBlockSequence(state, level, object, compact) { + var _result = '', + _tag = state.tag, + index, + length; + + for (index = 0, length = object.length; index < length; index += 1) { + // Write only valid elements. + if (writeNode(state, level + 1, object[index], true, true)) { + if (!compact || index !== 0) { + _result += generateNextLine(state, level); + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + _result += '-'; + } else { + _result += '- '; + } + + _result += state.dump; + } + } + + state.tag = _tag; + state.dump = _result || '[]'; // Empty sequence if no valid values. +} + +function writeFlowMapping(state, level, object) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + pairBuffer; + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + + pairBuffer = ''; + if (index !== 0) pairBuffer += ', '; + + if (state.condenseFlow) pairBuffer += '"'; + + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + + if (!writeNode(state, level, objectKey, false, false)) { + continue; // Skip this pair because of invalid key; + } + + if (state.dump.length > 1024) pairBuffer += '? '; + + pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' '); + + if (!writeNode(state, level, objectValue, false, false)) { + continue; // Skip this pair because of invalid value. + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = '{' + _result + '}'; +} + +function writeBlockMapping(state, level, object, compact) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + explicitPair, + pairBuffer; + + // Allow sorting keys so that the output file is deterministic + if (state.sortKeys === true) { + // Default sorting + objectKeyList.sort(); + } else if (typeof state.sortKeys === 'function') { + // Custom sort function + objectKeyList.sort(state.sortKeys); + } else if (state.sortKeys) { + // Something is wrong + throw new YAMLException('sortKeys must be a boolean or a function'); + } + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ''; + + if (!compact || index !== 0) { + pairBuffer += generateNextLine(state, level); + } + + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + + if (!writeNode(state, level + 1, objectKey, true, true, true)) { + continue; // Skip this pair because of invalid key. + } + + explicitPair = (state.tag !== null && state.tag !== '?') || + (state.dump && state.dump.length > 1024); + + if (explicitPair) { + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += '?'; + } else { + pairBuffer += '? '; + } + } + + pairBuffer += state.dump; + + if (explicitPair) { + pairBuffer += generateNextLine(state, level); + } + + if (!writeNode(state, level + 1, objectValue, true, explicitPair)) { + continue; // Skip this pair because of invalid value. + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += ':'; + } else { + pairBuffer += ': '; + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = _result || '{}'; // Empty mapping if no valid pairs. +} + +function detectType(state, object, explicit) { + var _result, typeList, index, length, type, style; + + typeList = explicit ? state.explicitTypes : state.implicitTypes; + + for (index = 0, length = typeList.length; index < length; index += 1) { + type = typeList[index]; + + if ((type.instanceOf || type.predicate) && + (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) && + (!type.predicate || type.predicate(object))) { + + state.tag = explicit ? type.tag : '?'; + + if (type.represent) { + style = state.styleMap[type.tag] || type.defaultStyle; + + if (_toString.call(type.represent) === '[object Function]') { + _result = type.represent(object, style); + } else if (_hasOwnProperty.call(type.represent, style)) { + _result = type.represent[style](object, style); + } else { + throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style'); + } + + state.dump = _result; + } + + return true; + } + } + + return false; +} + +// Serializes `object` and writes it to global `result`. +// Returns true on success, or false on invalid object. +// +function writeNode(state, level, object, block, compact, iskey) { + state.tag = null; + state.dump = object; + + if (!detectType(state, object, false)) { + detectType(state, object, true); + } + + var type = _toString.call(state.dump); + + if (block) { + block = (state.flowLevel < 0 || state.flowLevel > level); + } + + var objectOrArray = type === '[object Object]' || type === '[object Array]', + duplicateIndex, + duplicate; + + if (objectOrArray) { + duplicateIndex = state.duplicates.indexOf(object); + duplicate = duplicateIndex !== -1; + } + + if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) { + compact = false; + } + + if (duplicate && state.usedDuplicates[duplicateIndex]) { + state.dump = '*ref_' + duplicateIndex; + } else { + if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) { + state.usedDuplicates[duplicateIndex] = true; + } + if (type === '[object Object]') { + if (block && (Object.keys(state.dump).length !== 0)) { + writeBlockMapping(state, level, state.dump, compact); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowMapping(state, level, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object Array]') { + var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level; + if (block && (state.dump.length !== 0)) { + writeBlockSequence(state, arrayLevel, state.dump, compact); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowSequence(state, arrayLevel, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object String]') { + if (state.tag !== '?') { + writeScalar(state, state.dump, level, iskey); + } + } else { + if (state.skipInvalid) return false; + throw new YAMLException('unacceptable kind of an object to dump ' + type); + } + + if (state.tag !== null && state.tag !== '?') { + state.dump = '!<' + state.tag + '> ' + state.dump; + } + } + + return true; +} + +function getDuplicateReferences(object, state) { + var objects = [], + duplicatesIndexes = [], + index, + length; + + inspectNode(object, objects, duplicatesIndexes); + + for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) { + state.duplicates.push(objects[duplicatesIndexes[index]]); + } + state.usedDuplicates = new Array(length); +} + +function inspectNode(object, objects, duplicatesIndexes) { + var objectKeyList, + index, + length; + + if (object !== null && typeof object === 'object') { + index = objects.indexOf(object); + if (index !== -1) { + if (duplicatesIndexes.indexOf(index) === -1) { + duplicatesIndexes.push(index); + } + } else { + objects.push(object); + + if (Array.isArray(object)) { + for (index = 0, length = object.length; index < length; index += 1) { + inspectNode(object[index], objects, duplicatesIndexes); + } + } else { + objectKeyList = Object.keys(object); + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes); + } + } + } + } +} + +function dump(input, options) { + options = options || {}; + + var state = new State(options); + + if (!state.noRefs) getDuplicateReferences(input, state); + + if (writeNode(state, 0, input, true, true)) return state.dump + '\n'; + + return ''; +} + +function safeDump(input, options) { + return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); +} + +module.exports.dump = dump; +module.exports.safeDump = safeDump; + + +/***/ }), +/* 686 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; @@ -25411,25 +31931,39 @@ exports.XMLSerializer = XMLSerializerImpl_1.XMLSerializerImpl; //# sourceMappingURL=index.js.map /***/ }), - -/***/ 688: +/* 687 */, +/* 688 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const AbstractRangeImpl_1 = __webpack_require__(537); -const DOMException_1 = __webpack_require__(35); -const util_1 = __webpack_require__(918); +var AbstractRangeImpl_1 = __webpack_require__(413); +var DOMException_1 = __webpack_require__(35); +var util_1 = __webpack_require__(918); /** * Represents a static range. */ -class StaticRangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { +var StaticRangeImpl = /** @class */ (function (_super) { + __extends(StaticRangeImpl, _super); /** * Initializes a new instance of `StaticRange`. */ - constructor(init) { - super(); + function StaticRangeImpl(init) { + var _this = _super.call(this) || this; /** * 1. If init’s startContainer or endContainer is a DocumentType or Attr * node, then throw an "InvalidNodeTypeError" DOMException. @@ -25442,449 +31976,225 @@ class StaticRangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl { util_1.Guard.isDocumentTypeNode(init.endContainer) || util_1.Guard.isAttrNode(init.endContainer)) { throw new DOMException_1.InvalidNodeTypeError(); } - this._start = [init.startContainer, init.startOffset]; - this._end = [init.endContainer, init.endOffset]; + _this._start = [init.startContainer, init.startOffset]; + _this._end = [init.endContainer, init.endOffset]; + return _this; } -} + return StaticRangeImpl; +}(AbstractRangeImpl_1.AbstractRangeImpl)); exports.StaticRangeImpl = StaticRangeImpl; //# sourceMappingURL=StaticRangeImpl.js.map /***/ }), - -/***/ 693: +/* 689 */, +/* 690 */, +/* 691 */, +/* 692 */, +/* 693 */, +/* 694 */, +/* 695 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(42); -/** - * Adds the given item to the end of the set. - * - * @param set - a set - * @param item - an item - */ -function append(set, item) { - set.add(item); -} -exports.append = append; -/** - * Extends a set by appending all items from another set. - * - * @param setA - a list to extend - * @param setB - a list containing items to append to `setA` - */ -function extend(setA, setB) { - setB.forEach(setA.add, setA); -} -exports.extend = extend; -/** - * Inserts the given item to the start of the set. - * - * @param set - a set - * @param item - an item - */ -function prepend(set, item) { - const cloned = new Set(set); - set.clear(); - set.add(item); - cloned.forEach(set.add, set); -} -exports.prepend = prepend; -/** - * Replaces the given item or all items matching condition with a new item. - * - * @param set - a set - * @param conditionOrItem - an item to replace or a condition matching items - * to replace - * @param item - an item - */ -function replace(set, conditionOrItem, newItem) { - const newSet = new Set(); - for (const oldItem of set) { - if (util_1.isFunction(conditionOrItem)) { - if (!!conditionOrItem.call(null, oldItem)) { - newSet.add(newItem); - } - else { - newSet.add(oldItem); - } - } - else if (oldItem === conditionOrItem) { - newSet.add(newItem); - } - else { - newSet.add(oldItem); - } - } - set.clear(); - newSet.forEach(set.add, set); -} -exports.replace = replace; -/** - * Inserts the given item before the given index. - * - * @param set - a set - * @param item - an item - */ -function insert(set, item, index) { - const newSet = new Set(); - let i = 0; - for (const oldItem of set) { - if (i === index) - newSet.add(item); - newSet.add(oldItem); - i++; - } - set.clear(); - newSet.forEach(set.add, set); -} -exports.insert = insert; -/** - * Removes the given item or all items matching condition. - * - * @param set - a set - * @param conditionOrItem - an item to remove or a condition matching items - * to remove - */ -function remove(set, conditionOrItem) { - if (!util_1.isFunction(conditionOrItem)) { - set.delete(conditionOrItem); - } - else { - const toRemove = []; - for (const item of set) { - if (!!conditionOrItem.call(null, item)) { - toRemove.push(item); - } - } - for (const oldItem of toRemove) { - set.delete(oldItem); - } - } -} -exports.remove = remove; -/** - * Removes all items from the set. - */ -function empty(set) { - set.clear(); -} -exports.empty = empty; -/** - * Determines if the set contains the given item or any items matching - * condition. - * - * @param set - a set - * @param conditionOrItem - an item to a condition to match - */ -function contains(set, conditionOrItem) { - if (!util_1.isFunction(conditionOrItem)) { - return set.has(conditionOrItem); - } - else { - for (const oldItem of set) { - if (!!conditionOrItem.call(null, oldItem)) { - return true; - } - } - } - return false; -} -exports.contains = contains; -/** - * Returns the count of items in the set matching the given condition. - * - * @param set - a set - * @param condition - an optional condition to match - */ -function size(set, condition) { - if (condition === undefined) { - return set.size; - } - else { - let count = 0; - for (const item of set) { - if (!!condition.call(null, item)) { - count++; - } - } - return count; - } -} -exports.size = size; -/** - * Determines if the set is empty. - * - * @param set - a set - */ -function isEmpty(set) { - return set.size === 0; -} -exports.isEmpty = isEmpty; -/** - * Returns an iterator for the items of the set. - * - * @param set - a set - * @param condition - an optional condition to match - */ -function* forEach(set, condition) { - if (condition === undefined) { - yield* set; - } - else { - for (const item of set) { - if (!!condition.call(null, item)) { - yield item; - } - } - } -} -exports.forEach = forEach; -/** - * Creates and returns a shallow clone of set. - * - * @param set - a set - */ -function clone(set) { - return new Set(set); -} -exports.clone = clone; -/** - * Returns a new set containing items from the set sorted in ascending - * order. - * - * @param set - a set - * @param lessThanAlgo - a function that returns `true` if its first argument - * is less than its second argument, and `false` otherwise. - */ -function sortInAscendingOrder(set, lessThanAlgo) { - const list = new Array(...set); - list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1); - return new Set(list); -} -exports.sortInAscendingOrder = sortInAscendingOrder; -/** - * Returns a new set containing items from the set sorted in descending - * order. - * - * @param set - a set - * @param lessThanAlgo - a function that returns `true` if its first argument - * is less than its second argument, and `false` otherwise. - */ -function sortInDescendingOrder(set, lessThanAlgo) { - const list = new Array(...set); - list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1); - return new Set(list); -} -exports.sortInDescendingOrder = sortInDescendingOrder; -/** - * Determines if a set is a subset of another set. - * - * @param subset - a set - * @param superset - a superset possibly containing all items from `subset`. - */ -function isSubsetOf(subset, superset) { - for (const item of subset) { - if (!superset.has(item)) - return false; - } - return true; -} -exports.isSubsetOf = isSubsetOf; -/** - * Determines if a set is a superset of another set. - * - * @param superset - a set - * @param subset - a subset possibly contained within `superset`. - */ -function isSupersetOf(superset, subset) { - return isSubsetOf(subset, superset); -} -exports.isSupersetOf = isSupersetOf; -/** - * Returns a new set with items that are contained in both sets. - * - * @param setA - a set - * @param setB - a set - */ -function intersection(setA, setB) { - const newSet = new Set(); - for (const item of setA) { - if (setB.has(item)) - newSet.add(item); - } - return newSet; -} -exports.intersection = intersection; -/** - * Returns a new set with items from both sets. - * - * @param setA - a set - * @param setB - a set - */ -function union(setA, setB) { - const newSet = new Set(setA); - setB.forEach(newSet.add, newSet); - return newSet; -} -exports.union = union; -/** - * Returns a set of integers from `n` to `m` inclusive. - * - * @param n - starting number - * @param m - ending number - */ -function range(n, m) { - const newSet = new Set(); - for (let i = n; i <= m; i++) { - newSet.add(i); - } - return newSet; -} -exports.range = range; -//# sourceMappingURL=Set.js.map - -/***/ }), - -/***/ 694: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -exports.INPUT_VERSION = 'version'; -exports.INPUT_JAVA_VERSION = 'java-version'; -exports.INPUT_ARCHITECTURE = 'architecture'; -exports.INPUT_JAVA_PACKAGE = 'java-package'; -exports.INPUT_JDK_FILE = 'jdkFile'; -exports.INPUT_SERVER_ID = 'server-id'; -exports.INPUT_SERVER_USERNAME = 'server-username'; -exports.INPUT_SERVER_PASSWORD = 'server-password'; -exports.INPUT_SETTINGS_PATH = 'settings-path'; -exports.INPUT_GPG_PRIVATE_KEY = 'gpg-private-key'; -exports.INPUT_GPG_PASSPHRASE = 'gpg-passphrase'; -exports.INPUT_DEFAULT_GPG_PRIVATE_KEY = undefined; -exports.INPUT_DEFAULT_GPG_PASSPHRASE = 'GPG_PASSPHRASE'; -exports.STATE_GPG_PRIVATE_KEY_FINGERPRINT = 'gpg-private-key-fingerprint'; - - -/***/ }), - -/***/ 695: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const NodeImpl_1 = __webpack_require__(935); -const DOMException_1 = __webpack_require__(35); -const infra_1 = __webpack_require__(23); -const algorithm_1 = __webpack_require__(163); -const WebIDLAlgorithm_1 = __webpack_require__(495); +var interfaces_1 = __webpack_require__(970); +var NodeImpl_1 = __webpack_require__(935); +var DOMException_1 = __webpack_require__(35); +var infra_1 = __webpack_require__(23); +var algorithm_1 = __webpack_require__(163); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** * Represents an element node. */ -class ElementImpl extends NodeImpl_1.NodeImpl { +var ElementImpl = /** @class */ (function (_super) { + __extends(ElementImpl, _super); /** * Initializes a new instance of `Element`. */ - constructor() { - super(); - this._children = new Set(); - this._namespace = null; - this._namespacePrefix = null; - this._localName = ""; - this._customElementState = "undefined"; - this._customElementDefinition = null; - this._is = null; - this._shadowRoot = null; - this._attributeList = algorithm_1.create_namedNodeMap(this); - this._attributeChangeSteps = []; - this._name = ''; - this._assignedSlot = null; + function ElementImpl() { + var _this = _super.call(this) || this; + _this._children = new Set(); + _this._namespace = null; + _this._namespacePrefix = null; + _this._localName = ""; + _this._customElementState = "undefined"; + _this._customElementDefinition = null; + _this._is = null; + _this._shadowRoot = null; + _this._attributeList = algorithm_1.create_namedNodeMap(_this); + _this._attributeChangeSteps = []; + _this._name = ''; + _this._assignedSlot = null; + return _this; } + Object.defineProperty(ElementImpl.prototype, "namespaceURI", { + /** @inheritdoc */ + get: function () { return this._namespace; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "prefix", { + /** @inheritdoc */ + get: function () { return this._namespacePrefix; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "localName", { + /** @inheritdoc */ + get: function () { return this._localName; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "tagName", { + /** @inheritdoc */ + get: function () { return this._htmlUppercasedQualifiedName; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "id", { + /** @inheritdoc */ + get: function () { + return algorithm_1.element_getAnAttributeValue(this, "id"); + }, + set: function (value) { + algorithm_1.element_setAnAttributeValue(this, "id", value); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "className", { + /** @inheritdoc */ + get: function () { + return algorithm_1.element_getAnAttributeValue(this, "class"); + }, + set: function (value) { + algorithm_1.element_setAnAttributeValue(this, "class", value); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "classList", { + /** @inheritdoc */ + get: function () { + var attr = algorithm_1.element_getAnAttributeByName("class", this); + if (attr === null) { + attr = algorithm_1.create_attr(this._nodeDocument, "class"); + } + return algorithm_1.create_domTokenList(this, attr); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "slot", { + /** @inheritdoc */ + get: function () { + return algorithm_1.element_getAnAttributeValue(this, "slot"); + }, + set: function (value) { + algorithm_1.element_setAnAttributeValue(this, "slot", value); + }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get namespaceURI() { return this._namespace; } - /** @inheritdoc */ - get prefix() { return this._namespacePrefix; } - /** @inheritdoc */ - get localName() { return this._localName; } - /** @inheritdoc */ - get tagName() { return this._htmlUppercasedQualifiedName; } - /** @inheritdoc */ - get id() { - return algorithm_1.element_getAnAttributeValue(this, "id"); - } - set id(value) { - algorithm_1.element_setAnAttributeValue(this, "id", value); - } - /** @inheritdoc */ - get className() { - return algorithm_1.element_getAnAttributeValue(this, "class"); - } - set className(value) { - algorithm_1.element_setAnAttributeValue(this, "class", value); - } - /** @inheritdoc */ - get classList() { - let attr = algorithm_1.element_getAnAttributeByName("class", this); - if (attr === null) { - attr = algorithm_1.create_attr(this._nodeDocument, "class"); - } - return algorithm_1.create_domTokenList(this, attr); - } - /** @inheritdoc */ - get slot() { - return algorithm_1.element_getAnAttributeValue(this, "slot"); - } - set slot(value) { - algorithm_1.element_setAnAttributeValue(this, "slot", value); - } - /** @inheritdoc */ - hasAttributes() { + ElementImpl.prototype.hasAttributes = function () { return this._attributeList.length !== 0; - } + }; + Object.defineProperty(ElementImpl.prototype, "attributes", { + /** @inheritdoc */ + get: function () { return this._attributeList; }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get attributes() { return this._attributeList; } - /** @inheritdoc */ - getAttributeNames() { + ElementImpl.prototype.getAttributeNames = function () { + var e_1, _a; /** * The getAttributeNames() method, when invoked, must return the qualified * names of the attributes in context object’s attribute list, in order, * and a new list otherwise. */ - const names = []; - for (const attr of this._attributeList) { - names.push(attr._qualifiedName); + var names = []; + try { + for (var _b = __values(this._attributeList), _c = _b.next(); !_c.done; _c = _b.next()) { + var attr = _c.value; + names.push(attr._qualifiedName); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } } return names; - } + }; /** @inheritdoc */ - getAttribute(qualifiedName) { + ElementImpl.prototype.getAttribute = function (qualifiedName) { /** * 1. Let attr be the result of getting an attribute given qualifiedName * and the context object. * 2. If attr is null, return null. * 3. Return attr’s value. */ - const attr = algorithm_1.element_getAnAttributeByName(qualifiedName, this); + var attr = algorithm_1.element_getAnAttributeByName(qualifiedName, this); return (attr ? attr._value : null); - } + }; /** @inheritdoc */ - getAttributeNS(namespace, localName) { + ElementImpl.prototype.getAttributeNS = function (namespace, localName) { /** * 1. Let attr be the result of getting an attribute given namespace, * localName, and the context object. * 2. If attr is null, return null. * 3. Return attr’s value. */ - const attr = algorithm_1.element_getAnAttributeByNamespaceAndLocalName(namespace, localName, this); + var attr = algorithm_1.element_getAnAttributeByNamespaceAndLocalName(namespace, localName, this); return (attr ? attr._value : null); - } + }; /** @inheritdoc */ - setAttribute(qualifiedName, value) { + ElementImpl.prototype.setAttribute = function (qualifiedName, value) { /** * 1. If qualifiedName does not match the Name production in XML, then * throw an "InvalidCharacterError" DOMException. @@ -25903,9 +32213,9 @@ class ElementImpl extends NodeImpl_1.NodeImpl { * 3. Let attribute be the first attribute in context object’s attribute * list whose qualified name is qualifiedName, and null otherwise. */ - let attribute = null; - for (let i = 0; i < this._attributeList.length; i++) { - const attr = this._attributeList[i]; + var attribute = null; + for (var i = 0; i < this._attributeList.length; i++) { + var attr = this._attributeList[i]; if (attr._qualifiedName === qualifiedName) { attribute = attr; break; @@ -25927,38 +32237,38 @@ class ElementImpl extends NodeImpl_1.NodeImpl { * 5. Change attribute from context object to value. */ algorithm_1.element_change(attribute, this, value); - } + }; /** @inheritdoc */ - setAttributeNS(namespace, qualifiedName, value) { + ElementImpl.prototype.setAttributeNS = function (namespace, qualifiedName, value) { /** * 1. Let namespace, prefix, and localName be the result of passing * namespace and qualifiedName to validate and extract. * 2. Set an attribute value for the context object using localName, value, * and also prefix and namespace. */ - const [ns, prefix, localName] = algorithm_1.namespace_validateAndExtract(namespace, qualifiedName); + var _a = __read(algorithm_1.namespace_validateAndExtract(namespace, qualifiedName), 3), ns = _a[0], prefix = _a[1], localName = _a[2]; algorithm_1.element_setAnAttributeValue(this, localName, value, prefix, ns); - } + }; /** @inheritdoc */ - removeAttribute(qualifiedName) { + ElementImpl.prototype.removeAttribute = function (qualifiedName) { /** * The removeAttribute(qualifiedName) method, when invoked, must remove an * attribute given qualifiedName and the context object, and then return * undefined. */ algorithm_1.element_removeAnAttributeByName(qualifiedName, this); - } + }; /** @inheritdoc */ - removeAttributeNS(namespace, localName) { + ElementImpl.prototype.removeAttributeNS = function (namespace, localName) { /** * The removeAttributeNS(namespace, localName) method, when invoked, must * remove an attribute given namespace, localName, and context object, and * then return undefined. */ algorithm_1.element_removeAnAttributeByNamespaceAndLocalName(namespace, localName, this); - } + }; /** @inheritdoc */ - hasAttribute(qualifiedName) { + ElementImpl.prototype.hasAttribute = function (qualifiedName) { /** * 1. If the context object is in the HTML namespace and its node document * is an HTML document, then set qualifiedName to qualifiedName in ASCII @@ -25969,16 +32279,16 @@ class ElementImpl extends NodeImpl_1.NodeImpl { if (this._namespace === infra_1.namespace.HTML && this._nodeDocument._type === "html") { qualifiedName = qualifiedName.toLowerCase(); } - for (let i = 0; i < this._attributeList.length; i++) { - const attr = this._attributeList[i]; + for (var i = 0; i < this._attributeList.length; i++) { + var attr = this._attributeList[i]; if (attr._qualifiedName === qualifiedName) { return true; } } return false; - } + }; /** @inheritdoc */ - toggleAttribute(qualifiedName, force) { + ElementImpl.prototype.toggleAttribute = function (qualifiedName, force) { /** * 1. If qualifiedName does not match the Name production in XML, then * throw an "InvalidCharacterError" DOMException. @@ -25997,9 +32307,9 @@ class ElementImpl extends NodeImpl_1.NodeImpl { * 3. Let attribute be the first attribute in the context object’s attribute * list whose qualified name is qualifiedName, and null otherwise. */ - let attribute = null; - for (let i = 0; i < this._attributeList.length; i++) { - const attr = this._attributeList[i]; + var attribute = null; + for (var i = 0; i < this._attributeList.length; i++) { + var attr = this._attributeList[i]; if (attr._qualifiedName === qualifiedName) { attribute = attr; break; @@ -26034,64 +32344,64 @@ class ElementImpl extends NodeImpl_1.NodeImpl { * 6. Return true. */ return true; - } + }; /** @inheritdoc */ - hasAttributeNS(namespace, localName) { + ElementImpl.prototype.hasAttributeNS = function (namespace, localName) { /** * 1. If namespace is the empty string, set it to null. * 2. Return true if the context object has an attribute whose namespace is * namespace and local name is localName, and false otherwise. */ - const ns = namespace || null; - for (let i = 0; i < this._attributeList.length; i++) { - const attr = this._attributeList[i]; + var ns = namespace || null; + for (var i = 0; i < this._attributeList.length; i++) { + var attr = this._attributeList[i]; if (attr._namespace === ns && attr._localName === localName) { return true; } } return false; - } + }; /** @inheritdoc */ - getAttributeNode(qualifiedName) { + ElementImpl.prototype.getAttributeNode = function (qualifiedName) { /** * The getAttributeNode(qualifiedName) method, when invoked, must return the * result of getting an attribute given qualifiedName and context object. */ return algorithm_1.element_getAnAttributeByName(qualifiedName, this); - } + }; /** @inheritdoc */ - getAttributeNodeNS(namespace, localName) { + ElementImpl.prototype.getAttributeNodeNS = function (namespace, localName) { /** * The getAttributeNodeNS(namespace, localName) method, when invoked, must * return the result of getting an attribute given namespace, localName, and * the context object. */ return algorithm_1.element_getAnAttributeByNamespaceAndLocalName(namespace, localName, this); - } + }; /** @inheritdoc */ - setAttributeNode(attr) { + ElementImpl.prototype.setAttributeNode = function (attr) { /** * The setAttributeNode(attr) and setAttributeNodeNS(attr) methods, when * invoked, must return the result of setting an attribute given attr and * the context object. */ return algorithm_1.element_setAnAttribute(attr, this); - } + }; /** @inheritdoc */ - setAttributeNodeNS(attr) { + ElementImpl.prototype.setAttributeNodeNS = function (attr) { return algorithm_1.element_setAnAttribute(attr, this); - } + }; /** @inheritdoc */ - removeAttributeNode(attr) { + ElementImpl.prototype.removeAttributeNode = function (attr) { /** * 1. If context object’s attribute list does not contain attr, then throw * a "NotFoundError" DOMException. * 2. Remove attr from context object. * 3. Return attr. */ - let found = false; - for (let i = 0; i < this._attributeList.length; i++) { - const attribute = this._attributeList[i]; + var found = false; + for (var i = 0; i < this._attributeList.length; i++) { + var attribute = this._attributeList[i]; if (attribute === attr) { found = true; break; @@ -26101,9 +32411,9 @@ class ElementImpl extends NodeImpl_1.NodeImpl { throw new DOMException_1.NotFoundError(); algorithm_1.element_remove(attr, this); return attr; - } + }; /** @inheritdoc */ - attachShadow(init) { + ElementImpl.prototype.attachShadow = function (init) { /** * 1. If context object’s namespace is not the HTML namespace, then throw a * "NotSupportedError" DOMException. @@ -26129,7 +32439,7 @@ class ElementImpl extends NodeImpl_1.NodeImpl { * then throw a "NotSupportedError" DOMException. */ if (algorithm_1.customElement_isValidCustomElementName(this._localName) || this._is !== null) { - const definition = algorithm_1.customElement_lookUpACustomElementDefinition(this._nodeDocument, this._namespace, this._localName, this._is); + var definition = algorithm_1.customElement_lookUpACustomElementDefinition(this._nodeDocument, this._namespace, this._localName, this._is); if (definition !== null && definition.disableShadow === true) { throw new DOMException_1.NotSupportedError(); } @@ -26146,26 +32456,30 @@ class ElementImpl extends NodeImpl_1.NodeImpl { * 6. Set context object’s shadow root to shadow. * 7. Return shadow. */ - const shadow = algorithm_1.create_shadowRoot(this._nodeDocument, this); + var shadow = algorithm_1.create_shadowRoot(this._nodeDocument, this); shadow._mode = init.mode; this._shadowRoot = shadow; return shadow; - } + }; + Object.defineProperty(ElementImpl.prototype, "shadowRoot", { + /** @inheritdoc */ + get: function () { + /** + * 1. Let shadow be context object’s shadow root. + * 2. If shadow is null or its mode is "closed", then return null. + * 3. Return shadow. + */ + var shadow = this._shadowRoot; + if (shadow === null || shadow.mode === "closed") + return null; + else + return shadow; + }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get shadowRoot() { - /** - * 1. Let shadow be context object’s shadow root. - * 2. If shadow is null or its mode is "closed", then return null. - * 3. Return shadow. - */ - const shadow = this._shadowRoot; - if (shadow === null || shadow.mode === "closed") - return null; - else - return shadow; - } - /** @inheritdoc */ - closest(selectors) { + ElementImpl.prototype.closest = function (selectors) { /** * TODO: Selectors * 1. Let s be the result of parse a selector from selectors. [SELECTORS4] @@ -26178,9 +32492,9 @@ class ElementImpl extends NodeImpl_1.NodeImpl { * 5. Return null. */ throw new DOMException_1.NotImplementedError(); - } + }; /** @inheritdoc */ - matches(selectors) { + ElementImpl.prototype.matches = function (selectors) { /** * TODO: Selectors * 1. Let s be the result of parse a selector from selectors. [SELECTORS4] @@ -26190,120 +32504,186 @@ class ElementImpl extends NodeImpl_1.NodeImpl { * and false otherwise. [SELECTORS4] */ throw new DOMException_1.NotImplementedError(); - } + }; /** @inheritdoc */ - webkitMatchesSelector(selectors) { + ElementImpl.prototype.webkitMatchesSelector = function (selectors) { return this.matches(selectors); - } + }; /** @inheritdoc */ - getElementsByTagName(qualifiedName) { + ElementImpl.prototype.getElementsByTagName = function (qualifiedName) { /** * The getElementsByTagName(qualifiedName) method, when invoked, must return * the list of elements with qualified name qualifiedName for context * object. */ return algorithm_1.node_listOfElementsWithQualifiedName(qualifiedName, this); - } + }; /** @inheritdoc */ - getElementsByTagNameNS(namespace, localName) { + ElementImpl.prototype.getElementsByTagNameNS = function (namespace, localName) { /** * The getElementsByTagNameNS(namespace, localName) method, when invoked, * must return the list of elements with namespace namespace and local name * localName for context object. */ return algorithm_1.node_listOfElementsWithNamespace(namespace, localName, this); - } + }; /** @inheritdoc */ - getElementsByClassName(classNames) { + ElementImpl.prototype.getElementsByClassName = function (classNames) { /** * The getElementsByClassName(classNames) method, when invoked, must return * the list of elements with class names classNames for context object. */ return algorithm_1.node_listOfElementsWithClassNames(classNames, this); - } + }; /** @inheritdoc */ - insertAdjacentElement(where, element) { + ElementImpl.prototype.insertAdjacentElement = function (where, element) { /** * The insertAdjacentElement(where, element) method, when invoked, must * return the result of running insert adjacent, given context object, * where, and element. */ return algorithm_1.element_insertAdjacent(this, where, element); - } + }; /** @inheritdoc */ - insertAdjacentText(where, data) { + ElementImpl.prototype.insertAdjacentText = function (where, data) { /** * 1. Let text be a new Text node whose data is data and node document is * context object’s node document. * 2. Run insert adjacent, given context object, where, and text. */ - const text = algorithm_1.create_text(this._nodeDocument, data); + var text = algorithm_1.create_text(this._nodeDocument, data); algorithm_1.element_insertAdjacent(this, where, text); - } - /** - * Returns the qualified name. - */ - get _qualifiedName() { + }; + Object.defineProperty(ElementImpl.prototype, "_qualifiedName", { /** - * An element’s qualified name is its local name if its namespace prefix is - * null, and its namespace prefix, followed by ":", followed by its - * local name, otherwise. + * Returns the qualified name. */ - return (this._namespacePrefix ? - this._namespacePrefix + ':' + this._localName : - this._localName); - } - /** - * Returns the upper-cased qualified name for a html element. - */ - get _htmlUppercasedQualifiedName() { + get: function () { + /** + * An element’s qualified name is its local name if its namespace prefix is + * null, and its namespace prefix, followed by ":", followed by its + * local name, otherwise. + */ + return (this._namespacePrefix ? + this._namespacePrefix + ':' + this._localName : + this._localName); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "_htmlUppercasedQualifiedName", { /** - * 1. Let qualifiedName be context object’s qualified name. - * 2. If the context object is in the HTML namespace and its node document - * is an HTML document, then set qualifiedName to qualifiedName in ASCII - * uppercase. - * 3. Return qualifiedName. + * Returns the upper-cased qualified name for a html element. */ - let qualifiedName = this._qualifiedName; - if (this._namespace === infra_1.namespace.HTML && this._nodeDocument._type === "html") { - qualifiedName = qualifiedName.toUpperCase(); + get: function () { + /** + * 1. Let qualifiedName be context object’s qualified name. + * 2. If the context object is in the HTML namespace and its node document + * is an HTML document, then set qualifiedName to qualifiedName in ASCII + * uppercase. + * 3. Return qualifiedName. + */ + var qualifiedName = this._qualifiedName; + if (this._namespace === infra_1.namespace.HTML && this._nodeDocument._type === "html") { + qualifiedName = qualifiedName.toUpperCase(); + } + return qualifiedName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "children", { + // MIXIN: ParentNode + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "firstElementChild", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "lastElementChild", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "childElementCount", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + /* istanbul ignore next */ + ElementImpl.prototype.prepend = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; } - return qualifiedName; - } - // MIXIN: ParentNode + throw new Error("Mixin: ParentNode not implemented."); + }; /* istanbul ignore next */ - get children() { throw new Error("Mixin: ParentNode not implemented."); } + ElementImpl.prototype.append = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ParentNode not implemented."); + }; /* istanbul ignore next */ - get firstElementChild() { throw new Error("Mixin: ParentNode not implemented."); } + ElementImpl.prototype.querySelector = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); }; /* istanbul ignore next */ - get lastElementChild() { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - get childElementCount() { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - prepend(...nodes) { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - append(...nodes) { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - querySelector(selectors) { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - querySelectorAll(selectors) { throw new Error("Mixin: ParentNode not implemented."); } - // MIXIN: NonDocumentTypeChildNode - /* istanbul ignore next */ - get previousElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); } - /* istanbul ignore next */ - get nextElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); } + ElementImpl.prototype.querySelectorAll = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); }; + Object.defineProperty(ElementImpl.prototype, "previousElementSibling", { + // MIXIN: NonDocumentTypeChildNode + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ElementImpl.prototype, "nextElementSibling", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }, + enumerable: true, + configurable: true + }); // MIXIN: ChildNode /* istanbul ignore next */ - before(...nodes) { throw new Error("Mixin: ChildNode not implemented."); } + ElementImpl.prototype.before = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ChildNode not implemented."); + }; /* istanbul ignore next */ - after(...nodes) { throw new Error("Mixin: ChildNode not implemented."); } + ElementImpl.prototype.after = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ChildNode not implemented."); + }; /* istanbul ignore next */ - replaceWith(...nodes) { throw new Error("Mixin: ChildNode not implemented."); } + ElementImpl.prototype.replaceWith = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ChildNode not implemented."); + }; /* istanbul ignore next */ - remove() { throw new Error("Mixin: ChildNode not implemented."); } - // MIXIN: Slotable - /* istanbul ignore next */ - get assignedSlot() { throw new Error("Mixin: Slotable not implemented."); } + ElementImpl.prototype.remove = function () { throw new Error("Mixin: ChildNode not implemented."); }; + Object.defineProperty(ElementImpl.prototype, "assignedSlot", { + // MIXIN: Slotable + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: Slotable not implemented."); }, + enumerable: true, + configurable: true + }); /** * Creates a new `Element`. * @@ -26312,15 +32692,18 @@ class ElementImpl extends NodeImpl_1.NodeImpl { * @param namespace - namespace * @param prefix - namespace prefix */ - static _create(document, localName, namespace = null, namespacePrefix = null) { - const node = new ElementImpl(); + ElementImpl._create = function (document, localName, namespace, namespacePrefix) { + if (namespace === void 0) { namespace = null; } + if (namespacePrefix === void 0) { namespacePrefix = null; } + var node = new ElementImpl(); node._localName = localName; node._namespace = namespace; node._namespacePrefix = namespacePrefix; node._nodeDocument = document; return node; - } -} + }; + return ElementImpl; +}(NodeImpl_1.NodeImpl)); exports.ElementImpl = ElementImpl; /** * Initialize prototype properties @@ -26329,88 +32712,410 @@ WebIDLAlgorithm_1.idl_defineConst(ElementImpl.prototype, "_nodeType", interfaces //# sourceMappingURL=ElementImpl.js.map /***/ }), - -/***/ 699: -/***/ (function(__unusedmodule, exports) { +/* 696 */, +/* 697 */, +/* 698 */, +/* 699 */, +/* 700 */, +/* 701 */, +/* 702 */ +/***/ (function(module, __unusedexports, __webpack_require__) { "use strict"; -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents a cache for storing order between equal objects. - * - * This cache is used when an algorithm compares two objects and finds them to - * be equal but still needs to establish an order between those two objects. - * When two such objects `a` and `b` are passed to the `check` method, a random - * number is generated with `Math.random()`. If the random number is less than - * `0.5` it is assumed that `a < b` otherwise `a > b`. The random number along - * with `a` and `b` is stored in the cache, so that subsequent checks result - * in the same consistent result. - * - * The cache has a size limit which is defined on initialization. - */ -class CompareCache { - /** - * Initializes a new instance of `CompareCache`. - * - * @param limit - maximum number of items to keep in the cache. When the limit - * is exceeded the first item is removed from the cache. - */ - constructor(limit = 1000) { - this._items = new Map(); - this._limit = limit; + +// A linked list to keep track of recently-used-ness +const Yallist = __webpack_require__(612) + +const MAX = Symbol('max') +const LENGTH = Symbol('length') +const LENGTH_CALCULATOR = Symbol('lengthCalculator') +const ALLOW_STALE = Symbol('allowStale') +const MAX_AGE = Symbol('maxAge') +const DISPOSE = Symbol('dispose') +const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet') +const LRU_LIST = Symbol('lruList') +const CACHE = Symbol('cache') +const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet') + +const naiveLength = () => 1 + +// lruList is a yallist where the head is the youngest +// item, and the tail is the oldest. the list contains the Hit +// objects as the entries. +// Each Hit object has a reference to its Yallist.Node. This +// never changes. +// +// cache is a Map (or PseudoMap) that matches the keys to +// the Yallist.Node object. +class LRUCache { + constructor (options) { + if (typeof options === 'number') + options = { max: options } + + if (!options) + options = {} + + if (options.max && (typeof options.max !== 'number' || options.max < 0)) + throw new TypeError('max must be a non-negative number') + // Kind of weird to have a default max of Infinity, but oh well. + const max = this[MAX] = options.max || Infinity + + const lc = options.length || naiveLength + this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc + this[ALLOW_STALE] = options.stale || false + if (options.maxAge && typeof options.maxAge !== 'number') + throw new TypeError('maxAge must be a number') + this[MAX_AGE] = options.maxAge || 0 + this[DISPOSE] = options.dispose + this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false + this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false + this.reset() + } + + // resize the cache when the max changes. + set max (mL) { + if (typeof mL !== 'number' || mL < 0) + throw new TypeError('max must be a non-negative number') + + this[MAX] = mL || Infinity + trim(this) + } + get max () { + return this[MAX] + } + + set allowStale (allowStale) { + this[ALLOW_STALE] = !!allowStale + } + get allowStale () { + return this[ALLOW_STALE] + } + + set maxAge (mA) { + if (typeof mA !== 'number') + throw new TypeError('maxAge must be a non-negative number') + + this[MAX_AGE] = mA + trim(this) + } + get maxAge () { + return this[MAX_AGE] + } + + // resize the cache when the lengthCalculator changes. + set lengthCalculator (lC) { + if (typeof lC !== 'function') + lC = naiveLength + + if (lC !== this[LENGTH_CALCULATOR]) { + this[LENGTH_CALCULATOR] = lC + this[LENGTH] = 0 + this[LRU_LIST].forEach(hit => { + hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key) + this[LENGTH] += hit.length + }) } - /** - * Compares and caches the given objects. Returns `true` if `objA < objB` and - * `false` otherwise. - * - * @param objA - an item to compare - * @param objB - an item to compare - */ - check(objA, objB) { - if (this._items.get(objA) === objB) - return true; - else if (this._items.get(objB) === objA) - return false; - const result = (Math.random() < 0.5); - if (result) { - this._items.set(objA, objB); - } - else { - this._items.set(objB, objA); - } - if (this._items.size > this._limit) { - const it = this._items.keys().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - return result; + trim(this) + } + get lengthCalculator () { return this[LENGTH_CALCULATOR] } + + get length () { return this[LENGTH] } + get itemCount () { return this[LRU_LIST].length } + + rforEach (fn, thisp) { + thisp = thisp || this + for (let walker = this[LRU_LIST].tail; walker !== null;) { + const prev = walker.prev + forEachStep(this, fn, walker, thisp) + walker = prev } + } + + forEach (fn, thisp) { + thisp = thisp || this + for (let walker = this[LRU_LIST].head; walker !== null;) { + const next = walker.next + forEachStep(this, fn, walker, thisp) + walker = next + } + } + + keys () { + return this[LRU_LIST].toArray().map(k => k.key) + } + + values () { + return this[LRU_LIST].toArray().map(k => k.value) + } + + reset () { + if (this[DISPOSE] && + this[LRU_LIST] && + this[LRU_LIST].length) { + this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value)) + } + + this[CACHE] = new Map() // hash of items by key + this[LRU_LIST] = new Yallist() // list of items in order of use recency + this[LENGTH] = 0 // length of items in the list + } + + dump () { + return this[LRU_LIST].map(hit => + isStale(this, hit) ? false : { + k: hit.key, + v: hit.value, + e: hit.now + (hit.maxAge || 0) + }).toArray().filter(h => h) + } + + dumpLru () { + return this[LRU_LIST] + } + + set (key, value, maxAge) { + maxAge = maxAge || this[MAX_AGE] + + if (maxAge && typeof maxAge !== 'number') + throw new TypeError('maxAge must be a number') + + const now = maxAge ? Date.now() : 0 + const len = this[LENGTH_CALCULATOR](value, key) + + if (this[CACHE].has(key)) { + if (len > this[MAX]) { + del(this, this[CACHE].get(key)) + return false + } + + const node = this[CACHE].get(key) + const item = node.value + + // dispose of the old one before overwriting + // split out into 2 ifs for better coverage tracking + if (this[DISPOSE]) { + if (!this[NO_DISPOSE_ON_SET]) + this[DISPOSE](key, item.value) + } + + item.now = now + item.maxAge = maxAge + item.value = value + this[LENGTH] += len - item.length + item.length = len + this.get(key) + trim(this) + return true + } + + const hit = new Entry(key, value, len, now, maxAge) + + // oversized objects fall out of cache automatically. + if (hit.length > this[MAX]) { + if (this[DISPOSE]) + this[DISPOSE](key, value) + + return false + } + + this[LENGTH] += hit.length + this[LRU_LIST].unshift(hit) + this[CACHE].set(key, this[LRU_LIST].head) + trim(this) + return true + } + + has (key) { + if (!this[CACHE].has(key)) return false + const hit = this[CACHE].get(key).value + return !isStale(this, hit) + } + + get (key) { + return get(this, key, true) + } + + peek (key) { + return get(this, key, false) + } + + pop () { + const node = this[LRU_LIST].tail + if (!node) + return null + + del(this, node) + return node.value + } + + del (key) { + del(this, this[CACHE].get(key)) + } + + load (arr) { + // reset the cache + this.reset() + + const now = Date.now() + // A previous serialized cache has the most recent items first + for (let l = arr.length - 1; l >= 0; l--) { + const hit = arr[l] + const expiresAt = hit.e || 0 + if (expiresAt === 0) + // the item was created without expiration in a non aged cache + this.set(hit.k, hit.v) + else { + const maxAge = expiresAt - now + // dont add already expired items + if (maxAge > 0) { + this.set(hit.k, hit.v, maxAge) + } + } + } + } + + prune () { + this[CACHE].forEach((value, key) => get(this, key, false)) + } } -exports.CompareCache = CompareCache; -//# sourceMappingURL=CompareCache.js.map + +const get = (self, key, doUse) => { + const node = self[CACHE].get(key) + if (node) { + const hit = node.value + if (isStale(self, hit)) { + del(self, node) + if (!self[ALLOW_STALE]) + return undefined + } else { + if (doUse) { + if (self[UPDATE_AGE_ON_GET]) + node.value.now = Date.now() + self[LRU_LIST].unshiftNode(node) + } + } + return hit.value + } +} + +const isStale = (self, hit) => { + if (!hit || (!hit.maxAge && !self[MAX_AGE])) + return false + + const diff = Date.now() - hit.now + return hit.maxAge ? diff > hit.maxAge + : self[MAX_AGE] && (diff > self[MAX_AGE]) +} + +const trim = self => { + if (self[LENGTH] > self[MAX]) { + for (let walker = self[LRU_LIST].tail; + self[LENGTH] > self[MAX] && walker !== null;) { + // We know that we're about to delete this one, and also + // what the next least recently used key will be, so just + // go ahead and set it now. + const prev = walker.prev + del(self, walker) + walker = prev + } + } +} + +const del = (self, node) => { + if (node) { + const hit = node.value + if (self[DISPOSE]) + self[DISPOSE](hit.key, hit.value) + + self[LENGTH] -= hit.length + self[CACHE].delete(hit.key) + self[LRU_LIST].removeNode(node) + } +} + +class Entry { + constructor (key, value, length, now, maxAge) { + this.key = key + this.value = value + this.length = length + this.now = now + this.maxAge = maxAge || 0 + } +} + +const forEachStep = (self, fn, node, thisp) => { + let hit = node.value + if (isStale(self, hit)) { + del(self, node) + if (!self[ALLOW_STALE]) + hit = undefined + } + if (hit) + fn.call(thisp, hit.value, hit.key, self) +} + +module.exports = LRUCache + /***/ }), - -/***/ 704: +/* 703 */, +/* 704 */ /***/ (function(__unusedmodule, exports) { "use strict"; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); /** * Represents a set of objects with a size limit. */ -class FixedSizeSet { +var FixedSizeSet = /** @class */ (function () { /** * Initializes a new instance of `FixedSizeSet`. * * @param limit - maximum number of items to keep in the set. When the limit * is exceeded the first item is removed from the set. */ - constructor(limit = 1000) { + function FixedSizeSet(limit) { + if (limit === void 0) { limit = 1000; } this._items = new Set(); this._limit = limit; } @@ -26419,93 +33124,130 @@ class FixedSizeSet { * * @param item - an item */ - add(item) { + FixedSizeSet.prototype.add = function (item) { this._items.add(item); if (this._items.size > this._limit) { - const it = this._items.values().next(); + var it_1 = this._items.values().next(); /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); + if (!it_1.done) { + this._items.delete(it_1.value); } } return this; - } + }; /** * Removes an item from the set. * * @param item - an item */ - delete(item) { + FixedSizeSet.prototype.delete = function (item) { return this._items.delete(item); - } + }; /** * Determines if an item is in the set. * * @param item - an item */ - has(item) { + FixedSizeSet.prototype.has = function (item) { return this._items.has(item); - } + }; /** * Removes all items from the set. */ - clear() { + FixedSizeSet.prototype.clear = function () { this._items.clear(); - } - /** - * Gets the number of items in the set. - */ - get size() { return this._items.size; } + }; + Object.defineProperty(FixedSizeSet.prototype, "size", { + /** + * Gets the number of items in the set. + */ + get: function () { return this._items.size; }, + enumerable: true, + configurable: true + }); /** * Applies the given callback function to all elements of the set. */ - forEach(callback, thisArg) { - this._items.forEach(e => callback.call(thisArg, e, e, this)); - } + FixedSizeSet.prototype.forEach = function (callback, thisArg) { + var _this = this; + this._items.forEach(function (e) { return callback.call(thisArg, e, e, _this); }); + }; /** * Iterates through the items in the set. */ - *keys() { - yield* this._items.keys(); - } + FixedSizeSet.prototype.keys = function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(this._items.keys())]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }; /** * Iterates through the items in the set. */ - *values() { - yield* this._items.values(); - } + FixedSizeSet.prototype.values = function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(this._items.values())]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }; /** * Iterates through the items in the set. */ - *entries() { - yield* this._items.entries(); - } + FixedSizeSet.prototype.entries = function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(this._items.entries())]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }; /** * Iterates through the items in the set. */ - *[Symbol.iterator]() { - yield* this._items; - } - /** - * Returns the string tag of the set. - */ - get [Symbol.toStringTag]() { - return "FixedSizeSet"; - } -} + FixedSizeSet.prototype[Symbol.iterator] = function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(this._items)]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }; + Object.defineProperty(FixedSizeSet.prototype, Symbol.toStringTag, { + /** + * Returns the string tag of the set. + */ + get: function () { + return "FixedSizeSet"; + }, + enumerable: true, + configurable: true + }); + return FixedSizeSet; +}()); exports.FixedSizeSet = FixedSizeSet; //# sourceMappingURL=FixedSizeSet.js.map /***/ }), - -/***/ 705: +/* 705 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const TraversalAlgorithm_1 = __webpack_require__(464); +var interfaces_1 = __webpack_require__(970); +var TraversalAlgorithm_1 = __webpack_require__(464); /** * Returns the first or last child node, or `null` if there are none. * @@ -26520,12 +33262,12 @@ function treeWalker_traverseChildren(walker, first) { * if type is last. * 3. While node is non-null: */ - let node = (first ? walker._current._firstChild : walker._current._lastChild); + var node = (first ? walker._current._firstChild : walker._current._lastChild); while (node !== null) { /** * 3.1. Let result be the result of filtering node within walker. */ - const result = TraversalAlgorithm_1.traversal_filter(walker, node); + var result = TraversalAlgorithm_1.traversal_filter(walker, node); if (result === interfaces_1.FilterResult.Accept) { /** * 3.2. If result is FILTER_ACCEPT, then set walker’s current to node and @@ -26541,7 +33283,7 @@ function treeWalker_traverseChildren(walker, first) { * last child if type is last. * 3.3.2. If child is non-null, then set node to child and continue. */ - const child = (first ? node._firstChild : node._lastChild); + var child = (first ? node._firstChild : node._lastChild); if (child !== null) { node = child; continue; @@ -26556,7 +33298,7 @@ function treeWalker_traverseChildren(walker, first) { * node’s previous sibling if type is last. * 3.4.2. If sibling is non-null, then set node to sibling and break. */ - const sibling = (first ? node._nextSibling : node._previousSibling); + var sibling = (first ? node._nextSibling : node._previousSibling); if (sibling !== null) { node = sibling; break; @@ -26566,7 +33308,7 @@ function treeWalker_traverseChildren(walker, first) { * 3.4.4. If parent is null, walker’s root, or walker’s current, then * return null. */ - const parent = node._parent; + var parent = node._parent; if (parent === null || parent === walker._root || parent === walker._current) { return null; } @@ -26595,7 +33337,7 @@ function treeWalker_traverseSiblings(walker, next) { * 2. If node is root, then return null. * 3. While node is non-null: */ - let node = walker._current; + var node = walker._current; if (node === walker._root) return null; while (true) { @@ -26604,7 +33346,7 @@ function treeWalker_traverseSiblings(walker, next) { * previous sibling if type is previous. * 3.2. While sibling is non-null: */ - let sibling = (next ? node._nextSibling : node._previousSibling); + var sibling = (next ? node._nextSibling : node._previousSibling); while (sibling !== null) { /** * 3.2.1. Set node to sibling. @@ -26613,7 +33355,7 @@ function treeWalker_traverseSiblings(walker, next) { * and return node. */ node = sibling; - const result = TraversalAlgorithm_1.traversal_filter(walker, node); + var result = TraversalAlgorithm_1.traversal_filter(walker, node); if (result === interfaces_1.FilterResult.Accept) { walker._current = node; return node; @@ -26651,14 +33393,28 @@ exports.treeWalker_traverseSiblings = treeWalker_traverseSiblings; //# sourceMappingURL=TreeWalkerAlgorithm.js.map /***/ }), - -/***/ 710: +/* 706 */, +/* 707 */, +/* 708 */, +/* 709 */, +/* 710 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const EventAlgorithm_1 = __webpack_require__(108); +var EventAlgorithm_1 = __webpack_require__(826); /** * Adds an algorithm to the given abort signal. * @@ -26695,6 +33451,7 @@ exports.abort_remove = abort_remove; * @param signal - abort signal */ function abort_signalAbort(signal) { + var e_1, _a; /** * 1. If signal’s aborted flag is set, then return. * 2. Set signal’s aborted flag. @@ -26705,8 +33462,18 @@ function abort_signalAbort(signal) { if (signal._abortedFlag) return; signal._abortedFlag = true; - for (const algorithm of signal._abortAlgorithms) { - algorithm.call(signal); + try { + for (var _b = __values(signal._abortAlgorithms), _c = _b.next(); !_c.done; _c = _b.next()) { + var algorithm = _c.value; + algorithm.call(signal); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } } signal._abortAlgorithms.clear(); EventAlgorithm_1.event_fireAnEvent("abort", signal); @@ -26715,8 +33482,60 @@ exports.abort_signalAbort = abort_signalAbort; //# sourceMappingURL=AbortAlgorithm.js.map /***/ }), +/* 711 */, +/* 712 */, +/* 713 */, +/* 714 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 722: +const parse = __webpack_require__(830) +const valid = (version, options) => { + const v = parse(version, options) + return v ? v.version : null +} +module.exports = valid + + +/***/ }), +/* 715 */, +/* 716 */, +/* 717 */, +/* 718 */, +/* 719 */, +/* 720 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; +// Standard YAML's JSON schema. +// http://www.yaml.org/spec/1.2/spec.html#id2803231 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, this schema is not such strict as defined in the YAML specification. +// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc. + + + + + +var Schema = __webpack_require__(733); + + +module.exports = new Schema({ + include: [ + __webpack_require__(265) + ], + implicit: [ + __webpack_require__(809), + __webpack_require__(228), + __webpack_require__(44), + __webpack_require__(417) + ] +}); + + +/***/ }), +/* 721 */, +/* 722 */ /***/ (function(module) { /** @@ -26748,386 +33567,48 @@ module.exports = bytesToUuid; /***/ }), - -/***/ 724: -/***/ (function(__unusedmodule, exports, __webpack_require__) { +/* 723 */ +/***/ (function(module, __unusedexports, __webpack_require__) { "use strict"; +// JS-YAML's default schema for `safeLoad` function. +// It is not described in the YAML specification. +// +// This schema is based on standard YAML's Core schema and includes most of +// extra types described at YAML tag repository. (http://yaml.org/type/) + + + + + +var Schema = __webpack_require__(733); + + +module.exports = new Schema({ + include: [ + __webpack_require__(611) + ], + implicit: [ + __webpack_require__(841), + __webpack_require__(633) + ], + explicit: [ + __webpack_require__(913), + __webpack_require__(842), + __webpack_require__(75), + __webpack_require__(100) + ] +}); -Object.defineProperty(exports, "__esModule", { value: true }); -var ObjectCache_1 = __webpack_require__(326); -exports.ObjectCache = ObjectCache_1.ObjectCache; -var CompareCache_1 = __webpack_require__(699); -exports.CompareCache = CompareCache_1.CompareCache; -var StringWalker_1 = __webpack_require__(260); -exports.StringWalker = StringWalker_1.StringWalker; -/** - * Applies the mixin to a given class. - * - * @param baseClass - class to receive the mixin - * @param mixinClass - mixin class - * @param overrides - an array with names of function overrides. Base class - * functions whose names are in this array will be kept by prepending an - * underscore to their names. - */ -function applyMixin(baseClass, mixinClass, ...overrides) { - Object.getOwnPropertyNames(mixinClass.prototype).forEach(name => { - if (overrides.includes(name)) { - const orgPropDesc = Object.getOwnPropertyDescriptor(baseClass.prototype, name); - /* istanbul ignore else */ - if (orgPropDesc) { - Object.defineProperty(baseClass.prototype, "_" + name, orgPropDesc); - } - } - const propDesc = Object.getOwnPropertyDescriptor(mixinClass.prototype, name); - /* istanbul ignore else */ - if (propDesc) { - Object.defineProperty(baseClass.prototype, name, propDesc); - } - }); -} -exports.applyMixin = applyMixin; -/** - * Applies default values to the given object. - * - * @param obj - an object - * @param defaults - an object with default values - * @param overwrite - if set to `true` defaults object always overwrites object - * values, whether they are `undefined` or not. - */ -function applyDefaults(obj, defaults, overwrite = false) { - const result = clone(obj || {}); - for (const [key, val] of forEachObject(defaults)) { - if (isObject(val)) { - result[key] = applyDefaults(result[key], val); - } - else if (overwrite || result[key] === undefined) { - result[key] = val; - } - } - return result; -} -exports.applyDefaults = applyDefaults; -/** - * Iterates over items pairs of an array. - * - * @param arr - array to iterate - */ -function* forEachArray(arr) { - yield* arr; -} -exports.forEachArray = forEachArray; -/** - * Iterates over key/value pairs of a map or object. - * - * @param obj - map or object to iterate - */ -function* forEachObject(obj) { - if (isMap(obj)) { - yield* obj; - } - else { - for (const key in obj) { - /* istanbul ignore next */ - if (!obj.hasOwnProperty(key)) - continue; - yield [key, obj[key]]; - } - } -} -exports.forEachObject = forEachObject; -/** - * Returns the number of entries in a map or object. - * - * @param obj - map or object - */ -function objectLength(obj) { - if (isMap(obj)) { - return obj.size; - } - else { - return Object.keys(obj).length; - } -} -exports.objectLength = objectLength; -/** - * Gets the value of a key from a map or object. - * - * @param obj - map or object - * @param key - the key to retrieve - */ -function getObjectValue(obj, key) { - if (isMap(obj)) { - return obj.get(key); - } - else { - return obj[key]; - } -} -exports.getObjectValue = getObjectValue; -/** - * Removes a property from a map or object. - * - * @param obj - map or object - * @param key - the key to remove - */ -function removeObjectValue(obj, key) { - if (isMap(obj)) { - obj.delete(key); - } - else { - delete obj[key]; - } -} -exports.removeObjectValue = removeObjectValue; -/** - * Deep clones the given object. - * - * @param obj - an object - */ -function clone(obj) { - if (isFunction(obj)) { - return obj; - } - else if (isArray(obj)) { - const result = []; - for (const item of obj) { - result.push(clone(item)); - } - return result; - } - else if (isObject(obj)) { - const result = {}; - for (const key in obj) { - /* istanbul ignore next */ - if (obj.hasOwnProperty(key)) { - const val = obj[key]; - result[key] = clone(val); - } - } - return result; - } - else { - return obj; - } -} -exports.clone = clone; -/** - * Type guard for boolean types - * - * @param x - a variable to type check - */ -function isBoolean(x) { - return typeof x === "boolean"; -} -exports.isBoolean = isBoolean; -/** - * Type guard for numeric types - * - * @param x - a variable to type check - */ -function isNumber(x) { - return typeof x === "number"; -} -exports.isNumber = isNumber; -/** - * Type guard for strings - * - * @param x - a variable to type check - */ -function isString(x) { - return typeof x === "string"; -} -exports.isString = isString; -/** - * Type guard for function objects - * - * @param x - a variable to type check - */ -function isFunction(x) { - return !!x && Object.prototype.toString.call(x) === '[object Function]'; -} -exports.isFunction = isFunction; -/** - * Type guard for JS objects - * - * _Note:_ Functions are objects too - * - * @param x - a variable to type check - */ -function isObject(x) { - const type = typeof x; - return !!x && (type === 'function' || type === 'object'); -} -exports.isObject = isObject; -/** - * Type guard for arrays - * - * @param x - a variable to type check - */ -function isArray(x) { - return Array.isArray(x); -} -exports.isArray = isArray; -/** - * Type guard for maps. - * - * @param x - a variable to check - */ -function isMap(x) { - return x instanceof Map; -} -exports.isMap = isMap; -/** - * Determines if `x` is an empty Array or an Object with no own properties. - * - * @param x - a variable to check - */ -function isEmpty(x) { - if (isArray(x)) { - return !x.length; - } - else if (isObject(x)) { - for (const key in x) { - if (x.hasOwnProperty(key)) { - return false; - } - } - return true; - } - return false; -} -exports.isEmpty = isEmpty; -/** - * Determines if `x` is a plain Object. - * - * @param x - a variable to check - */ -function isPlainObject(x) { - if (isObject(x)) { - const proto = Object.getPrototypeOf(x); - const ctor = proto.constructor; - return proto && ctor && - (typeof ctor === 'function') && (ctor instanceof ctor) && - (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object)); - } - return false; -} -exports.isPlainObject = isPlainObject; -/** - * Determines if `x` is an iterable Object. - * - * @param x - a variable to check - */ -function isIterable(x) { - return x && (typeof x[Symbol.iterator] === 'function'); -} -exports.isIterable = isIterable; -/** - * Gets the primitive value of an object. - */ -function getValue(obj) { - if (isFunction(obj.valueOf)) { - return obj.valueOf(); - } - else { - return obj; - } -} -exports.getValue = getValue; -/** - * UTF-8 encodes the given string. - * - * @param input - a string - */ -function utf8Encode(input) { - const bytes = new Uint8Array(input.length * 4); - let byteIndex = 0; - for (let i = 0; i < input.length; i++) { - let char = input.charCodeAt(i); - if (char < 128) { - bytes[byteIndex++] = char; - continue; - } - else if (char < 2048) { - bytes[byteIndex++] = char >> 6 | 192; - } - else { - if (char > 0xd7ff && char < 0xdc00) { - if (++i >= input.length) { - throw new Error("Incomplete surrogate pair."); - } - const c2 = input.charCodeAt(i); - if (c2 < 0xdc00 || c2 > 0xdfff) { - throw new Error("Invalid surrogate character."); - } - char = 0x10000 + ((char & 0x03ff) << 10) + (c2 & 0x03ff); - bytes[byteIndex++] = char >> 18 | 240; - bytes[byteIndex++] = char >> 12 & 63 | 128; - } - else { - bytes[byteIndex++] = char >> 12 | 224; - } - bytes[byteIndex++] = char >> 6 & 63 | 128; - } - bytes[byteIndex++] = char & 63 | 128; - } - return bytes.subarray(0, byteIndex); -} -exports.utf8Encode = utf8Encode; -/** - * UTF-8 decodes the given byte sequence into a string. - * - * @param bytes - a byte sequence - */ -function utf8Decode(bytes) { - let result = ""; - let i = 0; - while (i < bytes.length) { - var c = bytes[i++]; - if (c > 127) { - if (c > 191 && c < 224) { - if (i >= bytes.length) { - throw new Error("Incomplete 2-byte sequence."); - } - c = (c & 31) << 6 | bytes[i++] & 63; - } - else if (c > 223 && c < 240) { - if (i + 1 >= bytes.length) { - throw new Error("Incomplete 3-byte sequence."); - } - c = (c & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63; - } - else if (c > 239 && c < 248) { - if (i + 2 >= bytes.length) { - throw new Error("Incomplete 4-byte sequence."); - } - c = (c & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63; - } - else { - throw new Error("Unknown multi-byte start."); - } - } - if (c <= 0xffff) { - result += String.fromCharCode(c); - } - else if (c <= 0x10ffff) { - c -= 0x10000; - result += String.fromCharCode(c >> 10 | 0xd800); - result += String.fromCharCode(c & 0x3FF | 0xdc00); - } - else { - throw new Error("Code point exceeds UTF-16 limit."); - } - } - return result; -} -exports.utf8Decode = utf8Decode; -//# sourceMappingURL=index.js.map /***/ }), - -/***/ 730: +/* 724 */, +/* 725 */, +/* 726 */, +/* 727 */, +/* 728 */, +/* 729 */, +/* 730 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -27136,7 +33617,7 @@ Object.defineProperty(exports, "__esModule", { value: true }); /** * Represents a mutation record. */ -class MutationRecordImpl { +var MutationRecordImpl = /** @class */ (function () { /** * Initializes a new instance of `MutationRecord`. * @@ -27156,7 +33637,7 @@ class MutationRecordImpl { * mutation, node `data` for a mutation to a CharacterData node and `null` * for a mutation to the tree of nodes. */ - constructor(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) { + function MutationRecordImpl(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) { this._type = type; this._target = target; this._addedNodes = addedNodes; @@ -27167,24 +33648,60 @@ class MutationRecordImpl { this._attributeNamespace = attributeNamespace; this._oldValue = oldValue; } - /** @inheritdoc */ - get type() { return this._type; } - /** @inheritdoc */ - get target() { return this._target; } - /** @inheritdoc */ - get addedNodes() { return this._addedNodes; } - /** @inheritdoc */ - get removedNodes() { return this._removedNodes; } - /** @inheritdoc */ - get previousSibling() { return this._previousSibling; } - /** @inheritdoc */ - get nextSibling() { return this._nextSibling; } - /** @inheritdoc */ - get attributeName() { return this._attributeName; } - /** @inheritdoc */ - get attributeNamespace() { return this._attributeNamespace; } - /** @inheritdoc */ - get oldValue() { return this._oldValue; } + Object.defineProperty(MutationRecordImpl.prototype, "type", { + /** @inheritdoc */ + get: function () { return this._type; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MutationRecordImpl.prototype, "target", { + /** @inheritdoc */ + get: function () { return this._target; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MutationRecordImpl.prototype, "addedNodes", { + /** @inheritdoc */ + get: function () { return this._addedNodes; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MutationRecordImpl.prototype, "removedNodes", { + /** @inheritdoc */ + get: function () { return this._removedNodes; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MutationRecordImpl.prototype, "previousSibling", { + /** @inheritdoc */ + get: function () { return this._previousSibling; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MutationRecordImpl.prototype, "nextSibling", { + /** @inheritdoc */ + get: function () { return this._nextSibling; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MutationRecordImpl.prototype, "attributeName", { + /** @inheritdoc */ + get: function () { return this._attributeName; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MutationRecordImpl.prototype, "attributeNamespace", { + /** @inheritdoc */ + get: function () { return this._attributeNamespace; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MutationRecordImpl.prototype, "oldValue", { + /** @inheritdoc */ + get: function () { return this._oldValue; }, + enumerable: true, + configurable: true + }); /** * Creates a new `MutationRecord`. * @@ -27204,308 +33721,222 @@ class MutationRecordImpl { * mutation, node `data` for a mutation to a CharacterData node and `null` * for a mutation to the tree of nodes. */ - static _create(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) { + MutationRecordImpl._create = function (type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) { return new MutationRecordImpl(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue); - } -} + }; + return MutationRecordImpl; +}()); exports.MutationRecordImpl = MutationRecordImpl; //# sourceMappingURL=MutationRecordImpl.js.map /***/ }), - -/***/ 742: -/***/ (function(__unusedmodule, exports, __webpack_require__) { +/* 731 */, +/* 732 */, +/* 733 */ +/***/ (function(module, __unusedexports, __webpack_require__) { "use strict"; -Object.defineProperty(exports, "__esModule", { value: true }); -const _1 = __webpack_require__(113); -const DOMException_1 = __webpack_require__(35); -const infra_1 = __webpack_require__(23); -const algorithm_1 = __webpack_require__(163); -/** - * Represents a token set. - */ -class DOMTokenListImpl { - /** - * Initializes a new instance of `DOMTokenList`. - * - * @param element - associated element - * @param attribute - associated attribute - */ - constructor(element, attribute) { - /** - * 1. Let element be associated element. - * 2. Let localName be associated attribute’s local name. - * 3. Let value be the result of getting an attribute value given element - * and localName. - * 4. Run the attribute change steps for element, localName, value, value, - * and null. - */ - this._element = element; - this._attribute = attribute; - this._tokenSet = new Set(); - const localName = attribute._localName; - const value = algorithm_1.element_getAnAttributeValue(element, localName); - // define a closure to be called when the associated attribute's value changes - const thisObj = this; - function updateTokenSet(element, localName, oldValue, value, namespace) { - /** - * 1. If localName is associated attribute’s local name, namespace is null, - * and value is null, then empty token set. - * 2. Otherwise, if localName is associated attribute’s local name, - * namespace is null, then set token set to value, parsed. - */ - if (localName === thisObj._attribute._localName && namespace === null) { - if (!value) - thisObj._tokenSet.clear(); - else - thisObj._tokenSet = algorithm_1.orderedSet_parse(value); - } - } - // add the closure to the associated element's attribute change steps - this._element._attributeChangeSteps.push(updateTokenSet); - if (_1.dom.features.steps) { - algorithm_1.dom_runAttributeChangeSteps(element, localName, value, value, null); - } - } - /** @inheritdoc */ - get length() { - /** - * The length attribute' getter must return context object’s token set’s - * size. - */ - return this._tokenSet.size; - } - /** @inheritdoc */ - item(index) { - /** - * 1. If index is equal to or greater than context object’s token set’s - * size, then return null. - * 2. Return context object’s token set[index]. - */ - let i = 0; - for (const token of this._tokenSet) { - if (i === index) - return token; - i++; - } - return null; - } - /** @inheritdoc */ - contains(token) { - /** - * The contains(token) method, when invoked, must return true if context - * object’s token set[token] exists, and false otherwise. - */ - return this._tokenSet.has(token); - } - /** @inheritdoc */ - add(...tokens) { - /** - * 1. For each token in tokens: - * 1.1. If token is the empty string, then throw a "SyntaxError" - * DOMException. - * 1.2. If token contains any ASCII whitespace, then throw an - * "InvalidCharacterError" DOMException. - * 2. For each token in tokens, append token to context object’s token set. - * 3. Run the update steps. - */ - for (const token of tokens) { - if (token === '') { - throw new DOMException_1.SyntaxError("Cannot add an empty token."); - } - else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) { - throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace."); - } - else { - this._tokenSet.add(token); - } - } - algorithm_1.tokenList_updateSteps(this); - } - /** @inheritdoc */ - remove(...tokens) { - /** - * 1. For each token in tokens: - * 1.1. If token is the empty string, then throw a "SyntaxError" - * DOMException. - * 1.2. If token contains any ASCII whitespace, then throw an - * "InvalidCharacterError" DOMException. - * 2. For each token in tokens, remove token from context object’s token set. - * 3. Run the update steps. - */ - for (const token of tokens) { - if (token === '') { - throw new DOMException_1.SyntaxError("Cannot remove an empty token."); - } - else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) { - throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace."); - } - else { - this._tokenSet.delete(token); - } - } - algorithm_1.tokenList_updateSteps(this); - } - /** @inheritdoc */ - toggle(token, force = undefined) { - /** - * 1. If token is the empty string, then throw a "SyntaxError" DOMException. - * 2. If token contains any ASCII whitespace, then throw an - * "InvalidCharacterError" DOMException. - */ - if (token === '') { - throw new DOMException_1.SyntaxError("Cannot toggle an empty token."); - } - else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) { - throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace."); - } - /** - * 3. If context object’s token set[token] exists, then: - */ - if (this._tokenSet.has(token)) { - /** - * 3.1. If force is either not given or is false, then remove token from - * context object’s token set, run the update steps and return false. - * 3.2. Return true. - */ - if (force === undefined || force === false) { - this._tokenSet.delete(token); - algorithm_1.tokenList_updateSteps(this); - return false; - } - return true; - } - /** - * 4. Otherwise, if force not given or is true, append token to context - * object’s token set, run the update steps, and return true. - */ - if (force === undefined || force === true) { - this._tokenSet.add(token); - algorithm_1.tokenList_updateSteps(this); - return true; - } - /** - * 5. Return false. - */ - return false; - } - /** @inheritdoc */ - replace(token, newToken) { - /** - * 1. If either token or newToken is the empty string, then throw a - * "SyntaxError" DOMException. - * 2. If either token or newToken contains any ASCII whitespace, then throw - * an "InvalidCharacterError" DOMException. - */ - if (token === '' || newToken === '') { - throw new DOMException_1.SyntaxError("Cannot replace an empty token."); - } - else if (infra_1.codePoint.ASCIIWhiteSpace.test(token) || infra_1.codePoint.ASCIIWhiteSpace.test(newToken)) { - throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace."); - } - /** - * 3. If context object’s token set does not contain token, then return - * false. - */ - if (!this._tokenSet.has(token)) - return false; - /** - * 4. Replace token in context object’s token set with newToken. - * 5. Run the update steps. - * 6. Return true. - */ - infra_1.set.replace(this._tokenSet, token, newToken); - algorithm_1.tokenList_updateSteps(this); - return true; - } - /** @inheritdoc */ - supports(token) { - /** - * 1. Let result be the return value of validation steps called with token. - * 2. Return result. - */ - return algorithm_1.tokenList_validationSteps(this, token); - } - /** @inheritdoc */ - get value() { - /** - * The value attribute must return the result of running context object’s - * serialize steps. - */ - return algorithm_1.tokenList_serializeSteps(this); - } - set value(value) { - /** - * Setting the value attribute must set an attribute value for the - * associated element using associated attribute’s local name and the given - * value. - */ - algorithm_1.element_setAnAttributeValue(this._element, this._attribute._localName, value); - } - /** - * Returns an iterator for the token set. - */ - [Symbol.iterator]() { - const it = this._tokenSet[Symbol.iterator](); - return { - next() { - return it.next(); - } - }; - } - /** - * Creates a new `DOMTokenList`. - * - * @param element - associated element - * @param attribute - associated attribute - */ - static _create(element, attribute) { - return new DOMTokenListImpl(element, attribute); - } + +/*eslint-disable max-len*/ + +var common = __webpack_require__(740); +var YAMLException = __webpack_require__(556); +var Type = __webpack_require__(945); + + +function compileList(schema, name, result) { + var exclude = []; + + schema.include.forEach(function (includedSchema) { + result = compileList(includedSchema, name, result); + }); + + schema[name].forEach(function (currentType) { + result.forEach(function (previousType, previousIndex) { + if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) { + exclude.push(previousIndex); + } + }); + + result.push(currentType); + }); + + return result.filter(function (type, index) { + return exclude.indexOf(index) === -1; + }); } -exports.DOMTokenListImpl = DOMTokenListImpl; -//# sourceMappingURL=DOMTokenListImpl.js.map + + +function compileMap(/* lists... */) { + var result = { + scalar: {}, + sequence: {}, + mapping: {}, + fallback: {} + }, index, length; + + function collectType(type) { + result[type.kind][type.tag] = result['fallback'][type.tag] = type; + } + + for (index = 0, length = arguments.length; index < length; index += 1) { + arguments[index].forEach(collectType); + } + return result; +} + + +function Schema(definition) { + this.include = definition.include || []; + this.implicit = definition.implicit || []; + this.explicit = definition.explicit || []; + + this.implicit.forEach(function (type) { + if (type.loadKind && type.loadKind !== 'scalar') { + throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.'); + } + }); + + this.compiledImplicit = compileList(this, 'implicit', []); + this.compiledExplicit = compileList(this, 'explicit', []); + this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit); +} + + +Schema.DEFAULT = null; + + +Schema.create = function createSchema() { + var schemas, types; + + switch (arguments.length) { + case 1: + schemas = Schema.DEFAULT; + types = arguments[0]; + break; + + case 2: + schemas = arguments[0]; + types = arguments[1]; + break; + + default: + throw new YAMLException('Wrong number of arguments for Schema.create function'); + } + + schemas = common.toArray(schemas); + types = common.toArray(types); + + if (!schemas.every(function (schema) { return schema instanceof Schema; })) { + throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.'); + } + + if (!types.every(function (type) { return type instanceof Type; })) { + throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.'); + } + + return new Schema({ + include: schemas, + explicit: types + }); +}; + + +module.exports = Schema; + /***/ }), +/* 734 */, +/* 735 */, +/* 736 */, +/* 737 */, +/* 738 */, +/* 739 */, +/* 740 */ +/***/ (function(module) { -/***/ 743: +"use strict"; + + + +function isNothing(subject) { + return (typeof subject === 'undefined') || (subject === null); +} + + +function isObject(subject) { + return (typeof subject === 'object') && (subject !== null); +} + + +function toArray(sequence) { + if (Array.isArray(sequence)) return sequence; + else if (isNothing(sequence)) return []; + + return [ sequence ]; +} + + +function extend(target, source) { + var index, length, key, sourceKeys; + + if (source) { + sourceKeys = Object.keys(source); + + for (index = 0, length = sourceKeys.length; index < length; index += 1) { + key = sourceKeys[index]; + target[key] = source[key]; + } + } + + return target; +} + + +function repeat(string, count) { + var result = '', cycle; + + for (cycle = 0; cycle < count; cycle += 1) { + result += string; + } + + return result; +} + + +function isNegativeZero(number) { + return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number); +} + + +module.exports.isNothing = isNothing; +module.exports.isObject = isObject; +module.exports.toArray = toArray; +module.exports.repeat = repeat; +module.exports.isNegativeZero = isNegativeZero; +module.exports.extend = extend; + + +/***/ }), +/* 741 */, +/* 742 */, +/* 743 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const dom_1 = __webpack_require__(252); -const dom_2 = __webpack_require__(113); -const util_1 = __webpack_require__(669); +var dom_1 = __webpack_require__(252); +var dom_2 = __webpack_require__(113); +var util_1 = __webpack_require__(592); dom_2.dom.setFeatures(false); -/** - * Throws an error if the parser returned an error document. - */ -function throwIfParserError(doc) { - const root = doc.documentElement; - if (root !== null && - root.localName === "parsererror" && - root.namespaceURI === "http://www.mozilla.org/newlayout/xml/parsererror.xml") { - const msgElement = root.firstElementChild; - /* istanbul ignore next */ - if (msgElement === null) - throw new Error("Error parsing XML string."); - const msg = msgElement.getAttribute("message"); - /* istanbul ignore next */ - if (msg === null) - throw new Error("Error parsing XML string."); - throw new Error(msg); - } -} -exports.throwIfParserError = throwIfParserError; /** * Creates an XML document without any child nodes. */ function createDocument() { - const impl = new dom_1.DOMImplementation(); - const doc = impl.createDocument(null, 'root', null); + var impl = new dom_1.DOMImplementation(); + var doc = impl.createDocument(null, 'root', null); /* istanbul ignore else */ if (doc.documentElement) { doc.removeChild(doc.documentElement); @@ -27513,17 +33944,11 @@ function createDocument() { return doc; } exports.createDocument = createDocument; -/** - * Creates a DOM parser. - */ -function createParser() { - return new dom_1.DOMParser(); -} -exports.createParser = createParser; /** * Sanitizes input strings with user supplied replacement characters. * * @param str - input string + * @param replacement - replacement character or function */ function sanitizeInput(str, replacement) { if (str == null) { @@ -27533,10 +33958,10 @@ function sanitizeInput(str, replacement) { return str + ""; } else { - let result = ""; + var result = ""; str = str + ""; - for (let i = 0; i < str.length; i++) { - let n = str.charCodeAt(i); + for (var i = 0; i < str.length; i++) { + var n = str.charCodeAt(i); // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] if (n === 0x9 || n === 0xA || n === 0xD || (n >= 0x20 && n <= 0xD7FF) || @@ -27545,17 +33970,11 @@ function sanitizeInput(str, replacement) { result += str.charAt(i); } else if (n >= 0xD800 && n <= 0xDBFF && i < str.length - 1) { - const n2 = str.charCodeAt(i + 1); + var n2 = str.charCodeAt(i + 1); if (n2 >= 0xDC00 && n2 <= 0xDFFF) { + // valid surrogate pair n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000; - if (n >= 0x10000 && n <= 0x10FFFF) { - // valid surrogate pair - result += String.fromCodePoint(n); - } - else { - // invalid surrogate pair - result += util_1.isString(replacement) ? replacement : replacement(String.fromCodePoint(n), i, str); - } + result += String.fromCodePoint(n); i++; } else { @@ -27575,66 +33994,103 @@ exports.sanitizeInput = sanitizeInput; //# sourceMappingURL=dom.js.map /***/ }), +/* 744 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 747: +const SemVer = __webpack_require__(65) +const major = (a, loose) => new SemVer(a, loose).major +module.exports = major + + +/***/ }), +/* 745 */, +/* 746 */, +/* 747 */ /***/ (function(module) { module.exports = require("fs"); /***/ }), - -/***/ 750: +/* 748 */, +/* 749 */, +/* 750 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(592); -const ObjectWriter_1 = __webpack_require__(419); -const BaseWriter_1 = __webpack_require__(462); +var util_1 = __webpack_require__(592); +var ObjectWriter_1 = __webpack_require__(419); +var BaseWriter_1 = __webpack_require__(462); /** * Serializes XML nodes into ES6 maps and arrays. */ -class MapWriter extends BaseWriter_1.BaseWriter { +var MapWriter = /** @class */ (function (_super) { + __extends(MapWriter, _super); + /** + * Initializes a new instance of `MapWriter`. + * + * @param builderOptions - XML builder options + * @param writerOptions - serialization options + */ + function MapWriter(builderOptions, writerOptions) { + var _this = _super.call(this, builderOptions) || this; + // provide default options + _this._writerOptions = util_1.applyDefaults(writerOptions, { + format: "map", + wellFormed: false, + noDoubleEncoding: false, + group: false, + verbose: false + }); + return _this; + } /** * Produces an XML serialization of the given node. * * @param node - node to serialize - * @param writerOptions - serialization options */ - serialize(node, writerOptions) { - const options = util_1.applyDefaults(writerOptions, { - format: "map", - wellFormed: false, - noDoubleEncoding: false, - group: false - }); + MapWriter.prototype.serialize = function (node) { // convert to object - const objectWriterOptions = util_1.applyDefaults(options, { + var objectWriterOptions = util_1.applyDefaults(this._writerOptions, { format: "object", wellFormed: false, - noDoubleEncoding: false + noDoubleEncoding: false, + verbose: false }); - const objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions); - const val = objectWriter.serialize(node, objectWriterOptions); + var objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions); + var val = objectWriter.serialize(node); // recursively convert object into Map return this._convertObject(val); - } + }; /** * Recursively converts a JS object into an ES5 map. * * @param obj - a JS object */ - _convertObject(obj) { + MapWriter.prototype._convertObject = function (obj) { if (util_1.isArray(obj)) { - for (let i = 0; i < obj.length; i++) { + for (var i = 0; i < obj.length; i++) { obj[i] = this._convertObject(obj[i]); } return obj; } else if (util_1.isObject(obj)) { - const map = new Map(); - for (const key in obj) { + var map = new Map(); + for (var key in obj) { map.set(key, this._convertObject(obj[key])); } return map; @@ -27642,33 +34098,110 @@ class MapWriter extends BaseWriter_1.BaseWriter { else { return obj; } - } -} + }; + return MapWriter; +}(BaseWriter_1.BaseWriter)); exports.MapWriter = MapWriter; //# sourceMappingURL=MapWriter.js.map /***/ }), +/* 751 */, +/* 752 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 760: +const eq = __webpack_require__(298) +const neq = __webpack_require__(85) +const gt = __webpack_require__(486) +const gte = __webpack_require__(167) +const lt = __webpack_require__(586) +const lte = __webpack_require__(898) + +const cmp = (a, op, b, loose) => { + switch (op) { + case '===': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a === b + + case '!==': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a !== b + + case '': + case '=': + case '==': + return eq(a, b, loose) + + case '!=': + return neq(a, b, loose) + + case '>': + return gt(a, b, loose) + + case '>=': + return gte(a, b, loose) + + case '<': + return lt(a, b, loose) + + case '<=': + return lte(a, b, loose) + + default: + throw new TypeError(`Invalid operator: ${op}`) + } +} +module.exports = cmp + + +/***/ }), +/* 753 */, +/* 754 */, +/* 755 */, +/* 756 */, +/* 757 */, +/* 758 */, +/* 759 */, +/* 760 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const CharacterDataImpl_1 = __webpack_require__(43); -const WebIDLAlgorithm_1 = __webpack_require__(495); +var interfaces_1 = __webpack_require__(970); +var CharacterDataImpl_1 = __webpack_require__(43); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** * Represents a comment node. */ -class CommentImpl extends CharacterDataImpl_1.CharacterDataImpl { +var CommentImpl = /** @class */ (function (_super) { + __extends(CommentImpl, _super); /** * Initializes a new instance of `Comment`. * * @param data - the text content */ - constructor(data = '') { - super(data); + function CommentImpl(data) { + if (data === void 0) { data = ''; } + return _super.call(this, data) || this; } /** * Creates a new `Comment`. @@ -27676,12 +34209,14 @@ class CommentImpl extends CharacterDataImpl_1.CharacterDataImpl { * @param document - owner document * @param data - node contents */ - static _create(document, data = '') { - const node = new CommentImpl(data); + CommentImpl._create = function (document, data) { + if (data === void 0) { data = ''; } + var node = new CommentImpl(data); node._nodeDocument = document; return node; - } -} + }; + return CommentImpl; +}(CharacterDataImpl_1.CharacterDataImpl)); exports.CommentImpl = CommentImpl; /** * Initialize prototype properties @@ -27690,14 +34225,15 @@ WebIDLAlgorithm_1.idl_defineConst(CommentImpl.prototype, "_nodeType", interfaces //# sourceMappingURL=CommentImpl.js.map /***/ }), - -/***/ 763: +/* 761 */, +/* 762 */, +/* 763 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const CodePoints_1 = __webpack_require__(11); +var CodePoints_1 = __webpack_require__(11); /** * Base-64 encodes the given string. * @@ -27779,35 +34315,46 @@ exports.forgivingBase64Decode = forgivingBase64Decode; //# sourceMappingURL=Base64.js.map /***/ }), - -/***/ 764: +/* 764 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(592); -const interfaces_1 = __webpack_require__(970); -const BaseWriter_1 = __webpack_require__(462); -const util_2 = __webpack_require__(918); +var util_1 = __webpack_require__(592); +var interfaces_1 = __webpack_require__(970); +var BaseWriter_1 = __webpack_require__(462); +var util_2 = __webpack_require__(918); /** * Serializes XML nodes into strings. */ -class XMLWriter extends BaseWriter_1.BaseWriter { - constructor() { - super(...arguments); - this._indentation = {}; - this._lengthToLastNewline = 0; - } +var XMLWriter = /** @class */ (function (_super) { + __extends(XMLWriter, _super); /** - * Produces an XML serialization of the given node. + * Initializes a new instance of `XMLWriter`. * - * @param node - node to serialize + * @param builderOptions - XML builder options * @param writerOptions - serialization options */ - serialize(node, writerOptions) { + function XMLWriter(builderOptions, writerOptions) { + var _this = _super.call(this, builderOptions) || this; + _this._indentation = {}; + _this._lengthToLastNewline = 0; // provide default options - this._options = util_1.applyDefaults(writerOptions, { + _this._writerOptions = util_1.applyDefaults(writerOptions, { wellFormed: false, noDoubleEncoding: false, headless: false, @@ -27820,31 +34367,43 @@ class XMLWriter extends BaseWriter_1.BaseWriter { indentTextOnlyNodes: false, spaceBeforeSlash: false }); + return _this; + } + /** + * Produces an XML serialization of the given node. + * + * @param node - node to serialize + */ + XMLWriter.prototype.serialize = function (node) { this._refs = { suppressPretty: false, emptyNode: false, markup: "" }; - // Serialize XML declaration since base serializer does not serialize it - if (node.nodeType === interfaces_1.NodeType.Document && !this._options.headless) { - this._beginLine(); - this._refs.markup = ""; - this._endLine(); + // Serialize XML declaration + if (node.nodeType === interfaces_1.NodeType.Document && !this._writerOptions.headless) { + this.declaration(this._builderOptions.version, this._builderOptions.encoding, this._builderOptions.standalone); } - this.serializeNode(node, this._options.wellFormed, this._options.noDoubleEncoding); + // recursively serialize node + this.serializeNode(node, this._writerOptions.wellFormed, this._writerOptions.noDoubleEncoding); // remove trailing newline - if (this._options.prettyPrint && - this._refs.markup.slice(-this._options.newline.length) === this._options.newline) { - this._refs.markup = this._refs.markup.slice(0, -this._options.newline.length); + if (this._writerOptions.prettyPrint && + this._refs.markup.slice(-this._writerOptions.newline.length) === this._writerOptions.newline) { + this._refs.markup = this._refs.markup.slice(0, -this._writerOptions.newline.length); } return this._refs.markup; - } + }; /** @inheritdoc */ - docType(name, publicId, systemId) { + XMLWriter.prototype.declaration = function (version, encoding, standalone) { + this._beginLine(); + this._refs.markup += ""; + this._endLine(); + }; + /** @inheritdoc */ + XMLWriter.prototype.docType = function (name, publicId, systemId) { this._beginLine(); if (publicId && systemId) { this._refs.markup += ""; @@ -27859,23 +34418,23 @@ class XMLWriter extends BaseWriter_1.BaseWriter { this._refs.markup += ""; } this._endLine(); - } + }; /** @inheritdoc */ - openTagBegin(name) { + XMLWriter.prototype.openTagBegin = function (name) { this._beginLine(); this._refs.markup += "<" + name; - } + }; /** @inheritdoc */ - openTagEnd(name, selfClosing, voidElement) { + XMLWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) { // do not indent text only elements or elements with empty text nodes this._refs.suppressPretty = false; this._refs.emptyNode = false; - if (this._options.prettyPrint && !selfClosing && !voidElement) { - let textOnlyNode = true; - let emptyNode = true; - let childNode = this.currentNode.firstChild; - let cdataCount = 0; - let textCount = 0; + if (this._writerOptions.prettyPrint && !selfClosing && !voidElement) { + var textOnlyNode = true; + var emptyNode = true; + var childNode = this.currentNode.firstChild; + var cdataCount = 0; + var textCount = 0; while (childNode) { if (util_2.Guard.isExclusiveTextNode(childNode)) { textCount++; @@ -27893,20 +34452,20 @@ class XMLWriter extends BaseWriter_1.BaseWriter { } childNode = childNode.nextSibling; } - this._refs.suppressPretty = !this._options.indentTextOnlyNodes && textOnlyNode && ((cdataCount <= 1 && textCount === 0) || cdataCount === 0); + this._refs.suppressPretty = !this._writerOptions.indentTextOnlyNodes && textOnlyNode && ((cdataCount <= 1 && textCount === 0) || cdataCount === 0); this._refs.emptyNode = emptyNode; } - if ((voidElement || selfClosing || this._refs.emptyNode) && this._options.allowEmptyTags) { + if ((voidElement || selfClosing || this._refs.emptyNode) && this._writerOptions.allowEmptyTags) { this._refs.markup += ">"; } else { this._refs.markup += voidElement ? " />" : - (selfClosing || this._refs.emptyNode) ? (this._options.spaceBeforeSlash ? " />" : "/>") : ">"; + (selfClosing || this._refs.emptyNode) ? (this._writerOptions.spaceBeforeSlash ? " />" : "/>") : ">"; } this._endLine(); - } + }; /** @inheritdoc */ - closeTag(name) { + XMLWriter.prototype.closeTag = function (name) { if (!this._refs.emptyNode) { this._beginLine(); this._refs.markup += ""; @@ -27914,12 +34473,12 @@ class XMLWriter extends BaseWriter_1.BaseWriter { this._refs.suppressPretty = false; this._refs.emptyNode = false; this._endLine(); - } + }; /** @inheritdoc */ - attribute(name, value) { - const str = name + "=\"" + value + "\""; - if (this._options.prettyPrint && this._options.width > 0 && - this._refs.markup.length - this._lengthToLastNewline + 1 + str.length > this._options.width) { + XMLWriter.prototype.attribute = function (name, value) { + var str = name + "=\"" + value + "\""; + if (this._writerOptions.prettyPrint && this._writerOptions.width > 0 && + this._refs.markup.length - this._lengthToLastNewline + 1 + str.length > this._writerOptions.width) { this._endLine(); this._beginLine(); this._refs.markup += this._indent(1) + str; @@ -27927,60 +34486,60 @@ class XMLWriter extends BaseWriter_1.BaseWriter { else { this._refs.markup += " " + str; } - } + }; /** @inheritdoc */ - text(data) { + XMLWriter.prototype.text = function (data) { if (data !== '') { this._beginLine(); this._refs.markup += data; this._endLine(); } - } + }; /** @inheritdoc */ - cdata(data) { + XMLWriter.prototype.cdata = function (data) { if (data !== '') { this._beginLine(); this._refs.markup += ""; this._endLine(); } - } + }; /** @inheritdoc */ - comment(data) { + XMLWriter.prototype.comment = function (data) { this._beginLine(); this._refs.markup += ""; this._endLine(); - } + }; /** @inheritdoc */ - instruction(target, data) { + XMLWriter.prototype.instruction = function (target, data) { this._beginLine(); this._refs.markup += ""; this._endLine(); - } + }; /** * Produces characters to be prepended to a line of string in pretty-print * mode. */ - _beginLine() { - if (this._options.prettyPrint && !this._refs.suppressPretty) { - this._refs.markup += this._indent(this._options.offset + this.level); + XMLWriter.prototype._beginLine = function () { + if (this._writerOptions.prettyPrint && !this._refs.suppressPretty) { + this._refs.markup += this._indent(this._writerOptions.offset + this.level); } - } + }; /** * Produces characters to be appended to a line of string in pretty-print * mode. */ - _endLine() { - if (this._options.prettyPrint && !this._refs.suppressPretty) { - this._refs.markup += this._options.newline; + XMLWriter.prototype._endLine = function () { + if (this._writerOptions.prettyPrint && !this._refs.suppressPretty) { + this._refs.markup += this._writerOptions.newline; this._lengthToLastNewline = this._refs.markup.length; } - } + }; /** * Produces an indentation string. * * @param level - depth of the tree */ - _indent(level) { + XMLWriter.prototype._indent = function (level) { if (level <= 0) { return ""; } @@ -27988,64 +34547,285 @@ class XMLWriter extends BaseWriter_1.BaseWriter { return this._indentation[level]; } else { - const str = this._options.indent.repeat(level); + var str = this._writerOptions.indent.repeat(level); this._indentation[level] = str; return str; } - } -} + }; + return XMLWriter; +}(BaseWriter_1.BaseWriter)); exports.XMLWriter = XMLWriter; //# sourceMappingURL=XMLWriter.js.map /***/ }), +/* 765 */, +/* 766 */, +/* 767 */, +/* 768 */, +/* 769 */, +/* 770 */, +/* 771 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { -/***/ 774: +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var XMLStringLexer_1 = __webpack_require__(911); +var interfaces_1 = __webpack_require__(172); +var infra_1 = __webpack_require__(23); +var algorithm_1 = __webpack_require__(163); +var dom_1 = __webpack_require__(743); +var BaseReader_1 = __webpack_require__(305); +/** + * Parses XML nodes from an XML document string. + */ +var XMLReader = /** @class */ (function (_super) { + __extends(XMLReader, _super); + function XMLReader() { + return _super !== null && _super.apply(this, arguments) || this; + } + /** + * Parses the given document representation. + * + * @param node - node receive parsed XML nodes + * @param str - XML document string to parse + */ + XMLReader.prototype._parse = function (node, str) { + var e_1, _a, e_2, _b; + var lexer = new XMLStringLexer_1.XMLStringLexer(str, { skipWhitespaceOnlyText: true }); + // sanitizes input characters + var invalidCharReplacement = this._builderOptions.invalidCharReplacement; + var s = function (str) { + return dom_1.sanitizeInput(str, invalidCharReplacement); + }; + var context = node; + var token = lexer.nextToken(); + while (token.type !== interfaces_1.TokenType.EOF) { + switch (token.type) { + case interfaces_1.TokenType.Declaration: + var declaration = token; + var version = s(declaration.version); + if (version !== "1.0") { + throw new Error("Invalid xml version: " + version); + } + var builderOptions = { + version: version + }; + if (declaration.encoding) { + builderOptions.encoding = s(declaration.encoding); + } + if (declaration.standalone) { + builderOptions.standalone = (s(declaration.standalone) === "yes"); + } + context.set(builderOptions); + break; + case interfaces_1.TokenType.DocType: + var doctype = token; + context = this.docType(context, s(doctype.name), s(doctype.pubId), s(doctype.sysId)) || context; + break; + case interfaces_1.TokenType.CDATA: + var cdata = token; + context = this.cdata(context, s(cdata.data)) || context; + break; + case interfaces_1.TokenType.Comment: + var comment = token; + context = this.comment(context, s(comment.data)) || context; + break; + case interfaces_1.TokenType.PI: + var pi = token; + context = this.instruction(context, s(pi.target), s(pi.data)) || context; + break; + case interfaces_1.TokenType.Text: + var text = token; + context = this.text(context, s(text.data)) || context; + break; + case interfaces_1.TokenType.Element: + var element = token; + var elementName = s(element.name); + // inherit namespace from parent + var _c = __read(algorithm_1.namespace_extractQName(elementName), 1), prefix = _c[0]; + var namespace = context.node.lookupNamespaceURI(prefix); + // override namespace if there is a namespace declaration + // attribute + // also lookup namespace declaration attributes + var nsDeclarations = {}; + try { + for (var _d = (e_1 = void 0, __values(element.attributes)), _e = _d.next(); !_e.done; _e = _d.next()) { + var _f = __read(_e.value, 2), attName = _f[0], attValue = _f[1]; + attName = s(attName); + attValue = s(attValue); + if (attName === "xmlns") { + namespace = attValue; + } + else { + var _g = __read(algorithm_1.namespace_extractQName(attName), 2), attPrefix = _g[0], attLocalName = _g[1]; + if (attPrefix === "xmlns") { + if (attLocalName === prefix) { + namespace = attValue; + } + nsDeclarations[attLocalName] = attValue; + } + } + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_e && !_e.done && (_a = _d.return)) _a.call(_d); + } + finally { if (e_1) throw e_1.error; } + } + // create the DOM element node + var elementNode = (namespace !== null ? + this.element(context, namespace, elementName) : + this.element(context, undefined, elementName)); + if (elementNode === undefined) + break; + try { + // assign attributes + for (var _h = (e_2 = void 0, __values(element.attributes)), _j = _h.next(); !_j.done; _j = _h.next()) { + var _k = __read(_j.value, 2), attName = _k[0], attValue = _k[1]; + attName = s(attName); + attValue = s(attValue); + var _l = __read(algorithm_1.namespace_extractQName(attName), 2), attPrefix = _l[0], attLocalName = _l[1]; + var attNamespace = null; + if (attPrefix === "xmlns" || (attPrefix === null && attLocalName === "xmlns")) { + // namespace declaration attribute + attNamespace = infra_1.namespace.XMLNS; + } + else { + attNamespace = elementNode.node.lookupNamespaceURI(attPrefix); + if (attNamespace !== null && elementNode.node.isDefaultNamespace(attNamespace)) { + attNamespace = null; + } + else if (attNamespace === null && attPrefix !== null) { + attNamespace = nsDeclarations[attPrefix] || null; + } + } + if (attNamespace !== null) + this.attribute(elementNode, attNamespace, attName, attValue); + else + this.attribute(elementNode, undefined, attName, attValue); + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_j && !_j.done && (_b = _h.return)) _b.call(_h); + } + finally { if (e_2) throw e_2.error; } + } + if (!element.selfClosing) { + context = elementNode; + } + break; + case interfaces_1.TokenType.ClosingTag: + /* istanbul ignore else */ + if (context.node.parentNode) { + context = context.up(); + } + break; + } + token = lexer.nextToken(); + } + return context; + }; + return XMLReader; +}(BaseReader_1.BaseReader)); +exports.XMLReader = XMLReader; +//# sourceMappingURL=XMLReader.js.map + +/***/ }), +/* 772 */, +/* 773 */, +/* 774 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const WebIDLAlgorithm_1 = __webpack_require__(495); +var interfaces_1 = __webpack_require__(970); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** * Represents a node filter. */ -class NodeFilterImpl { +var NodeFilterImpl = /** @class */ (function () { /** * Initializes a new instance of `NodeFilter`. */ - constructor() { + function NodeFilterImpl() { } /** * Callback function. */ - acceptNode(node) { + NodeFilterImpl.prototype.acceptNode = function (node) { return interfaces_1.FilterResult.Accept; - } + }; /** * Creates a new `NodeFilter`. */ - static _create() { + NodeFilterImpl._create = function () { return new NodeFilterImpl(); - } -} + }; + NodeFilterImpl.FILTER_ACCEPT = 1; + NodeFilterImpl.FILTER_REJECT = 2; + NodeFilterImpl.FILTER_SKIP = 3; + NodeFilterImpl.SHOW_ALL = 0xffffffff; + NodeFilterImpl.SHOW_ELEMENT = 0x1; + NodeFilterImpl.SHOW_ATTRIBUTE = 0x2; + NodeFilterImpl.SHOW_TEXT = 0x4; + NodeFilterImpl.SHOW_CDATA_SECTION = 0x8; + NodeFilterImpl.SHOW_ENTITY_REFERENCE = 0x10; + NodeFilterImpl.SHOW_ENTITY = 0x20; + NodeFilterImpl.SHOW_PROCESSING_INSTRUCTION = 0x40; + NodeFilterImpl.SHOW_COMMENT = 0x80; + NodeFilterImpl.SHOW_DOCUMENT = 0x100; + NodeFilterImpl.SHOW_DOCUMENT_TYPE = 0x200; + NodeFilterImpl.SHOW_DOCUMENT_FRAGMENT = 0x400; + NodeFilterImpl.SHOW_NOTATION = 0x800; + return NodeFilterImpl; +}()); exports.NodeFilterImpl = NodeFilterImpl; -NodeFilterImpl.FILTER_ACCEPT = 1; -NodeFilterImpl.FILTER_REJECT = 2; -NodeFilterImpl.FILTER_SKIP = 3; -NodeFilterImpl.SHOW_ALL = 0xffffffff; -NodeFilterImpl.SHOW_ELEMENT = 0x1; -NodeFilterImpl.SHOW_ATTRIBUTE = 0x2; -NodeFilterImpl.SHOW_TEXT = 0x4; -NodeFilterImpl.SHOW_CDATA_SECTION = 0x8; -NodeFilterImpl.SHOW_ENTITY_REFERENCE = 0x10; -NodeFilterImpl.SHOW_ENTITY = 0x20; -NodeFilterImpl.SHOW_PROCESSING_INSTRUCTION = 0x40; -NodeFilterImpl.SHOW_COMMENT = 0x80; -NodeFilterImpl.SHOW_DOCUMENT = 0x100; -NodeFilterImpl.SHOW_DOCUMENT_TYPE = 0x200; -NodeFilterImpl.SHOW_DOCUMENT_FRAGMENT = 0x400; -NodeFilterImpl.SHOW_NOTATION = 0x800; /** * Define constants on prototype. */ @@ -28068,177 +34848,109 @@ WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_NOTATION", 0x8 //# sourceMappingURL=NodeFilterImpl.js.map /***/ }), - -/***/ 780: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * A surrogate is a code point that is in the range U+D800 to U+DFFF, inclusive. - */ -exports.Surrogate = /[\uD800-\uDFFF]/; -/** - * A scalar value is a code point that is not a surrogate. - */ -exports.ScalarValue = /[\uD800-\uDFFF]/; -/** - * A noncharacter is a code point that is in the range U+FDD0 to U+FDEF, - * inclusive, or U+FFFE, U+FFFF, U+1FFFE, U+1FFFF, U+2FFFE, U+2FFFF, U+3FFFE, - * U+3FFFF, U+4FFFE, U+4FFFF, U+5FFFE, U+5FFFF, U+6FFFE, U+6FFFF, U+7FFFE, - * U+7FFFF, U+8FFFE, U+8FFFF, U+9FFFE, U+9FFFF, U+AFFFE, U+AFFFF, U+BFFFE, - * U+BFFFF, U+CFFFE, U+CFFFF, U+DFFFE, U+DFFFF, U+EFFFE, U+EFFFF, U+FFFFE, - * U+FFFFF, U+10FFFE, or U+10FFFF. - */ -exports.NonCharacter = /[\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]/; -/** - * An ASCII code point is a code point in the range U+0000 NULL to U+007F - * DELETE, inclusive. - */ -exports.ASCIICodePoint = /[\u0000-\u007F]/; -/** - * An ASCII tab or newline is U+0009 TAB, U+000A LF, or U+000D CR. - */ -exports.ASCIITabOrNewLine = /[\t\n\r]/; -/** - * ASCII whitespace is U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, or - * U+0020 SPACE. - */ -exports.ASCIIWhiteSpace = /[\t\n\f\r ]/; -/** - * A C0 control is a code point in the range U+0000 NULL to U+001F - * INFORMATION SEPARATOR ONE, inclusive. - */ -exports.C0Control = /[\u0000-\u001F]/; -/** - * A C0 control or space is a C0 control or U+0020 SPACE. - */ -exports.C0ControlOrSpace = /[\u0000-\u001F ]/; -/** - * A control is a C0 control or a code point in the range U+007F DELETE to - * U+009F APPLICATION PROGRAM COMMAND, inclusive. - */ -exports.Control = /[\u0000-\u001F\u007F-\u009F]/; -/** - * An ASCII digit is a code point in the range U+0030 (0) to U+0039 (9), - * inclusive. - */ -exports.ASCIIDigit = /[0-9]/; -/** - * An ASCII upper hex digit is an ASCII digit or a code point in the range - * U+0041 (A) to U+0046 (F), inclusive. - */ -exports.ASCIIUpperHexDigit = /[0-9A-F]/; -/** - * An ASCII lower hex digit is an ASCII digit or a code point in the range - * U+0061 (a) to U+0066 (f), inclusive. - */ -exports.ASCIILowerHexDigit = /[0-9a-f]/; -/** - * An ASCII hex digit is an ASCII upper hex digit or ASCII lower hex digit. - */ -exports.ASCIIHexDigit = /[0-9A-Fa-f]/; -/** - * An ASCII upper alpha is a code point in the range U+0041 (A) to U+005A (Z), - * inclusive. - */ -exports.ASCIIUpperAlpha = /[A-Z]/; -/** - * An ASCII lower alpha is a code point in the range U+0061 (a) to U+007A (z), - * inclusive. - */ -exports.ASCIILowerAlpha = /[a-z]/; -/** - * An ASCII alpha is an ASCII upper alpha or ASCII lower alpha. - */ -exports.ASCIIAlpha = /[A-Za-z]/; -/** - * An ASCII alphanumeric is an ASCII digit or ASCII alpha. - */ -exports.ASCIIAlphanumeric = /[0-9A-Za-z]/; -//# sourceMappingURL=CodePoints.js.map - -/***/ }), - -/***/ 781: +/* 775 */, +/* 776 */, +/* 777 */, +/* 778 */, +/* 779 */, +/* 780 */, +/* 781 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const BaseCBWriter_1 = __webpack_require__(512); +var BaseCBWriter_1 = __webpack_require__(512); /** * Serializes XML nodes. */ -class JSONCBWriter extends BaseCBWriter_1.BaseCBWriter { +var JSONCBWriter = /** @class */ (function (_super) { + __extends(JSONCBWriter, _super); /** - * Initializes a new instance of `BaseCBWriter`. + * Initializes a new instance of `JSONCBWriter`. * * @param builderOptions - XML builder options */ - constructor(builderOptions) { - super(builderOptions); - this._hasChildren = []; - this._additionalLevel = 0; + function JSONCBWriter(builderOptions) { + var _this = _super.call(this, builderOptions) || this; + _this._hasChildren = []; + _this._additionalLevel = 0; + return _this; } /** @inheritdoc */ - declaration(version, encoding, standalone) { + JSONCBWriter.prototype.frontMatter = function () { return ""; - } + }; /** @inheritdoc */ - docType(name, publicId, systemId) { + JSONCBWriter.prototype.declaration = function (version, encoding, standalone) { return ""; - } + }; /** @inheritdoc */ - comment(data) { + JSONCBWriter.prototype.docType = function (name, publicId, systemId) { + return ""; + }; + /** @inheritdoc */ + JSONCBWriter.prototype.comment = function (data) { // { "!": "hello" } return this._comma() + this._beginLine() + "{" + this._sep() + this._key(this._builderOptions.convert.comment) + this._sep() + this._val(data) + this._sep() + "}"; - } + }; /** @inheritdoc */ - text(data) { + JSONCBWriter.prototype.text = function (data) { // { "#": "hello" } return this._comma() + this._beginLine() + "{" + this._sep() + this._key(this._builderOptions.convert.text) + this._sep() + this._val(data) + this._sep() + "}"; - } + }; /** @inheritdoc */ - instruction(target, data) { + JSONCBWriter.prototype.instruction = function (target, data) { // { "?": "target hello" } return this._comma() + this._beginLine() + "{" + this._sep() + this._key(this._builderOptions.convert.ins) + this._sep() + this._val(data ? target + " " + data : target) + this._sep() + "}"; - } + }; /** @inheritdoc */ - cdata(data) { + JSONCBWriter.prototype.cdata = function (data) { // { "$": "hello" } return this._comma() + this._beginLine() + "{" + this._sep() + this._key(this._builderOptions.convert.cdata) + this._sep() + this._val(data) + this._sep() + "}"; - } + }; /** @inheritdoc */ - attribute(name, value) { + JSONCBWriter.prototype.attribute = function (name, value) { // { "@name": "val" } return this._comma() + this._beginLine(1) + "{" + this._sep() + this._key(this._builderOptions.convert.att + name) + this._sep() + this._val(value) + this._sep() + "}"; - } + }; /** @inheritdoc */ - openTagBegin(name) { + JSONCBWriter.prototype.openTagBegin = function (name) { // { "node": { "#": [ - let str = this._comma() + this._beginLine() + "{" + this._sep() + this._key(name) + this._sep() + "{"; + var str = this._comma() + this._beginLine() + "{" + this._sep() + this._key(name) + this._sep() + "{"; this._additionalLevel++; this.hasData = true; str += this._beginLine() + this._key(this._builderOptions.convert.text) + this._sep() + "["; this._hasChildren.push(false); return str; - } + }; /** @inheritdoc */ - openTagEnd(name, selfClosing, voidElement) { + JSONCBWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) { if (selfClosing) { - let str = this._sep() + "]"; + var str = this._sep() + "]"; this._additionalLevel--; str += this._beginLine() + "}" + this._sep() + "}"; return str; @@ -28246,24 +34958,25 @@ class JSONCBWriter extends BaseCBWriter_1.BaseCBWriter { else { return ""; } - } + }; /** @inheritdoc */ - closeTag(name) { + JSONCBWriter.prototype.closeTag = function (name) { // ] } } - let str = this._beginLine() + "]"; + var str = this._beginLine() + "]"; this._additionalLevel--; str += this._beginLine() + "}" + this._sep() + "}"; return str; - } + }; /** @inheritdoc */ - beginElement(name) { } + JSONCBWriter.prototype.beginElement = function (name) { }; /** @inheritdoc */ - endElement(name) { this._hasChildren.pop(); } + JSONCBWriter.prototype.endElement = function (name) { this._hasChildren.pop(); }; /** * Produces characters to be prepended to a line of string in pretty-print * mode. */ - _beginLine(additionalOffset = 0) { + JSONCBWriter.prototype._beginLine = function (additionalOffset) { + if (additionalOffset === void 0) { additionalOffset = 0; } if (this._writerOptions.prettyPrint) { return (this.hasData ? this._writerOptions.newline : "") + this._indent(this._writerOptions.offset + this.level + additionalOffset); @@ -28271,55 +34984,55 @@ class JSONCBWriter extends BaseCBWriter_1.BaseCBWriter { else { return ""; } - } + }; /** * Produces an indentation string. * * @param level - depth of the tree */ - _indent(level) { + JSONCBWriter.prototype._indent = function (level) { if (level + this._additionalLevel <= 0) { return ""; } else { return this._writerOptions.indent.repeat(level + this._additionalLevel); } - } + }; /** * Produces a comma before a child node if it has previous siblings. */ - _comma() { - const str = (this._hasChildren[this._hasChildren.length - 1] ? "," : ""); + JSONCBWriter.prototype._comma = function () { + var str = (this._hasChildren[this._hasChildren.length - 1] ? "," : ""); if (this._hasChildren.length > 0) { this._hasChildren[this._hasChildren.length - 1] = true; } return str; - } + }; /** * Produces a separator string. */ - _sep() { + JSONCBWriter.prototype._sep = function () { return (this._writerOptions.prettyPrint ? " " : ""); - } + }; /** * Produces a JSON key string delimited with double quotes. */ - _key(key) { + JSONCBWriter.prototype._key = function (key) { return "\"" + key + "\":"; - } + }; /** * Produces a JSON value string delimited with double quotes. */ - _val(val) { - return "\"" + val + "\""; - } -} + JSONCBWriter.prototype._val = function (val) { + return JSON.stringify(val); + }; + return JSONCBWriter; +}(BaseCBWriter_1.BaseCBWriter)); exports.JSONCBWriter = JSONCBWriter; //# sourceMappingURL=JSONCBWriter.js.map /***/ }), - -/***/ 782: +/* 782 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -28340,144 +35053,145 @@ exports.isASCIIByte = isASCIIByte; //# sourceMappingURL=Byte.js.map /***/ }), - -/***/ 783: +/* 783 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); +var interfaces_1 = __webpack_require__(970); /** * Contains user-defined type guards for DOM objects. */ -class Guard { +var Guard = /** @class */ (function () { + function Guard() { + } /** * Determines if the given object is a `Node`. * * @param a - the object to check */ - static isNode(a) { + Guard.isNode = function (a) { return (!!a && a._nodeType !== undefined); - } + }; /** * Determines if the given object is a `Document`. * * @param a - the object to check */ - static isDocumentNode(a) { + Guard.isDocumentNode = function (a) { return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Document); - } + }; /** * Determines if the given object is a `DocumentType`. * * @param a - the object to check */ - static isDocumentTypeNode(a) { + Guard.isDocumentTypeNode = function (a) { return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.DocumentType); - } + }; /** * Determines if the given object is a `DocumentFragment`. * * @param a - the object to check */ - static isDocumentFragmentNode(a) { + Guard.isDocumentFragmentNode = function (a) { return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.DocumentFragment); - } + }; /** * Determines if the given object is a `Attr`. * * @param a - the object to check */ - static isAttrNode(a) { + Guard.isAttrNode = function (a) { return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Attribute); - } + }; /** * Determines if the given node is a `CharacterData` node. * * @param a - the object to check */ - static isCharacterDataNode(a) { + Guard.isCharacterDataNode = function (a) { if (!Guard.isNode(a)) return false; - const type = a._nodeType; + var type = a._nodeType; return (type === interfaces_1.NodeType.Text || type === interfaces_1.NodeType.ProcessingInstruction || type === interfaces_1.NodeType.Comment || type === interfaces_1.NodeType.CData); - } + }; /** * Determines if the given object is a `Text` or a `CDATASection`. * * @param a - the object to check */ - static isTextNode(a) { + Guard.isTextNode = function (a) { return (Guard.isNode(a) && (a._nodeType === interfaces_1.NodeType.Text || a._nodeType === interfaces_1.NodeType.CData)); - } + }; /** * Determines if the given object is a `Text`. * * @param a - the object to check */ - static isExclusiveTextNode(a) { + Guard.isExclusiveTextNode = function (a) { return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Text); - } + }; /** * Determines if the given object is a `CDATASection`. * * @param a - the object to check */ - static isCDATASectionNode(a) { + Guard.isCDATASectionNode = function (a) { return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.CData); - } + }; /** * Determines if the given object is a `Comment`. * * @param a - the object to check */ - static isCommentNode(a) { + Guard.isCommentNode = function (a) { return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Comment); - } + }; /** * Determines if the given object is a `ProcessingInstruction`. * * @param a - the object to check */ - static isProcessingInstructionNode(a) { + Guard.isProcessingInstructionNode = function (a) { return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.ProcessingInstruction); - } + }; /** * Determines if the given object is an `Element`. * * @param a - the object to check */ - static isElementNode(a) { + Guard.isElementNode = function (a) { return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Element); - } + }; /** * Determines if the given object is a custom `Element`. * * @param a - the object to check */ - static isCustomElementNode(a) { + Guard.isCustomElementNode = function (a) { return (Guard.isElementNode(a) && a._customElementState === "custom"); - } + }; /** * Determines if the given object is a `ShadowRoot`. * * @param a - the object to check */ - static isShadowRoot(a) { + Guard.isShadowRoot = function (a) { return (!!a && a.host !== undefined); - } + }; /** * Determines if the given object is a `MouseEvent`. * * @param a - the object to check */ - static isMouseEvent(a) { + Guard.isMouseEvent = function (a) { return (!!a && a.screenX !== undefined && a.screenY != undefined); - } + }; /** * Determines if the given object is a slotable. * @@ -28486,154 +35200,239 @@ class Guard { * * @param a - the object to check */ - static isSlotable(a) { + Guard.isSlotable = function (a) { return (!!a && a._name !== undefined && a._assignedSlot !== undefined && (Guard.isTextNode(a) || Guard.isElementNode(a))); - } + }; /** * Determines if the given object is a slot. * * @param a - the object to check */ - static isSlot(a) { + Guard.isSlot = function (a) { return (!!a && a._name !== undefined && a._assignedNodes !== undefined && Guard.isElementNode(a)); - } + }; /** * Determines if the given object is a `Window`. * * @param a - the object to check */ - static isWindow(a) { + Guard.isWindow = function (a) { return (!!a && a.navigator !== undefined); - } + }; /** * Determines if the given object is an `EventListener`. * * @param a - the object to check */ - static isEventListener(a) { + Guard.isEventListener = function (a) { return (!!a && a.handleEvent !== undefined); - } + }; /** * Determines if the given object is a `RegisteredObserver`. * * @param a - the object to check */ - static isRegisteredObserver(a) { + Guard.isRegisteredObserver = function (a) { return (!!a && a.observer !== undefined && a.options !== undefined); - } + }; /** * Determines if the given object is a `TransientRegisteredObserver`. * * @param a - the object to check */ - static isTransientRegisteredObserver(a) { + Guard.isTransientRegisteredObserver = function (a) { return (!!a && a.source !== undefined && Guard.isRegisteredObserver(a)); - } -} + }; + return Guard; +}()); exports.Guard = Guard; //# sourceMappingURL=Guard.js.map /***/ }), - -/***/ 784: +/* 784 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const EventTargetImpl_1 = __webpack_require__(597); -const algorithm_1 = __webpack_require__(163); +var EventTargetImpl_1 = __webpack_require__(597); +var algorithm_1 = __webpack_require__(163); /** * Represents a signal object that communicates with a DOM request and abort * it through an AbortController. */ -class AbortSignalImpl extends EventTargetImpl_1.EventTargetImpl { +var AbortSignalImpl = /** @class */ (function (_super) { + __extends(AbortSignalImpl, _super); /** * Initializes a new instance of `AbortSignal`. */ - constructor() { - super(); - this._abortedFlag = false; - this._abortAlgorithms = new Set(); - } - /** @inheritdoc */ - get aborted() { return this._abortedFlag; } - /** @inheritdoc */ - get onabort() { - return algorithm_1.event_getterEventHandlerIDLAttribute(this, "onabort"); - } - set onabort(val) { - algorithm_1.event_setterEventHandlerIDLAttribute(this, "onabort", val); + function AbortSignalImpl() { + var _this = _super.call(this) || this; + _this._abortedFlag = false; + _this._abortAlgorithms = new Set(); + return _this; } + Object.defineProperty(AbortSignalImpl.prototype, "aborted", { + /** @inheritdoc */ + get: function () { return this._abortedFlag; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AbortSignalImpl.prototype, "onabort", { + /** @inheritdoc */ + get: function () { + return algorithm_1.event_getterEventHandlerIDLAttribute(this, "onabort"); + }, + set: function (val) { + algorithm_1.event_setterEventHandlerIDLAttribute(this, "onabort", val); + }, + enumerable: true, + configurable: true + }); /** * Creates a new `AbortSignal`. */ - static _create() { + AbortSignalImpl._create = function () { return new AbortSignalImpl(); - } -} + }; + return AbortSignalImpl; +}(EventTargetImpl_1.EventTargetImpl)); exports.AbortSignalImpl = AbortSignalImpl; //# sourceMappingURL=AbortSignalImpl.js.map /***/ }), +/* 785 */, +/* 786 */, +/* 787 */, +/* 788 */, +/* 789 */, +/* 790 */, +/* 791 */, +/* 792 */, +/* 793 */, +/* 794 */ +/***/ (function(module) { -/***/ 796: +module.exports = require("stream"); + +/***/ }), +/* 795 */, +/* 796 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const NodeImpl_1 = __webpack_require__(935); -const WebIDLAlgorithm_1 = __webpack_require__(495); +var interfaces_1 = __webpack_require__(970); +var NodeImpl_1 = __webpack_require__(935); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** * Represents a document fragment in the XML tree. */ -class DocumentFragmentImpl extends NodeImpl_1.NodeImpl { +var DocumentFragmentImpl = /** @class */ (function (_super) { + __extends(DocumentFragmentImpl, _super); /** * Initializes a new instance of `DocumentFragment`. * * @param host - shadow root's host element */ - constructor(host = null) { - super(); - this._children = new Set(); - this._host = host; + function DocumentFragmentImpl(host) { + if (host === void 0) { host = null; } + var _this = _super.call(this) || this; + _this._children = new Set(); + _this._host = host; + return _this; } // MIXIN: NonElementParentNode /* istanbul ignore next */ - getElementById(elementId) { throw new Error("Mixin: NonElementParentNode not implemented."); } - // MIXIN: ParentNode + DocumentFragmentImpl.prototype.getElementById = function (elementId) { throw new Error("Mixin: NonElementParentNode not implemented."); }; + Object.defineProperty(DocumentFragmentImpl.prototype, "children", { + // MIXIN: ParentNode + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentFragmentImpl.prototype, "firstElementChild", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentFragmentImpl.prototype, "lastElementChild", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DocumentFragmentImpl.prototype, "childElementCount", { + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: ParentNode not implemented."); }, + enumerable: true, + configurable: true + }); /* istanbul ignore next */ - get children() { throw new Error("Mixin: ParentNode not implemented."); } + DocumentFragmentImpl.prototype.prepend = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ParentNode not implemented."); + }; /* istanbul ignore next */ - get firstElementChild() { throw new Error("Mixin: ParentNode not implemented."); } + DocumentFragmentImpl.prototype.append = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + throw new Error("Mixin: ParentNode not implemented."); + }; /* istanbul ignore next */ - get lastElementChild() { throw new Error("Mixin: ParentNode not implemented."); } + DocumentFragmentImpl.prototype.querySelector = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); }; /* istanbul ignore next */ - get childElementCount() { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - prepend(...nodes) { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - append(...nodes) { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - querySelector(selectors) { throw new Error("Mixin: ParentNode not implemented."); } - /* istanbul ignore next */ - querySelectorAll(selectors) { throw new Error("Mixin: ParentNode not implemented."); } + DocumentFragmentImpl.prototype.querySelectorAll = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); }; /** * Creates a new `DocumentFragment`. * * @param document - owner document * @param host - shadow root's host element */ - static _create(document, host = null) { - const node = new DocumentFragmentImpl(host); + DocumentFragmentImpl._create = function (document, host) { + if (host === void 0) { host = null; } + var node = new DocumentFragmentImpl(host); node._nodeDocument = document; return node; - } -} + }; + return DocumentFragmentImpl; +}(NodeImpl_1.NodeImpl)); exports.DocumentFragmentImpl = DocumentFragmentImpl; /** * Initialize prototype properties @@ -28642,95 +35441,84 @@ WebIDLAlgorithm_1.idl_defineConst(DocumentFragmentImpl.prototype, "_nodeType", i //# sourceMappingURL=DocumentFragmentImpl.js.map /***/ }), - -/***/ 798: -/***/ (function(__unusedmodule, exports) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents an object with lazy initialization. - */ -class Lazy { - /** - * Initializes a new instance of `Lazy`. - * - * @param initFunc - initializer function - */ - constructor(initFunc) { - this._initialized = false; - this._value = undefined; - this._initFunc = initFunc; - } - /** - * Gets the value of the object. - */ - get value() { - if (!this._initialized) { - this._value = this._initFunc(); - this._initialized = true; - } - return this._value; - } -} -exports.Lazy = Lazy; -//# sourceMappingURL=Lazy.js.map - -/***/ }), - -/***/ 800: +/* 797 */, +/* 798 */, +/* 799 */, +/* 800 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const TraverserImpl_1 = __webpack_require__(487); -const algorithm_1 = __webpack_require__(163); +var TraverserImpl_1 = __webpack_require__(487); +var algorithm_1 = __webpack_require__(163); /** * Represents an object which can be used to iterate through the nodes * of a subtree. */ -class NodeIteratorImpl extends TraverserImpl_1.TraverserImpl { +var NodeIteratorImpl = /** @class */ (function (_super) { + __extends(NodeIteratorImpl, _super); /** * Initializes a new instance of `NodeIterator`. */ - constructor(root, reference, pointerBeforeReference) { - super(root); - this._iteratorCollection = undefined; - this._reference = reference; - this._pointerBeforeReference = pointerBeforeReference; - algorithm_1.nodeIterator_iteratorList().add(this); + function NodeIteratorImpl(root, reference, pointerBeforeReference) { + var _this = _super.call(this, root) || this; + _this._iteratorCollection = undefined; + _this._reference = reference; + _this._pointerBeforeReference = pointerBeforeReference; + algorithm_1.nodeIterator_iteratorList().add(_this); + return _this; } + Object.defineProperty(NodeIteratorImpl.prototype, "referenceNode", { + /** @inheritdoc */ + get: function () { return this._reference; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeIteratorImpl.prototype, "pointerBeforeReferenceNode", { + /** @inheritdoc */ + get: function () { return this._pointerBeforeReference; }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get referenceNode() { return this._reference; } - /** @inheritdoc */ - get pointerBeforeReferenceNode() { return this._pointerBeforeReference; } - /** @inheritdoc */ - nextNode() { + NodeIteratorImpl.prototype.nextNode = function () { /** * The nextNode() method, when invoked, must return the result of * traversing with the context object and next. */ return algorithm_1.nodeIterator_traverse(this, true); - } + }; /** @inheritdoc */ - previousNode() { + NodeIteratorImpl.prototype.previousNode = function () { /** * The previousNode() method, when invoked, must return the result of * traversing with the context object and previous. */ return algorithm_1.nodeIterator_traverse(this, false); - } + }; /** @inheritdoc */ - detach() { + NodeIteratorImpl.prototype.detach = function () { /** * The detach() method, when invoked, must do nothing. * * since JS lacks weak references, we still use detach */ algorithm_1.nodeIterator_iteratorList().delete(this); - } + }; /** * Creates a new `NodeIterator`. * @@ -28739,20 +35527,97 @@ class NodeIteratorImpl extends TraverserImpl_1.TraverserImpl { * @param pointerBeforeReference - whether the iterator is before or after the * reference node */ - static _create(root, reference, pointerBeforeReference) { + NodeIteratorImpl._create = function (root, reference, pointerBeforeReference) { return new NodeIteratorImpl(root, reference, pointerBeforeReference); - } -} + }; + return NodeIteratorImpl; +}(TraverserImpl_1.TraverserImpl)); exports.NodeIteratorImpl = NodeIteratorImpl; //# sourceMappingURL=NodeIteratorImpl.js.map /***/ }), +/* 801 */, +/* 802 */, +/* 803 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 811: +const SemVer = __webpack_require__(65) +const minor = (a, loose) => new SemVer(a, loose).minor +module.exports = minor + + +/***/ }), +/* 804 */, +/* 805 */, +/* 806 */, +/* 807 */, +/* 808 */, +/* 809 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +function resolveYamlNull(data) { + if (data === null) return true; + + var max = data.length; + + return (max === 1 && data === '~') || + (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL')); +} + +function constructYamlNull() { + return null; +} + +function isNull(object) { + return object === null; +} + +module.exports = new Type('tag:yaml.org,2002:null', { + kind: 'scalar', + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: function () { return '~'; }, + lowercase: function () { return 'null'; }, + uppercase: function () { return 'NULL'; }, + camelcase: function () { return 'Null'; } + }, + defaultStyle: 'lowercase' +}); + + +/***/ }), +/* 810 */, +/* 811 */ /***/ (function(__unusedmodule, exports, __webpack_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.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) { @@ -28762,58 +35627,39 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge step((generator = generator.apply(thisArg, _arguments || [])).next()); }); }; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; Object.defineProperty(exports, "__esModule", { value: true }); const core = __importStar(__webpack_require__(470)); -const installer = __importStar(__webpack_require__(923)); const auth = __importStar(__webpack_require__(331)); -const gpg = __importStar(__webpack_require__(884)); -const constants = __importStar(__webpack_require__(694)); +const constants = __importStar(__webpack_require__(211)); const path = __importStar(__webpack_require__(622)); +const distribution_factory_1 = __webpack_require__(24); function run() { return __awaiter(this, void 0, void 0, function* () { try { - let version = core.getInput(constants.INPUT_VERSION); - if (!version) { - version = core.getInput(constants.INPUT_JAVA_VERSION, { required: true }); + const version = core.getInput(constants.INPUT_JAVA_VERSION, { required: true }); + const distributionName = core.getInput(constants.INPUT_DISTRIBUTION, { required: true }); + const architecture = core.getInput(constants.INPUT_ARCHITECTURE); + const packageType = core.getInput(constants.INPUT_JAVA_PACKAGE); + const jdkFile = core.getInput(constants.INPUT_JDK_FILE); + const installerOptions = { + architecture, + packageType, + version + }; + const distribution = distribution_factory_1.getJavaDistribution(distributionName, installerOptions, jdkFile); + if (!distribution) { + throw new Error(`No supported distribution was found for input ${distributionName}`); } - const arch = core.getInput(constants.INPUT_ARCHITECTURE, { required: true }); - if (!['x86', 'x64'].includes(arch)) { - throw new Error(`architecture "${arch}" is not in [x86 | x64]`); - } - const javaPackage = core.getInput(constants.INPUT_JAVA_PACKAGE, { - required: true - }); - const jdkFile = core.getInput(constants.INPUT_JDK_FILE, { required: false }); - yield installer.getJava(version, arch, jdkFile, javaPackage); + const result = yield distribution.setupJava(); + core.info(''); + core.info('Java configuration:'); + core.info(` Distribution: ${distributionName}`); + core.info(` Version: ${result.version}`); + core.info(` Path: ${result.path}`); + core.info(''); const matchersPath = path.join(__dirname, '..', '..', '.github'); core.info(`##[add-matcher]${path.join(matchersPath, 'java.json')}`); - const id = core.getInput(constants.INPUT_SERVER_ID, { required: false }); - const username = core.getInput(constants.INPUT_SERVER_USERNAME, { - required: false - }); - const password = core.getInput(constants.INPUT_SERVER_PASSWORD, { - required: false - }); - const gpgPrivateKey = core.getInput(constants.INPUT_GPG_PRIVATE_KEY, { required: false }) || - constants.INPUT_DEFAULT_GPG_PRIVATE_KEY; - const gpgPassphrase = core.getInput(constants.INPUT_GPG_PASSPHRASE, { required: false }) || - (gpgPrivateKey ? constants.INPUT_DEFAULT_GPG_PASSPHRASE : undefined); - if (gpgPrivateKey) { - core.setSecret(gpgPrivateKey); - } - yield auth.configAuthentication(id, username, password, gpgPassphrase); - if (gpgPrivateKey) { - core.info('importing private key'); - const keyFingerprint = (yield gpg.importKey(gpgPrivateKey)) || ''; - core.saveState(constants.STATE_GPG_PRIVATE_KEY_FINGERPRINT, keyFingerprint); - } + yield auth.configureAuthentication(); } catch (error) { core.setFailed(error.message); @@ -28824,22 +35670,49 @@ run(); /***/ }), - -/***/ 813: +/* 812 */, +/* 813 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(724); -const interfaces_1 = __webpack_require__(286); -const infra_1 = __webpack_require__(307); -const url_1 = __webpack_require__(835); -let _validationErrorCallback; +var util_1 = __webpack_require__(592); +var interfaces_1 = __webpack_require__(286); +var infra_1 = __webpack_require__(23); +var url_1 = __webpack_require__(835); +var _validationErrorCallback; /** * Default ports for a special URL scheme. */ -const _defaultPorts = { +var _defaultPorts = { "ftp": 21, "file": null, "http": 80, @@ -28851,23 +35724,23 @@ const _defaultPorts = { * The C0 control percent-encode set are the C0 controls and all code points * greater than U+007E (~). */ -const _c0ControlPercentEncodeSet = /[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var _c0ControlPercentEncodeSet = /[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; /** * The fragment percent-encode set is the C0 control percent-encode set and * U+0020 SPACE, U+0022 ("), U+003C (<), U+003E (>), and U+0060 (`). */ -const _fragmentPercentEncodeSet = /[ "<>`]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var _fragmentPercentEncodeSet = /[ "<>`]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; /** * The path percent-encode set is the fragment percent-encode set and * U+0023 (#), U+003F (?), U+007B ({), and U+007D (}). */ -const _pathPercentEncodeSet = /[ "<>`#?{}]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var _pathPercentEncodeSet = /[ "<>`#?{}]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; /** * The userinfo percent-encode set is the path percent-encode set and * U+002F (/), U+003A (:), U+003B (;), U+003D (=), U+0040 (@), U+005B ([), * U+005C (\), U+005D (]), U+005E (^), and U+007C (|). */ -const _userInfoPercentEncodeSet = /[ "<>`#?{}/:;=@\[\]\\\^\|]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var _userInfoPercentEncodeSet = /[ "<>`#?{}/:;=@\[\]\\\^\|]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; /** * The URL code points are ASCII alphanumeric, U+0021 (!), U+0024 ($), * U+0026 (&), U+0027 ('), U+0028 LEFT PARENTHESIS, U+0029 RIGHT PARENTHESIS, @@ -28876,13 +35749,13 @@ const _userInfoPercentEncodeSet = /[ "<>`#?{}/:;=@\[\]\\\^\|]|[\0-\x1F\x7F-\uD7F * U+007E (~), and code points in the range U+00A0 to U+10FFFD, inclusive, * excluding surrogates and noncharacters. */ -const _urlCodePoints = /[0-9A-Za-z!\$&-\/:;=\?@_~\xA0-\uD7FF\uE000-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uD83E\uD840-\uD87E\uD880-\uD8BE\uD8C0-\uD8FE\uD900-\uD93E\uD940-\uD97E\uD980-\uD9BE\uD9C0-\uD9FE\uDA00-\uDA3E\uDA40-\uDA7E\uDA80-\uDABE\uDAC0-\uDAFE\uDB00-\uDB3E\uDB40-\uDB7E\uDB80-\uDBBE\uDBC0-\uDBFE][\uDC00-\uDFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDC00-\uDFFD]/; +var _urlCodePoints = /[0-9A-Za-z!\$&-\/:;=\?@_~\xA0-\uD7FF\uE000-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uD83E\uD840-\uD87E\uD880-\uD8BE\uD8C0-\uD8FE\uD900-\uD93E\uD940-\uD97E\uD980-\uD9BE\uD9C0-\uD9FE\uDA00-\uDA3E\uDA40-\uDA7E\uDA80-\uDABE\uDAC0-\uDAFE\uDB00-\uDB3E\uDB40-\uDB7E\uDB80-\uDBBE\uDBC0-\uDBFE][\uDC00-\uDFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDC00-\uDFFD]/; /** * A forbidden host code point is U+0000 NULL, U+0009 TAB, U+000A LF, * U+000D CR, U+0020 SPACE, U+0023 (#), U+0025 (%), U+002F (/), U+003A (:), * U+003F (?), U+0040 (@), U+005B ([), U+005C (\), or U+005D (]). */ -const _forbiddenHostCodePoint = /[\0\t\f\r #%/:?@\[\\\]]/; +var _forbiddenHostCodePoint = /[\0\t\f\r #%/:?@\[\\\]]/; /** * Sets the callback function for validation errors. * @@ -28977,11 +35850,13 @@ exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort; * * @param url - an URL */ -function urlSerializer(url, excludeFragmentFlag = false) { +function urlSerializer(url, excludeFragmentFlag) { + var e_1, _a; + if (excludeFragmentFlag === void 0) { excludeFragmentFlag = false; } /** * 1. Let output be url’s scheme and U+003A (:) concatenated. */ - let output = url.scheme + ':'; + var output = url.scheme + ':'; /** * 2. If url’s host is non-null: */ @@ -29032,8 +35907,18 @@ function urlSerializer(url, excludeFragmentFlag = false) { output += url.path[0]; } else { - for (const str of url.path) { - output += '/' + str; + try { + for (var _b = __values(url.path), _c = _b.next(); !_c.done; _c = _b.next()) { + var str = _c.value; + output += '/' + str; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } } } /** @@ -29092,9 +35977,9 @@ function iPv4Serializer(address) { * 3.3. Set n to floor(n / 256). * 4. Return output. */ - let output = ""; - let n = address; - for (let i = 1; i <= 4; i++) { + var output = ""; + var n = address; + for (var i = 1; i <= 4; i++) { output = (n % 256).toString() + output; if (i !== 4) { output = '.' + output; @@ -29118,16 +36003,16 @@ function iPv6Serializer(address) { * 3. If there is no sequence of address’s IPv6 pieces that are 0 that is * longer than 1, then set compress to null. */ - let output = ""; - let compress = null; - let lastIndex = -1; - let count = 0; - let lastCount = 0; - for (let i = 0; i < 8; i++) { + var output = ""; + var compress = null; + var lastIndex = -1; + var count = 0; + var lastCount = 0; + for (var i = 0; i < 8; i++) { if (address[i] !== 0) continue; count = 1; - for (let j = i + 1; j < 8; j++) { + for (var j = i + 1; j < 8; j++) { if (address[j] !== 0) break; count++; @@ -29144,8 +36029,8 @@ function iPv6Serializer(address) { * 4. Let ignore0 be false. * 5. For each pieceIndex in the range 0 to 7, inclusive: */ - let ignore0 = false; - for (let pieceIndex = 0; pieceIndex < 8; pieceIndex++) { + var ignore0 = false; + for (var pieceIndex = 0; pieceIndex < 8; pieceIndex++) { /** * 5.1. If ignore0 is true and address[pieceIndex] is 0, then continue. * 5.2. Otherwise, if ignore0 is true, set ignore0 to false. @@ -29197,12 +36082,12 @@ function urlParser(input, baseURL, encodingOverride) { * if that did not return failure, and null otherwise. * 5. Return url. */ - const url = basicURLParser(input, baseURL, encodingOverride); + var url = basicURLParser(input, baseURL, encodingOverride); if (url === null) return null; if (url.scheme !== "blob") return url; - const entry = resolveABlobURL(url); + var entry = resolveABlobURL(url); if (entry !== null) { url._blobURLEntry = entry; } @@ -29220,6 +36105,7 @@ exports.urlParser = urlParser; * @param encodingOverride - encoding override */ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { + var e_2, _a, e_3, _b; /** * 1. If url is not given: * 1.1. Set url to a new URL. @@ -29230,8 +36116,8 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { if (url === undefined) { url = newURL(); // leading - const leadingControlOrSpace = /^[\u0000-\u001F\u0020]+/; - const trailingControlOrSpace = /[\u0000-\u001F\u0020]+$/; + var leadingControlOrSpace = /^[\u0000-\u001F\u0020]+/; + var trailingControlOrSpace = /[\u0000-\u001F\u0020]+$/; if (leadingControlOrSpace.test(input) || trailingControlOrSpace.test(input)) { validationError("Input string contains leading or trailing control characters or space."); } @@ -29242,7 +36128,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { * 2. If input contains any ASCII tab or newline, validation error. * 3. Remove all ASCII tab or newline from input. */ - const tabOrNewline = /[\u0009\u000A\u000D]/g; + var tabOrNewline = /[\u0009\u000A\u000D]/g; if (tabOrNewline.test(input)) { validationError("Input string contains tab or newline characters."); } @@ -29254,10 +36140,10 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { * 7. If encoding override is given, set encoding to the result of getting * an output encoding from encoding override. */ - let state = (stateOverride === undefined ? interfaces_1.ParserState.SchemeStart : stateOverride); + var state = (stateOverride === undefined ? interfaces_1.ParserState.SchemeStart : stateOverride); if (baseURL === undefined) baseURL = null; - let encoding = (encodingOverride === undefined || + var encoding = (encodingOverride === undefined || encodingOverride === "replacement" || encodingOverride === "UTF-16BE" || encodingOverride === "UTF-16LE" ? "UTF-8" : encodingOverride); /** @@ -29265,12 +36151,12 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { * 9. Let the @ flag, [] flag, and passwordTokenSeenFlag be unset. * 10. Let pointer be a pointer to first code point in input. */ - let buffer = ""; - let atFlag = false; - let arrayFlag = false; - let passwordTokenSeenFlag = false; - const EOF = ""; - const walker = new util_1.StringWalker(input); + var buffer = ""; + var atFlag = false; + var arrayFlag = false; + var passwordTokenSeenFlag = false; + var EOF = ""; + var walker = new util_1.StringWalker(input); /** * 11. Keep running the following state machine by switching on state. If * after a run pointer points to the EOF code point, go to the next step. @@ -29648,27 +36534,37 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { if (atFlag) buffer = '%40' + buffer; atFlag = true; - for (const codePoint of buffer) { - /** - * 1.4.1. If codePoint is U+003A (:) and passwordTokenSeenFlag is - * unset, then set passwordTokenSeenFlag and continue. - * 1.4.2. Let encodedCodePoints be the result of running UTF-8 - * percent encode codePoint using the userinfo percent-encode set. - * 1.4.3. If passwordTokenSeenFlag is set, then append - * encodedCodePoints to url’s password. - * 1.4.4. Otherwise, append encodedCodePoints to url’s username. - */ - if (codePoint === ':' && !passwordTokenSeenFlag) { - passwordTokenSeenFlag = true; - continue; + try { + for (var buffer_1 = (e_2 = void 0, __values(buffer)), buffer_1_1 = buffer_1.next(); !buffer_1_1.done; buffer_1_1 = buffer_1.next()) { + var codePoint = buffer_1_1.value; + /** + * 1.4.1. If codePoint is U+003A (:) and passwordTokenSeenFlag is + * unset, then set passwordTokenSeenFlag and continue. + * 1.4.2. Let encodedCodePoints be the result of running UTF-8 + * percent encode codePoint using the userinfo percent-encode set. + * 1.4.3. If passwordTokenSeenFlag is set, then append + * encodedCodePoints to url’s password. + * 1.4.4. Otherwise, append encodedCodePoints to url’s username. + */ + if (codePoint === ':' && !passwordTokenSeenFlag) { + passwordTokenSeenFlag = true; + continue; + } + var encodedCodePoints = utf8PercentEncode(codePoint, _userInfoPercentEncodeSet); + if (passwordTokenSeenFlag) { + url.password += encodedCodePoints; + } + else { + url.username += encodedCodePoints; + } } - const encodedCodePoints = utf8PercentEncode(codePoint, _userInfoPercentEncodeSet); - if (passwordTokenSeenFlag) { - url.password += encodedCodePoints; - } - else { - url.username += encodedCodePoints; + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (buffer_1_1 && !buffer_1_1.done && (_a = buffer_1.return)) _a.call(buffer_1); } + finally { if (e_2) throw e_2.error; } } /** * 1.5. Set buffer to the empty string. @@ -29729,7 +36625,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { validationError("Invalid input string."); return null; } - const host = hostParser(buffer, !isSpecial(url)); + var host = hostParser(buffer, !isSpecial(url)); if (host === null) return null; url.host = host; @@ -29767,7 +36663,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { validationError("Invalid input string."); return url; } - const host = hostParser(buffer, !isSpecial(url)); + var host = hostParser(buffer, !isSpecial(url)); if (host === null) return null; url.host = host; @@ -29819,7 +36715,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { * 2.1.4. Set buffer to the empty string. */ if (buffer !== "") { - const port = parseInt(buffer, 10); + var port = parseInt(buffer, 10); if (port > Math.pow(2, 16) - 1) { validationError("Invalid port number."); return null; @@ -30015,7 +36911,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { * 1.3.6. Set buffer to the empty string and state to path start * state. */ - let host = hostParser(buffer, !isSpecial(url)); + var host = hostParser(buffer, !isSpecial(url)); if (host === null) return null; if (host === "localhost") @@ -30133,7 +37029,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { validationError("Invalid input string."); url.host = ""; } - const bufferCodePoints = Array.from(buffer); + var bufferCodePoints = Array.from(buffer); buffer = bufferCodePoints.slice(0, 1) + ':' + bufferCodePoints.slice(2); } /** @@ -30267,7 +37163,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { if (encoding.toUpperCase() !== "UTF-8") { throw new Error("Only UTF-8 encoding is supported."); } - let bytes = util_1.utf8Encode(walker.c()); + var bytes = util_1.utf8Encode(walker.c()); /** * 3.4. If bytes starts with `&#` and ends with 0x3B (;), then: */ @@ -30284,26 +37180,36 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) { url.query += "%26%23" + infra_1.byteSequence.isomorphicDecode(bytes) + "%3B"; } else { - /** - * 3.5. Otherwise, for each byte in bytes: - * 3.5.1. If one of the following is true - * - byte is less than 0x21 (!) - * - byte is greater than 0x7E (~) - * - byte is 0x22 ("), 0x23 (#), 0x3C (<), or 0x3E (>) - * - byte is 0x27 (') and url is special - * then append byte, percent encoded, to url’s query. - * 3.5.2. Otherwise, append a code point whose value is byte to - * url’s query. - */ - for (const byte of bytes) { - if (byte < 0x21 || byte > 0x7E || byte === 0x22 || - byte === 0x23 || byte === 0x3C || byte === 0x3E || - (byte === 0x27 && isSpecial(url))) { - url.query += percentEncode(byte); + try { + /** + * 3.5. Otherwise, for each byte in bytes: + * 3.5.1. If one of the following is true + * - byte is less than 0x21 (!) + * - byte is greater than 0x7E (~) + * - byte is 0x22 ("), 0x23 (#), 0x3C (<), or 0x3E (>) + * - byte is 0x27 (') and url is special + * then append byte, percent encoded, to url’s query. + * 3.5.2. Otherwise, append a code point whose value is byte to + * url’s query. + */ + for (var bytes_1 = (e_3 = void 0, __values(bytes)), bytes_1_1 = bytes_1.next(); !bytes_1_1.done; bytes_1_1 = bytes_1.next()) { + var byte = bytes_1_1.value; + if (byte < 0x21 || byte > 0x7E || byte === 0x22 || + byte === 0x23 || byte === 0x3C || byte === 0x3E || + (byte === 0x27 && isSpecial(url))) { + url.query += percentEncode(byte); + } + else { + url.query += String.fromCharCode(byte); + } } - else { - url.query += String.fromCharCode(byte); + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (bytes_1_1 && !bytes_1_1.done && (_b = bytes_1.return)) _b.call(bytes_1); } + finally { if (e_3) throw e_3.error; } } } } @@ -30358,14 +37264,25 @@ exports.basicURLParser = basicURLParser; * @param username - username string */ function setTheUsername(url, username) { + var e_4, _a; /** * 1. Set url’s username to the empty string. * 2. For each code point in username, UTF-8 percent encode it using the * userinfo percent-encode set, and append the result to url’s username. */ - let result = ""; - for (const codePoint of username) { - result += utf8PercentEncode(codePoint, _userInfoPercentEncodeSet); + var result = ""; + try { + for (var username_1 = __values(username), username_1_1 = username_1.next(); !username_1_1.done; username_1_1 = username_1.next()) { + var codePoint = username_1_1.value; + result += utf8PercentEncode(codePoint, _userInfoPercentEncodeSet); + } + } + catch (e_4_1) { e_4 = { error: e_4_1 }; } + finally { + try { + if (username_1_1 && !username_1_1.done && (_a = username_1.return)) _a.call(username_1); + } + finally { if (e_4) throw e_4.error; } } url.username = result; } @@ -30377,14 +37294,25 @@ exports.setTheUsername = setTheUsername; * @param username - password string */ function setThePassword(url, password) { + var e_5, _a; /** * 1. Set url’s password to the empty string. * 2. For each code point in password, UTF-8 percent encode it using the * userinfo percent-encode set, and append the result to url’s password. */ - let result = ""; - for (const codePoint of password) { - result += utf8PercentEncode(codePoint, _userInfoPercentEncodeSet); + var result = ""; + try { + for (var password_1 = __values(password), password_1_1 = password_1.next(); !password_1_1.done; password_1_1 = password_1.next()) { + var codePoint = password_1_1.value; + result += utf8PercentEncode(codePoint, _userInfoPercentEncodeSet); + } + } + catch (e_5_1) { e_5 = { error: e_5_1 }; } + finally { + try { + if (password_1_1 && !password_1_1.done && (_a = password_1.return)) _a.call(password_1); + } + finally { if (e_5) throw e_5.error; } } url.password = result; } @@ -30404,7 +37332,7 @@ exports.isSingleDotPathSegment = isSingleDotPathSegment; * @param str - a string */ function isDoubleDotPathSegment(str) { - const lowerStr = str.toLowerCase(); + var lowerStr = str.toLowerCase(); return lowerStr === ".." || lowerStr === ".%2e" || lowerStr === "%2e." || lowerStr === "%2e%2e"; } @@ -30422,7 +37350,7 @@ function shorten(url) { * normalized Windows drive letter, then return. * 4. Remove path’s last item. */ - const path = url.path; + var path = url.path; if (path.length === 0) return; if (url.scheme === "file" && path.length === 1 && @@ -30485,7 +37413,8 @@ exports.startsWithAWindowsDriveLetter = startsWithAWindowsDriveLetter; * @param isNotSpecial - `true` if the source URL is not special; otherwise * `false`. */ -function hostParser(input, isNotSpecial = false) { +function hostParser(input, isNotSpecial) { + if (isNotSpecial === void 0) { isNotSpecial = false; } /** * 1. If isNotSpecial is not given, then set isNotSpecial to false. * 2. If input starts with U+005B ([), then: @@ -30515,14 +37444,14 @@ function hostParser(input, isNotSpecial = false) { * coupled with an early return for failure, as domain to ASCII fails * on U+FFFD REPLACEMENT CHARACTER. */ - const domain = util_1.utf8Decode(stringPercentDecode(input)); + var domain = util_1.utf8Decode(stringPercentDecode(input)); /** * 5. Let asciiDomain be the result of running domain to ASCII on domain. * 6. If asciiDomain is failure, validation error, return failure. * 7. If asciiDomain contains a forbidden host code point, validation error, * return failure. */ - const asciiDomain = domainToASCII(domain); + var asciiDomain = domainToASCII(domain); if (asciiDomain === null) { validationError("Invalid domain."); return null; @@ -30536,7 +37465,7 @@ function hostParser(input, isNotSpecial = false) { * 9. If ipv4Host is an IPv4 address or failure, return ipv4Host. * 10. Return asciiDomain. */ - const ipv4Host = iPv4Parser(asciiDomain); + var ipv4Host = iPv4Parser(asciiDomain); if (ipv4Host === null || util_1.isNumber(ipv4Host)) return ipv4Host; return asciiDomain; @@ -30549,11 +37478,12 @@ exports.hostParser = hostParser; * @param isNotSpecial - `true` if the source URL is not special; otherwise * `false`. */ -function iPv4NumberParser(input, validationErrorFlag = { value: false }) { +function iPv4NumberParser(input, validationErrorFlag) { + if (validationErrorFlag === void 0) { validationErrorFlag = { value: false }; } /** * 1. Let R be 10. */ - let R = 10; + var R = 10; if (input.startsWith("0x") || input.startsWith("0X")) { /** * 2. If input contains at least two code points and the first two code @@ -30585,7 +37515,7 @@ function iPv4NumberParser(input, validationErrorFlag = { value: false }) { */ if (input === "") return 0; - const radixRDigits = (R === 10 ? /^[0-9]+$/ : (R === 16 ? /^[0-9A-Fa-f]+$/ : /^[0-7]+$/)); + var radixRDigits = (R === 10 ? /^[0-9]+$/ : (R === 16 ? /^[0-9A-Fa-f]+$/ : /^[0-7]+$/)); if (!radixRDigits.test(input)) return null; /** @@ -30602,12 +37532,13 @@ exports.iPv4NumberParser = iPv4NumberParser; * @param input - input string */ function iPv4Parser(input) { + var e_6, _a, e_7, _b; /** * 1. Let validationErrorFlag be unset. * 2. Let parts be input split on U+002E (.). */ - const validationErrorFlag = { value: false }; - const parts = input.split('.'); + var validationErrorFlag = { value: false }; + var parts = input.split('.'); /** * 3. If the last item in parts is the empty string, then: * 3.1. Set validationErrorFlag. @@ -30632,14 +37563,24 @@ function iPv4Parser(input) { * 6.3. If n is failure, return input. * 6.4. Append n to numbers. */ - const numbers = []; - for (const part of parts) { - if (part === "") - return input; - const n = iPv4NumberParser(part, validationErrorFlag); - if (n === null) - return input; - numbers.push(n); + var numbers = []; + try { + for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) { + var part = parts_1_1.value; + if (part === "") + return input; + var n = iPv4NumberParser(part, validationErrorFlag); + if (n === null) + return input; + numbers.push(n); + } + } + catch (e_6_1) { e_6 = { error: e_6_1 }; } + finally { + try { + if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1); + } + finally { if (e_6) throw e_6.error; } } /** * 7. If validationErrorFlag is set, validation error. @@ -30651,8 +37592,8 @@ function iPv4Parser(input) { */ if (validationErrorFlag.value) validationError("Invalid IP v4 address."); - for (let i = 0; i < numbers.length; i++) { - const item = numbers[i]; + for (var i = 0; i < numbers.length; i++) { + var item = numbers[i]; if (item > 255) { validationError("Invalid IP v4 address."); if (i < numbers.length - 1) @@ -30667,7 +37608,7 @@ function iPv4Parser(input) { * 11. Let ipv4 be the last item in numbers. * 12. Remove the last item from numbers. */ - let ipv4 = numbers[numbers.length - 1]; + var ipv4 = numbers[numbers.length - 1]; numbers.pop(); /** * 13. Let counter be zero. @@ -30675,10 +37616,20 @@ function iPv4Parser(input) { * 14.2. Increment ipv4 by n × 256**(3 − counter). * 14.2. Increment counter by 1. */ - let counter = 0; - for (const n of numbers) { - ipv4 += n * Math.pow(256, 3 - counter); - counter++; + var counter = 0; + try { + for (var numbers_1 = __values(numbers), numbers_1_1 = numbers_1.next(); !numbers_1_1.done; numbers_1_1 = numbers_1.next()) { + var n = numbers_1_1.value; + ipv4 += n * Math.pow(256, 3 - counter); + counter++; + } + } + catch (e_7_1) { e_7 = { error: e_7_1 }; } + finally { + try { + if (numbers_1_1 && !numbers_1_1.done && (_b = numbers_1.return)) _b.call(numbers_1); + } + finally { if (e_7) throw e_7.error; } } /** * 15. Return ipv4. @@ -30692,6 +37643,7 @@ exports.iPv4Parser = iPv4Parser; * @param input - input string */ function iPv6Parser(input) { + var _a; /** * 1. Let address be a new IPv6 address whose IPv6 pieces are all 0. * 2. Let pieceIndex be 0. @@ -30699,11 +37651,11 @@ function iPv6Parser(input) { * 4. Let pointer be a pointer into input, initially 0 (pointing to the * first code point). */ - const EOF = ""; - const address = [0, 0, 0, 0, 0, 0, 0, 0]; - let pieceIndex = 0; - let compress = null; - const walker = new util_1.StringWalker(input); + var EOF = ""; + var address = [0, 0, 0, 0, 0, 0, 0, 0]; + var pieceIndex = 0; + var compress = null; + var walker = new util_1.StringWalker(input); /** * 5. If c is U+003A (:), then: * 5.1. If remaining does not start with U+003A (:), validation error, @@ -30753,8 +37705,8 @@ function iPv6Parser(input) { * to value × 0x10 + c interpreted as hexadecimal number, and increase * pointer and length by 1. */ - let value = 0; - let length = 0; + var value = 0; + var length = 0; while (length < 4 && infra_1.codePoint.ASCIIHexDigit.test(walker.c())) { value = value * 0x10 + parseInt(walker.c(), 16); walker.pointer++; @@ -30780,7 +37732,7 @@ function iPv6Parser(input) { validationError("Invalid IP v6 address."); return null; } - let numbersSeen = 0; + var numbersSeen = 0; /** * 6.5.5. While c is not the EOF code point: */ @@ -30788,7 +37740,7 @@ function iPv6Parser(input) { /** * 6.5.5.1. Let ipv4Piece be null. */ - let ipv4Piece = null; + var ipv4Piece = null; /** * 6.5.5.2. If numbersSeen is greater than 0, then: * 6.5.5.2.1. If c is a U+002E (.) and numbersSeen is less than 4, then @@ -30819,7 +37771,7 @@ function iPv6Parser(input) { /** * 6.5.5.4.1. Let number be c interpreted as decimal number. */ - const number = parseInt(walker.c(), 10); + var number = parseInt(walker.c(), 10); /** * 6.5.5.4.2. If ipv4Piece is null, then set ipv4Piece to number. * Otherwise, if ipv4Piece is 0, validation error, return failure. @@ -30907,11 +37859,10 @@ function iPv6Parser(input) { * both pieceIndex and swaps by 1. */ if (compress !== null) { - let swaps = pieceIndex - compress; + var swaps = pieceIndex - compress; pieceIndex = 7; while (pieceIndex !== 0 && swaps > 0) { - [address[pieceIndex], address[compress + swaps - 1]] = - [address[compress + swaps - 1], address[pieceIndex]]; + _a = __read([address[compress + swaps - 1], address[pieceIndex]], 2), address[pieceIndex] = _a[0], address[compress + swaps - 1] = _a[1]; pieceIndex--; swaps--; } @@ -30936,6 +37887,7 @@ exports.iPv6Parser = iPv6Parser; * @param input - a string */ function opaqueHostParser(input) { + var e_8, _a; /** * 1. If input contains a forbidden host code point excluding U+0025 (%), * validation error, return failure. @@ -30944,14 +37896,24 @@ function opaqueHostParser(input) { * control percent-encode set, and append the result to output. * 4. Return output. */ - const forbiddenChars = /[\x00\t\f\r #/:?@\[\\\]]/; + var forbiddenChars = /[\x00\t\f\r #/:?@\[\\\]]/; if (forbiddenChars.test(input)) { validationError("Invalid host string."); return null; } - let output = ""; - for (const codePoint of input) { - output += utf8PercentEncode(codePoint, _c0ControlPercentEncodeSet); + var output = ""; + try { + for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) { + var codePoint = input_1_1.value; + output += utf8PercentEncode(codePoint, _c0ControlPercentEncodeSet); + } + } + catch (e_8_1) { e_8 = { error: e_8_1 }; } + finally { + try { + if (input_1_1 && !input_1_1.done && (_a = input_1.return)) _a.call(input_1); + } + finally { if (e_8) throw e_8.error; } } return output; } @@ -30987,7 +37949,7 @@ exports.percentEncode = percentEncode; * @param input - a byte sequence */ function percentDecode(input) { - const isHexDigit = (byte) => { + var isHexDigit = function (byte) { return (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x46) || (byte >= 0x61 && byte <= 0x66); }; @@ -30995,10 +37957,10 @@ function percentDecode(input) { * 1. Let output be an empty byte sequence. * 2. For each byte byte in input: */ - const output = new Uint8Array(input.length); - let n = 0; - for (let i = 0; i < input.length; i++) { - const byte = input[i]; + var output = new Uint8Array(input.length); + var n = 0; + for (var i = 0; i < input.length; i++) { + var byte = input[i]; /** * 2.1. If byte is not 0x25 (%), then append byte to output. * 2.2. Otherwise, if byte is 0x25 (%) and the next two bytes after byte @@ -31024,7 +37986,7 @@ function percentDecode(input) { n++; } else { - const bytePoint = parseInt(util_1.utf8Decode(Uint8Array.of(input[i + 1], input[i + 2])), 16); + var bytePoint = parseInt(util_1.utf8Decode(Uint8Array.of(input[i + 1], input[i + 2])), 16); output[n] = bytePoint; n++; i += 2; @@ -31053,6 +38015,7 @@ exports.stringPercentDecode = stringPercentDecode; * @param percentEncodeSet - a percent encode set */ function utf8PercentEncode(codePoint, percentEncodeSet) { + var e_9, _a; /** * 1. If codePoint is not in percentEncodeSet, then return codePoint. * 2. Let bytes be the result of running UTF-8 encode on codePoint. @@ -31061,10 +38024,20 @@ function utf8PercentEncode(codePoint, percentEncodeSet) { */ if (!percentEncodeSet.test(codePoint)) return codePoint; - const bytes = util_1.utf8Encode(codePoint); - let result = ""; - for (const byte of bytes) { - result += percentEncode(byte); + var bytes = util_1.utf8Encode(codePoint); + var result = ""; + try { + for (var bytes_2 = __values(bytes), bytes_2_1 = bytes_2.next(); !bytes_2_1.done; bytes_2_1 = bytes_2.next()) { + var byte = bytes_2_1.value; + result += percentEncode(byte); + } + } + catch (e_9_1) { e_9 = { error: e_9_1 }; } + finally { + try { + if (bytes_2_1 && !bytes_2_1.done && (_a = bytes_2.return)) _a.call(bytes_2); + } + finally { if (e_9) throw e_9.error; } } return result; } @@ -31086,7 +38059,8 @@ exports.hostEquals = hostEquals; * @param urlB - a URL * @param excludeFragmentsFlag - whether to ignore fragments while comparing */ -function urlEquals(urlA, urlB, excludeFragmentsFlag = false) { +function urlEquals(urlA, urlB, excludeFragmentsFlag) { + if (excludeFragmentsFlag === void 0) { excludeFragmentsFlag = false; } /** * 1. Let serializedA be the result of serializing A, with the exclude * fragment flag set if the exclude fragments flag is set. @@ -31118,19 +38092,30 @@ exports.urlEncodedStringParser = urlEncodedStringParser; * @param input - a byte sequence */ function urlEncodedParser(input) { + var e_10, _a, e_11, _b; /** * 1. Let sequences be the result of splitting input on 0x26 (&). */ - const sequences = []; - let currentSequence = []; - for (const byte of input) { - if (byte === 0x26) { - sequences.push(Uint8Array.from(currentSequence)); - currentSequence = []; + var sequences = []; + var currentSequence = []; + try { + for (var input_2 = __values(input), input_2_1 = input_2.next(); !input_2_1.done; input_2_1 = input_2.next()) { + var byte = input_2_1.value; + if (byte === 0x26) { + sequences.push(Uint8Array.from(currentSequence)); + currentSequence = []; + } + else { + currentSequence.push(byte); + } } - else { - currentSequence.push(byte); + } + catch (e_10_1) { e_10 = { error: e_10_1 }; } + finally { + try { + if (input_2_1 && !input_2_1.done && (_a = input_2.return)) _a.call(input_2); } + finally { if (e_10) throw e_10.error; } } if (currentSequence.length !== 0) { sequences.push(Uint8Array.from(currentSequence)); @@ -31138,48 +38123,58 @@ function urlEncodedParser(input) { /** * 2. Let output be an initially empty list of name-value tuples where both name and value hold a string. */ - const output = []; - /** - * 3. For each byte sequence bytes in sequences: - */ - for (const bytes of sequences) { + var output = []; + try { /** - * 3.1. If bytes is the empty byte sequence, then continue. + * 3. For each byte sequence bytes in sequences: */ - if (bytes.length === 0) - continue; - /** - * 3.2. If bytes contains a 0x3D (=), then let name be the bytes from the - * start of bytes up to but excluding its first 0x3D (=), and let value be - * the bytes, if any, after the first 0x3D (=) up to the end of bytes. - * If 0x3D (=) is the first byte, then name will be the empty byte - * sequence. If it is the last, then value will be the empty byte sequence. - * 3.3. Otherwise, let name have the value of bytes and let value be the - * empty byte sequence. - */ - const index = bytes.indexOf(0x3D); - const name = (index !== -1 ? bytes.slice(0, index) : bytes); - const value = (index !== -1 ? bytes.slice(index + 1) : new Uint8Array()); - /** - * 3.4. Replace any 0x2B (+) in name and value with 0x20 (SP). - */ - for (let i = 0; i < name.length; i++) - if (name[i] === 0x2B) - name[i] = 0x20; - for (let i = 0; i < value.length; i++) - if (value[i] === 0x2B) - value[i] = 0x20; - /** - * 3.5. Let nameString and valueString be the result of running UTF-8 - * decode without BOM on the percent decoding of name and value, - * respectively. - */ - const nameString = util_1.utf8Decode(name); - const valueString = util_1.utf8Decode(value); - /** - * 3.6. Append (nameString, valueString) to output. - */ - output.push([nameString, valueString]); + for (var sequences_1 = __values(sequences), sequences_1_1 = sequences_1.next(); !sequences_1_1.done; sequences_1_1 = sequences_1.next()) { + var bytes = sequences_1_1.value; + /** + * 3.1. If bytes is the empty byte sequence, then continue. + */ + if (bytes.length === 0) + continue; + /** + * 3.2. If bytes contains a 0x3D (=), then let name be the bytes from the + * start of bytes up to but excluding its first 0x3D (=), and let value be + * the bytes, if any, after the first 0x3D (=) up to the end of bytes. + * If 0x3D (=) is the first byte, then name will be the empty byte + * sequence. If it is the last, then value will be the empty byte sequence. + * 3.3. Otherwise, let name have the value of bytes and let value be the + * empty byte sequence. + */ + var index = bytes.indexOf(0x3D); + var name = (index !== -1 ? bytes.slice(0, index) : bytes); + var value = (index !== -1 ? bytes.slice(index + 1) : new Uint8Array()); + /** + * 3.4. Replace any 0x2B (+) in name and value with 0x20 (SP). + */ + for (var i = 0; i < name.length; i++) + if (name[i] === 0x2B) + name[i] = 0x20; + for (var i = 0; i < value.length; i++) + if (value[i] === 0x2B) + value[i] = 0x20; + /** + * 3.5. Let nameString and valueString be the result of running UTF-8 + * decode without BOM on the percent decoding of name and value, + * respectively. + */ + var nameString = util_1.utf8Decode(name); + var valueString = util_1.utf8Decode(value); + /** + * 3.6. Append (nameString, valueString) to output. + */ + output.push([nameString, valueString]); + } + } + catch (e_11_1) { e_11 = { error: e_11_1 }; } + finally { + try { + if (sequences_1_1 && !sequences_1_1.done && (_b = sequences_1.return)) _b.call(sequences_1); + } + finally { if (e_11) throw e_11.error; } } /** * 4. Return output. @@ -31193,6 +38188,7 @@ exports.urlEncodedParser = urlEncodedParser; * @param input - a byte sequence */ function urlEncodedByteSerializer(input) { + var e_12, _a; /** * 1. Let output be the empty string. * 2. For each byte in input, depending on byte: @@ -31212,19 +38208,29 @@ function urlEncodedByteSerializer(input) { * Append byte, percent encoded, to output. * 3. Return output. */ - let output = ""; - for (const byte of input) { - if (byte === 0x20) { - output += '+'; + var output = ""; + try { + for (var input_3 = __values(input), input_3_1 = input_3.next(); !input_3_1.done; input_3_1 = input_3.next()) { + var byte = input_3_1.value; + if (byte === 0x20) { + output += '+'; + } + else if (byte === 0x2A || byte === 0x2D || byte === 0x2E || + (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x5A) || + byte === 0x5F || (byte >= 0x61 && byte <= 0x7A)) { + output += String.fromCodePoint(byte); + } + else { + output += percentEncode(byte); + } } - else if (byte === 0x2A || byte === 0x2D || byte === 0x2E || - (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x5A) || - byte === 0x5F || (byte >= 0x61 && byte <= 0x7A)) { - output += String.fromCodePoint(byte); - } - else { - output += percentEncode(byte); + } + catch (e_12_1) { e_12 = { error: e_12_1 }; } + finally { + try { + if (input_3_1 && !input_3_1.done && (_a = input_3.return)) _a.call(input_3); } + finally { if (e_12) throw e_12.error; } } return output; } @@ -31236,12 +38242,13 @@ exports.urlEncodedByteSerializer = urlEncodedByteSerializer; * @param encodingOverride: encoding override */ function urlEncodedSerializer(tuples, encodingOverride) { + var e_13, _a; /** * 1. Let encoding be UTF-8. * 2. If encoding override is given, set encoding to the result of getting * an output encoding from encoding override. */ - const encoding = (encodingOverride === undefined || + var encoding = (encodingOverride === undefined || encodingOverride === "replacement" || encodingOverride === "UTF-16BE" || encodingOverride === "UTF-16LE" ? "UTF-8" : encodingOverride); if (encoding.toUpperCase() !== "UTF-8") { @@ -31250,39 +38257,49 @@ function urlEncodedSerializer(tuples, encodingOverride) { /** * 3. Let output be the empty string. */ - let output = ""; - /** - * 4. For each tuple in tuples: - */ - for (const tuple of tuples) { + var output = ""; + try { /** - * 4.1. Let name be the result of serializing the result of encoding - * tuple’s name, using encoding. + * 4. For each tuple in tuples: */ - const name = urlEncodedByteSerializer(util_1.utf8Encode(tuple[0])); - /** - * 4.2. Let value be tuple’s value. - */ - let value = tuple[1]; - /** - * TODO: - * 4.3. If value is a file, then set value to value’s filename. - */ - /** - * 4.4. Set value to the result of serializing the result of encoding - * value, using encoding. - */ - value = urlEncodedByteSerializer(util_1.utf8Encode(value)); - /** - * 4.5. If tuple is not the first pair in tuples, then append U+0026 (&) - * to output. - */ - if (output !== "") - output += '&'; - /** - * 4.6. Append name, followed by U+003D (=), followed by value, to output. - */ - output += name + '=' + value; + for (var tuples_1 = __values(tuples), tuples_1_1 = tuples_1.next(); !tuples_1_1.done; tuples_1_1 = tuples_1.next()) { + var tuple = tuples_1_1.value; + /** + * 4.1. Let name be the result of serializing the result of encoding + * tuple’s name, using encoding. + */ + var name = urlEncodedByteSerializer(util_1.utf8Encode(tuple[0])); + /** + * 4.2. Let value be tuple’s value. + */ + var value = tuple[1]; + /** + * TODO: + * 4.3. If value is a file, then set value to value’s filename. + */ + /** + * 4.4. Set value to the result of serializing the result of encoding + * value, using encoding. + */ + value = urlEncodedByteSerializer(util_1.utf8Encode(value)); + /** + * 4.5. If tuple is not the first pair in tuples, then append U+0026 (&) + * to output. + */ + if (output !== "") + output += '&'; + /** + * 4.6. Append name, followed by U+003D (=), followed by value, to output. + */ + output += name + '=' + value; + } + } + catch (e_13_1) { e_13 = { error: e_13_1 }; } + finally { + try { + if (tuples_1_1 && !tuples_1_1.done && (_a = tuples_1.return)) _a.call(tuples_1); + } + finally { if (e_13) throw e_13.error; } } /** * 5. Return output. @@ -31323,7 +38340,7 @@ function origin(url) { if (url._blobURLEntry !== null) { // TODO: return URL’s blob URL entry’s environment’s origin. } - const parsedURL = basicURLParser(url.path[0]); + var parsedURL = basicURLParser(url.path[0]); if (parsedURL === null) return interfaces_1.OpaqueOrigin; else @@ -31346,7 +38363,8 @@ exports.origin = origin; * * @param domain - a domain string */ -function domainToASCII(domain, beStrict = false) { +function domainToASCII(domain, beStrict) { + if (beStrict === void 0) { beStrict = false; } /** * 1. If beStrict is not given, set it to false. * 2. Let result be the result of running Unicode ToASCII with domain_name @@ -31357,7 +38375,7 @@ function domainToASCII(domain, beStrict = false) { * 4. Return result. */ // Use node.js function - const result = url_1.domainToASCII(domain); + var result = url_1.domainToASCII(domain); if (result === "") { validationError("Invalid domain name."); return null; @@ -31370,7 +38388,8 @@ exports.domainToASCII = domainToASCII; * * @param domain - a domain string */ -function domainToUnicode(domain, beStrict = false) { +function domainToUnicode(domain, beStrict) { + if (beStrict === void 0) { beStrict = false; } /** * 1. Let result be the result of running Unicode ToUnicode with domain_name * set to domain, CheckHyphens set to false, CheckBidi set to true, @@ -31380,7 +38399,7 @@ function domainToUnicode(domain, beStrict = false) { * return result. */ // Use node.js function - const result = url_1.domainToUnicode(domain); + var result = url_1.domainToUnicode(domain); if (result === "") { validationError("Invalid domain name."); } @@ -31407,7 +38426,7 @@ function asciiSerializationOfAnOrigin(origin) { if (origin[0] === "" && origin[1] === "" && origin[2] === null && origin[3] === null) { return "null"; } - let result = origin[0] + "://" + hostSerializer(origin[1]); + var result = origin[0] + "://" + hostSerializer(origin[1]); if (origin[2] !== null) result += ":" + origin[2].toString(); return result; @@ -31416,66 +38435,124 @@ exports.asciiSerializationOfAnOrigin = asciiSerializationOfAnOrigin; //# sourceMappingURL=URLAlgorithm.js.map /***/ }), +/* 814 */, +/* 815 */, +/* 816 */, +/* 817 */, +/* 818 */ +/***/ (function(module) { -/***/ 820: +module.exports = require("tls"); + +/***/ }), +/* 819 */, +/* 820 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const CharacterDataImpl_1 = __webpack_require__(43); -const algorithm_1 = __webpack_require__(163); -const WebIDLAlgorithm_1 = __webpack_require__(495); +var interfaces_1 = __webpack_require__(970); +var CharacterDataImpl_1 = __webpack_require__(43); +var algorithm_1 = __webpack_require__(163); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** * Represents a text node. */ -class TextImpl extends CharacterDataImpl_1.CharacterDataImpl { +var TextImpl = /** @class */ (function (_super) { + __extends(TextImpl, _super); /** * Initializes a new instance of `Text`. * * @param data - the text content */ - constructor(data = '') { - super(data); - this._name = ''; - this._assignedSlot = null; + function TextImpl(data) { + if (data === void 0) { data = ''; } + var _this = _super.call(this, data) || this; + _this._name = ''; + _this._assignedSlot = null; + return _this; } + Object.defineProperty(TextImpl.prototype, "wholeText", { + /** @inheritdoc */ + get: function () { + var e_1, _a; + /** + * The wholeText attribute’s getter must return the concatenation of the + * data of the contiguous Text nodes of the context object, in tree order. + */ + var text = ''; + try { + for (var _b = __values(algorithm_1.text_contiguousTextNodes(this, true)), _c = _b.next(); !_c.done; _c = _b.next()) { + var node = _c.value; + text = text + node._data; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + return text; + }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get wholeText() { - /** - * The wholeText attribute’s getter must return the concatenation of the - * data of the contiguous Text nodes of the context object, in tree order. - */ - let text = ''; - for (const node of algorithm_1.text_contiguousTextNodes(this, true)) { - text = text + node._data; - } - return text; - } - /** @inheritdoc */ - splitText(offset) { + TextImpl.prototype.splitText = function (offset) { /** * The splitText(offset) method, when invoked, must split context object * with offset offset. */ return algorithm_1.text_split(this, offset); - } - // MIXIN: Slotable - /* istanbul ignore next */ - get assignedSlot() { throw new Error("Mixin: Slotable not implemented."); } + }; + Object.defineProperty(TextImpl.prototype, "assignedSlot", { + // MIXIN: Slotable + /* istanbul ignore next */ + get: function () { throw new Error("Mixin: Slotable not implemented."); }, + enumerable: true, + configurable: true + }); /** * Creates a `Text`. * * @param document - owner document * @param data - the text content */ - static _create(document, data = '') { - const node = new TextImpl(data); + TextImpl._create = function (document, data) { + if (data === void 0) { data = ''; } + var node = new TextImpl(data); node._nodeDocument = document; return node; - } -} + }; + return TextImpl; +}(CharacterDataImpl_1.CharacterDataImpl)); exports.TextImpl = TextImpl; /** * Initialize prototype properties @@ -31484,334 +38561,1436 @@ WebIDLAlgorithm_1.idl_defineConst(TextImpl.prototype, "_nodeType", interfaces_1. //# sourceMappingURL=TextImpl.js.map /***/ }), - -/***/ 826: +/* 821 */, +/* 822 */ /***/ (function(module, __unusedexports, __webpack_require__) { -var rng = __webpack_require__(139); -var bytesToUuid = __webpack_require__(722); +const parse = __webpack_require__(830) +const eq = __webpack_require__(298) -function v4(options, buf, offset) { - var i = buf && offset || 0; - - if (typeof(options) == 'string') { - buf = options === 'binary' ? new Array(16) : null; - options = null; - } - options = options || {}; - - var rnds = options.random || (options.rng || rng)(); - - // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - rnds[6] = (rnds[6] & 0x0f) | 0x40; - rnds[8] = (rnds[8] & 0x3f) | 0x80; - - // Copy bytes to buffer, if provided - if (buf) { - for (var ii = 0; ii < 16; ++ii) { - buf[i + ii] = rnds[ii]; +const diff = (version1, version2) => { + if (eq(version1, version2)) { + return null + } else { + const v1 = parse(version1) + const v2 = parse(version2) + const hasPre = v1.prerelease.length || v2.prerelease.length + const prefix = hasPre ? 'pre' : '' + const defaultResult = hasPre ? 'prerelease' : '' + for (const key in v1) { + if (key === 'major' || key === 'minor' || key === 'patch') { + if (v1[key] !== v2[key]) { + return prefix + key + } + } } + return defaultResult // may be undefined } - - return buf || bytesToUuid(rnds); } - -module.exports = v4; +module.exports = diff /***/ }), +/* 823 */, +/* 824 */, +/* 825 */, +/* 826 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { -/***/ 835: +"use strict"; + +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; +var __spread = (this && this.__spread) || function () { + for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); + return ar; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +var DOMImpl_1 = __webpack_require__(648); +var interfaces_1 = __webpack_require__(970); +var util_1 = __webpack_require__(918); +var CustomEventImpl_1 = __webpack_require__(164); +var EventImpl_1 = __webpack_require__(427); +var DOMException_1 = __webpack_require__(35); +var TreeAlgorithm_1 = __webpack_require__(873); +var ShadowTreeAlgorithm_1 = __webpack_require__(180); +var DOMAlgorithm_1 = __webpack_require__(304); +/** + * Sets the canceled flag of an event. + * + * @param event - an event + */ +function event_setTheCanceledFlag(event) { + if (event._cancelable && !event._inPassiveListenerFlag) { + event._canceledFlag = true; + } +} +exports.event_setTheCanceledFlag = event_setTheCanceledFlag; +/** + * Initializes the value of an event. + * + * @param event - an event to initialize + * @param type - the type of event + * @param bubbles - whether the event propagates in reverse + * @param cancelable - whether the event can be cancelled + */ +function event_initialize(event, type, bubbles, cancelable) { + event._initializedFlag = true; + event._stopPropagationFlag = false; + event._stopImmediatePropagationFlag = false; + event._canceledFlag = false; + event._isTrusted = false; + event._target = null; + event._type = type; + event._bubbles = bubbles; + event._cancelable = cancelable; +} +exports.event_initialize = event_initialize; +/** + * Creates a new event. + * + * @param eventInterface - event interface + * @param realm - realm + */ +function event_createAnEvent(eventInterface, realm) { + if (realm === void 0) { realm = undefined; } + /** + * 1. If realm is not given, then set it to null. + * 2. Let dictionary be the result of converting the JavaScript value + * undefined to the dictionary type accepted by eventInterface’s + * constructor. (This dictionary type will either be EventInit or a + * dictionary that inherits from it.) + * 3. Let event be the result of running the inner event creation steps with + * eventInterface, realm, the time of the occurrence that the event is + * signaling, and dictionary. + * 4. Initialize event’s isTrusted attribute to true. + * 5. Return event. + */ + if (realm === undefined) + realm = null; + var dictionary = {}; + var event = event_innerEventCreationSteps(eventInterface, realm, new Date(), dictionary); + event._isTrusted = true; + return event; +} +exports.event_createAnEvent = event_createAnEvent; +/** + * Performs event creation steps. + * + * @param eventInterface - event interface + * @param realm - realm + * @param time - time of occurrance + * @param dictionary - event attributes + * + */ +function event_innerEventCreationSteps(eventInterface, realm, time, dictionary) { + /** + * 1. Let event be the result of creating a new object using eventInterface. + * TODO: Implement realms + * If realm is non-null, then use that Realm; otherwise, use the default + * behavior defined in Web IDL. + */ + var event = new eventInterface(""); + /** + * 2. Set event’s initialized flag. + * 3. Initialize event’s timeStamp attribute to a DOMHighResTimeStamp + * representing the high resolution time from the time origin to time. + * 4. For each member → value in dictionary, if event has an attribute + * whose identifier is member, then initialize that attribute to value. + * 5. Run the event constructing steps with event. + * 6. Return event. + */ + event._initializedFlag = true; + event._timeStamp = time.getTime(); + Object.assign(event, dictionary); + if (DOMImpl_1.dom.features.steps) { + DOMAlgorithm_1.dom_runEventConstructingSteps(event); + } + return event; +} +exports.event_innerEventCreationSteps = event_innerEventCreationSteps; +/** + * Dispatches an event to an event target. + * + * @param event - the event to dispatch + * @param target - event target + * @param legacyTargetOverrideFlag - legacy target override flag + * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns + * whether the event listener's callback threw an exception + */ +function event_dispatch(event, target, legacyTargetOverrideFlag, legacyOutputDidListenersThrowFlag) { + var e_1, _a, e_2, _b; + if (legacyTargetOverrideFlag === void 0) { legacyTargetOverrideFlag = false; } + if (legacyOutputDidListenersThrowFlag === void 0) { legacyOutputDidListenersThrowFlag = { value: false }; } + var clearTargets = false; + /** + * 1. Set event's dispatch flag. + */ + event._dispatchFlag = true; + /** + * 2. Let targetOverride be target, if legacy target override flag is not + * given, and target's associated Document otherwise. + * + * _Note:_ legacy target override flag is only used by HTML and only when + * target is a Window object. + */ + var targetOverride = target; + if (legacyTargetOverrideFlag) { + var doc = target._associatedDocument; + if (util_1.Guard.isDocumentNode(doc)) { + targetOverride = doc; + } + } + /** + * 3. Let activationTarget be null. + * 4. Let relatedTarget be the result of retargeting event's relatedTarget + * against target. + * 5. If target is not relatedTarget or target is event's relatedTarget, + * then: + */ + var activationTarget = null; + var relatedTarget = TreeAlgorithm_1.tree_retarget(event._relatedTarget, target); + if (target !== relatedTarget || target === event._relatedTarget) { + /** + * 5.1. Let touchTargets be a new list. + * 5.2. For each touchTarget of event's touch target list, append the + * result of retargeting touchTarget against target to touchTargets. + * 5.3. Append to an event path with event, target, targetOverride, + * relatedTarget, touchTargets, and false. + * 5.4. Let isActivationEvent be true, if event is a MouseEvent object + * and event's type attribute is "click", and false otherwise. + * 5.5. If isActivationEvent is true and target has activation behavior, + * then set activationTarget to target. + * 5.6. Let slotable be target, if target is a slotable and is assigned, + * and null otherwise. + * 5.7. Let slot-in-closed-tree be false. + * 5.8. Let parent be the result of invoking target's get the parent with + * event. + */ + var touchTargets = []; + try { + for (var _c = __values(event._touchTargetList), _d = _c.next(); !_d.done; _d = _c.next()) { + var touchTarget = _d.value; + touchTargets.push(TreeAlgorithm_1.tree_retarget(touchTarget, target)); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_d && !_d.done && (_a = _c.return)) _a.call(_c); + } + finally { if (e_1) throw e_1.error; } + } + event_appendToAnEventPath(event, target, targetOverride, relatedTarget, touchTargets, false); + var isActivationEvent = (util_1.Guard.isMouseEvent(event) && event._type === "click"); + if (isActivationEvent && target._activationBehavior !== undefined) { + activationTarget = target; + } + var slotable = (util_1.Guard.isSlotable(target) && ShadowTreeAlgorithm_1.shadowTree_isAssigned(target)) ? + target : null; + var slotInClosedTree = false; + var parent = target._getTheParent(event); + /** + * 5.9. While parent is non-null: + */ + while (parent !== null && util_1.Guard.isNode(parent)) { + /** + * 5.9.1 If slotable is non-null: + * 5.9.1.1. Assert: parent is a slot. + * 5.9.1.2. Set slotable to null. + * 5.9.1.3. If parent's root is a shadow root whose mode is "closed", + * then set slot-in-closed-tree to true. + */ + if (slotable !== null) { + if (!util_1.Guard.isSlot(parent)) { + throw new Error("Parent node of a slotable should be a slot."); + } + slotable = null; + var root = TreeAlgorithm_1.tree_rootNode(parent, true); + if (util_1.Guard.isShadowRoot(root) && root._mode === "closed") { + slotInClosedTree = true; + } + } + /** + * 5.9.2 If parent is a slotable and is assigned, then set slotable to + * parent. + * 5.9.3. Let relatedTarget be the result of retargeting event's + * relatedTarget against parent. + * 5.9.4. Let touchTargets be a new list. + * 5.9.4. For each touchTarget of event's touch target list, append the + * result of retargeting touchTarget against parent to touchTargets. + */ + if (util_1.Guard.isSlotable(parent) && ShadowTreeAlgorithm_1.shadowTree_isAssigned(parent)) { + slotable = parent; + } + relatedTarget = TreeAlgorithm_1.tree_retarget(event._relatedTarget, parent); + touchTargets = []; + try { + for (var _e = (e_2 = void 0, __values(event._touchTargetList)), _f = _e.next(); !_f.done; _f = _e.next()) { + var touchTarget = _f.value; + touchTargets.push(TreeAlgorithm_1.tree_retarget(touchTarget, parent)); + } + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_f && !_f.done && (_b = _e.return)) _b.call(_e); + } + finally { if (e_2) throw e_2.error; } + } + /** + * 5.9.6. If parent is a Window object, or parent is a node and target's + * root is a shadow-including inclusive ancestor of parent, then: + */ + if (util_1.Guard.isWindow(parent) || (util_1.Guard.isNode(parent) && util_1.Guard.isNode(target) && + TreeAlgorithm_1.tree_isAncestorOf(TreeAlgorithm_1.tree_rootNode(target, true), parent, true, true))) { + /** + * 5.9.6.1. If isActivationEvent is true, event's bubbles attribute + * is true, activationTarget is null, and parent has activation + * behavior, then set activationTarget to parent. + * 5.9.6.2. Append to an event path with event, parent, null, + * relatedTarget, touchTargets, and slot-in-closed-tree. + */ + if (isActivationEvent && event._bubbles && activationTarget === null && + parent._activationBehavior) { + activationTarget = parent; + } + event_appendToAnEventPath(event, parent, null, relatedTarget, touchTargets, slotInClosedTree); + } + else if (parent === relatedTarget) { + /** + * 5.9.7. Otherwise, if parent is relatedTarget, + * then set parent to null. + */ + parent = null; + } + else { + /** + * 5.9.8. Otherwise, set target to parent and then: + * 5.9.8.1. If isActivationEvent is true, activationTarget is null, + * and target has activation behavior, then set activationTarget + * to target. + * 5.9.8.2. Append to an event path with event, parent, target, + * relatedTarget, touchTargets, and slot-in-closed-tree. + */ + target = parent; + if (isActivationEvent && activationTarget === null && + target._activationBehavior) { + activationTarget = target; + } + event_appendToAnEventPath(event, parent, target, relatedTarget, touchTargets, slotInClosedTree); + } + /** + * 5.9.9. If parent is non-null, then set parent to the result of + * invoking parent's get the parent with event. + * 5.9.10. Set slot-in-closed-tree to false. + */ + if (parent !== null) { + parent = parent._getTheParent(event); + } + slotInClosedTree = false; + } + /** + * 5.10. Let clearTargetsStruct be the last struct in event's path whose + * shadow-adjusted target is non-null. + */ + var clearTargetsStruct = null; + var path = event._path; + for (var i = path.length - 1; i >= 0; i--) { + var struct = path[i]; + if (struct.shadowAdjustedTarget !== null) { + clearTargetsStruct = struct; + break; + } + } + /** + * 5.11. Let clearTargets be true if clearTargetsStruct's shadow-adjusted + * target, clearTargetsStruct's relatedTarget, or an EventTarget object + * in clearTargetsStruct's touch target list is a node and its root is + * a shadow root, and false otherwise. + */ + if (clearTargetsStruct !== null) { + if (util_1.Guard.isNode(clearTargetsStruct.shadowAdjustedTarget) && + util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(clearTargetsStruct.shadowAdjustedTarget, true))) { + clearTargets = true; + } + else if (util_1.Guard.isNode(clearTargetsStruct.relatedTarget) && + util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(clearTargetsStruct.relatedTarget, true))) { + clearTargets = true; + } + else { + for (var j = 0; j < clearTargetsStruct.touchTargetList.length; j++) { + var struct = clearTargetsStruct.touchTargetList[j]; + if (util_1.Guard.isNode(struct) && + util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(struct, true))) { + clearTargets = true; + break; + } + } + } + } + /** + * 5.12. If activationTarget is non-null and activationTarget has + * legacy-pre-activation behavior, then run activationTarget's + * legacy-pre-activation behavior. + */ + if (activationTarget !== null && + activationTarget._legacyPreActivationBehavior !== undefined) { + activationTarget._legacyPreActivationBehavior(event); + } + /** + * 5.13. For each struct in event's path, in reverse order: + */ + for (var i = path.length - 1; i >= 0; i--) { + var struct = path[i]; + /** + * 5.13.1. If struct's shadow-adjusted target is non-null, then set + * event's eventPhase attribute to AT_TARGET. + * 5.13.2. Otherwise, set event's eventPhase attribute to + * CAPTURING_PHASE. + * 5.13.3. Invoke with struct, event, "capturing", and + * legacyOutputDidListenersThrowFlag if given. + */ + if (struct.shadowAdjustedTarget !== null) { + event._eventPhase = interfaces_1.EventPhase.AtTarget; + } + else { + event._eventPhase = interfaces_1.EventPhase.Capturing; + } + event_invoke(struct, event, "capturing", legacyOutputDidListenersThrowFlag); + } + /** + * 5.14. For each struct in event's path + */ + for (var i = 0; i < path.length; i++) { + var struct = path[i]; + /** + * 5.14.1. If struct's shadow-adjusted target is non-null, then set + * event's eventPhase attribute to AT_TARGET. + * 5.14.2. Otherwise: + * 5.14.2.1. If event's bubbles attribute is false, then continue. + * 5.14.2.2. Set event's eventPhase attribute to BUBBLING_PHASE. + * 5.14.3. Invoke with struct, event, "bubbling", and + * legacyOutputDidListenersThrowFlag if given. + */ + if (struct.shadowAdjustedTarget !== null) { + event._eventPhase = interfaces_1.EventPhase.AtTarget; + } + else { + if (!event._bubbles) + continue; + event._eventPhase = interfaces_1.EventPhase.Bubbling; + } + event_invoke(struct, event, "bubbling", legacyOutputDidListenersThrowFlag); + } + } + /** + * 6. Set event's eventPhase attribute to NONE. + * 7. Set event's currentTarget attribute to null. + * 8. Set event's path to the empty list. + * 9. Unset event's dispatch flag, stop propagation flag, and stop + * immediate propagation flag. + */ + event._eventPhase = interfaces_1.EventPhase.None; + event._currentTarget = null; + event._path = []; + event._dispatchFlag = false; + event._stopPropagationFlag = false; + event._stopImmediatePropagationFlag = false; + /** + * 10. If clearTargets, then: + * 10.1. Set event's target to null. + * 10.2. Set event's relatedTarget to null. + * 10.3. Set event's touch target list to the empty list. + */ + if (clearTargets) { + event._target = null; + event._relatedTarget = null; + event._touchTargetList = []; + } + /** + * 11. If activationTarget is non-null, then: + * 11.1. If event's canceled flag is unset, then run activationTarget's + * activation behavior with event. + * 11.2. Otherwise, if activationTarget has legacy-canceled-activation + * behavior, then run activationTarget's legacy-canceled-activation + * behavior. + */ + if (activationTarget !== null) { + if (!event._canceledFlag && activationTarget._activationBehavior !== undefined) { + activationTarget._activationBehavior(event); + } + else if (activationTarget._legacyCanceledActivationBehavior !== undefined) { + activationTarget._legacyCanceledActivationBehavior(event); + } + } + /** + * 12. Return false if event's canceled flag is set, and true otherwise. + */ + return !event._canceledFlag; +} +exports.event_dispatch = event_dispatch; +/** + * Appends a new struct to an event's path. + * + * @param event - an event + * @param invocationTarget - the target of the invocation + * @param shadowAdjustedTarget - shadow-root adjusted event target + * @param relatedTarget - related event target + * @param touchTargets - a list of touch targets + * @param slotInClosedTree - if the target's parent is a closed shadow root + */ +function event_appendToAnEventPath(event, invocationTarget, shadowAdjustedTarget, relatedTarget, touchTargets, slotInClosedTree) { + /** + * 1. Let invocationTargetInShadowTree be false. + * 2. If invocationTarget is a node and its root is a shadow root, then + * set invocationTargetInShadowTree to true. + */ + var invocationTargetInShadowTree = false; + if (util_1.Guard.isNode(invocationTarget) && + util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(invocationTarget))) { + invocationTargetInShadowTree = true; + } + /** + * 3. Let root-of-closed-tree be false. + * 4. If invocationTarget is a shadow root whose mode is "closed", then + * set root-of-closed-tree to true. + */ + var rootOfClosedTree = false; + if (util_1.Guard.isShadowRoot(invocationTarget) && + invocationTarget._mode === "closed") { + rootOfClosedTree = true; + } + /** + * 5. Append a new struct to event's path whose invocation target is + * invocationTarget, invocation-target-in-shadow-tree is + * invocationTargetInShadowTree, shadow-adjusted target is + * shadowAdjustedTarget, relatedTarget is relatedTarget, + * touch target list is touchTargets, root-of-closed-tree is + * root-of-closed-tree, and slot-in-closed-tree is slot-in-closed-tree. + */ + event._path.push({ + invocationTarget: invocationTarget, + invocationTargetInShadowTree: invocationTargetInShadowTree, + shadowAdjustedTarget: shadowAdjustedTarget, + relatedTarget: relatedTarget, + touchTargetList: touchTargets, + rootOfClosedTree: rootOfClosedTree, + slotInClosedTree: slotInClosedTree + }); +} +exports.event_appendToAnEventPath = event_appendToAnEventPath; +/** + * Invokes an event. + * + * @param struct - a struct defining event's path + * @param event - the event to invoke + * @param phase - event phase + * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns + * whether the event listener's callback threw an exception + */ +function event_invoke(struct, event, phase, legacyOutputDidListenersThrowFlag) { + if (legacyOutputDidListenersThrowFlag === void 0) { legacyOutputDidListenersThrowFlag = { value: false }; } + /** + * 1. Set event's target to the shadow-adjusted target of the last struct + * in event's path, that is either struct or preceding struct, whose + * shadow-adjusted target is non-null. + */ + var path = event._path; + var index = -1; + for (var i = 0; i < path.length; i++) { + if (path[i] === struct) { + index = i; + break; + } + } + if (index !== -1) { + var item = path[index]; + if (item.shadowAdjustedTarget !== null) { + event._target = item.shadowAdjustedTarget; + } + else if (index > 0) { + item = path[index - 1]; + if (item.shadowAdjustedTarget !== null) { + event._target = item.shadowAdjustedTarget; + } + } + } + /** + * 2. Set event's relatedTarget to struct's relatedTarget. + * 3. Set event's touch target list to struct's touch target list. + * 4. If event's stop propagation flag is set, then return. + * 5. Initialize event's currentTarget attribute to struct's invocation + * target. + * 6. Let listeners be a clone of event's currentTarget attribute value's + * event listener list. + * + * _Note:_ This avoids event listeners added after this point from being + * run. Note that removal still has an effect due to the removed field. + */ + event._relatedTarget = struct.relatedTarget; + event._touchTargetList = struct.touchTargetList; + if (event._stopPropagationFlag) + return; + event._currentTarget = struct.invocationTarget; + var currentTarget = event._currentTarget; + var targetListeners = currentTarget._eventListenerList; + var listeners = new (Array.bind.apply(Array, __spread([void 0], targetListeners)))(); + /** + * 7. Let found be the result of running inner invoke with event, listeners, + * phase, and legacyOutputDidListenersThrowFlag if given. + */ + var found = event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag); + /** + * 8. If found is false and event's isTrusted attribute is true, then: + */ + if (!found && event._isTrusted) { + /** + * 8.1. Let originalEventType be event's type attribute value. + * 8.2. If event's type attribute value is a match for any of the strings + * in the first column in the following table, set event's type attribute + * value to the string in the second column on the same row as the matching + * string, and return otherwise. + * + * Event type | Legacy event type + * ------------------------------------------------- + * "animationend" | "webkitAnimationEnd" + * "animationiteration" | "webkitAnimationIteration" + * "animationstart" | "webkitAnimationStart" + * "transitionend" | "webkitTransitionEnd" + */ + var originalEventType = event._type; + if (originalEventType === "animationend") { + event._type = "webkitAnimationEnd"; + } + else if (originalEventType === "animationiteration") { + event._type = "webkitAnimationIteration"; + } + else if (originalEventType === "animationstart") { + event._type = "webkitAnimationStart"; + } + else if (originalEventType === "transitionend") { + event._type = "webkitTransitionEnd"; + } + /** + * 8.3. Inner invoke with event, listeners, phase, and + * legacyOutputDidListenersThrowFlag if given. + * 8.4. Set event's type attribute value to originalEventType. + */ + event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag); + event._type = originalEventType; + } +} +exports.event_invoke = event_invoke; +/** + * Invokes an event. + * + * @param event - the event to invoke + * @param listeners - event listeners + * @param phase - event phase + * @param struct - a struct defining event's path + * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns + * whether the event listener's callback threw an exception + */ +function event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag) { + if (legacyOutputDidListenersThrowFlag === void 0) { legacyOutputDidListenersThrowFlag = { value: false }; } + /** + * 1. Let found be false. + * 2. For each listener in listeners, whose removed is false: + */ + var found = false; + for (var i = 0; i < listeners.length; i++) { + var listener = listeners[i]; + if (!listener.removed) { + /** + * 2.1. If event's type attribute value is not listener's type, then + * continue. + * 2.2. Set found to true. + * 2.3. If phase is "capturing" and listener's capture is false, then + * continue. + * 2.4. If phase is "bubbling" and listener's capture is true, then + * continue. + */ + if (event._type !== listener.type) + continue; + found = true; + if (phase === "capturing" && !listener.capture) + continue; + if (phase === "bubbling" && listener.capture) + continue; + /** + * 2.5. If listener's once is true, then remove listener from event's + * currentTarget attribute value's event listener list. + */ + if (listener.once && event._currentTarget !== null) { + var impl = event._currentTarget; + var index = -1; + for (var i_1 = 0; i_1 < impl._eventListenerList.length; i_1++) { + if (impl._eventListenerList[i_1] === listener) { + index = i_1; + break; + } + } + if (index !== -1) { + impl._eventListenerList.splice(index, 1); + } + } + /** + * TODO: Implement realms + * + * 2.6. Let global be listener callback's associated Realm's global + * object. + */ + var globalObject = undefined; + /** + * 2.7. Let currentEvent be undefined. + * 2.8. If global is a Window object, then: + * 2.8.1. Set currentEvent to global's current event. + * 2.8.2. If struct's invocation-target-in-shadow-tree is false, then + * set global's current event to event. + */ + var currentEvent = undefined; + if (util_1.Guard.isWindow(globalObject)) { + currentEvent = globalObject._currentEvent; + if (struct.invocationTargetInShadowTree === false) { + globalObject._currentEvent = event; + } + } + /** + * 2.9. If listener's passive is true, then set event's in passive + * listener flag. + * 2.10. Call a user object's operation with listener's callback, + * "handleEvent", « event », and event's currentTarget attribute value. + */ + if (listener.passive) + event._inPassiveListenerFlag = true; + try { + listener.callback.handleEvent.call(event._currentTarget, event); + } + catch (err) { + /** + * If this throws an exception, then: + * 2.10.1. Report the exception. + * 2.10.2. Set legacyOutputDidListenersThrowFlag if given. + * + * _Note:_ The legacyOutputDidListenersThrowFlag is only used by + * Indexed Database API. + * TODO: Report the exception + * See: https://html.spec.whatwg.org/multipage/webappapis.html#runtime-script-errors-in-documents + */ + legacyOutputDidListenersThrowFlag.value = true; + } + /** + * 2.11. Unset event's in passive listener flag. + */ + if (listener.passive) + event._inPassiveListenerFlag = false; + /** + * 2.12. If global is a Window object, then set global's current event + * to currentEvent. + */ + if (util_1.Guard.isWindow(globalObject)) { + globalObject._currentEvent = currentEvent; + } + /** + * 2.13. If event's stop immediate propagation flag is set, then return + * found. + */ + if (event._stopImmediatePropagationFlag) + return found; + } + } + /** + * 3. Return found. + */ + return found; +} +exports.event_innerInvoke = event_innerInvoke; +/** + * Fires an event at target. + * @param e - event name + * @param target - event target + * @param eventConstructor - an event constructor, with a description of how + * IDL attributes are to be initialized + * @param idlAttributes - a dictionary describing how IDL attributes are + * to be initialized + * @param legacyTargetOverrideFlag - legacy target override flag + */ +function event_fireAnEvent(e, target, eventConstructor, idlAttributes, legacyTargetOverrideFlag) { + /** + * 1. If eventConstructor is not given, then let eventConstructor be Event. + */ + if (eventConstructor === undefined) { + eventConstructor = EventImpl_1.EventImpl; + } + /** + * 2. Let event be the result of creating an event given eventConstructor, + * in the relevant Realm of target. + */ + var event = event_createAnEvent(eventConstructor); + /** + * 3. Initialize event’s type attribute to e. + */ + event._type = e; + /** + * 4. Initialize any other IDL attributes of event as described in the + * invocation of this algorithm. + * _Note:_ This also allows for the isTrusted attribute to be set to false. + */ + if (idlAttributes) { + for (var key in idlAttributes) { + var idlObj = event; + idlObj[key] = idlAttributes[key]; + } + } + /** + * 5. Return the result of dispatching event at target, with legacy target + * override flag set if set. + */ + return event_dispatch(event, target, legacyTargetOverrideFlag); +} +exports.event_fireAnEvent = event_fireAnEvent; +/** + * Creates an event. + * + * @param eventInterface - the name of the event interface + */ +function event_createLegacyEvent(eventInterface) { + /** + * 1. Let constructor be null. + */ + var constructor = null; + /** + * TODO: Implement in HTML DOM + * 2. If interface is an ASCII case-insensitive match for any of the strings + * in the first column in the following table, then set constructor to the + * interface in the second column on the same row as the matching string: + * + * String | Interface + * -------|---------- + * "beforeunloadevent" | BeforeUnloadEvent + * "compositionevent" | CompositionEvent + * "customevent" | CustomEvent + * "devicemotionevent" | DeviceMotionEvent + * "deviceorientationevent" | DeviceOrientationEvent + * "dragevent" | DragEvent + * "event" | Event + * "events" | Event + * "focusevent" | FocusEvent + * "hashchangeevent" | HashChangeEvent + * "htmlevents" | Event + * "keyboardevent" | KeyboardEvent + * "messageevent" | MessageEvent + * "mouseevent" | MouseEvent + * "mouseevents" | + * "storageevent" | StorageEvent + * "svgevents" | Event + * "textevent" | CompositionEvent + * "touchevent" | TouchEvent + * "uievent" | UIEvent + * "uievents" | UIEvent + */ + switch (eventInterface.toLowerCase()) { + case "beforeunloadevent": + break; + case "compositionevent": + break; + case "customevent": + constructor = CustomEventImpl_1.CustomEventImpl; + break; + case "devicemotionevent": + break; + case "deviceorientationevent": + break; + case "dragevent": + break; + case "event": + case "events": + constructor = EventImpl_1.EventImpl; + break; + case "focusevent": + break; + case "hashchangeevent": + break; + case "htmlevents": + break; + case "keyboardevent": + break; + case "messageevent": + break; + case "mouseevent": + break; + case "mouseevents": + break; + case "storageevent": + break; + case "svgevents": + break; + case "textevent": + break; + case "touchevent": + break; + case "uievent": + break; + case "uievents": + break; + } + /** + * 3. If constructor is null, then throw a "NotSupportedError" DOMException. + */ + if (constructor === null) { + throw new DOMException_1.NotSupportedError("Event constructor not found for interface " + eventInterface + "."); + } + /** + * 4. If the interface indicated by constructor is not exposed on the + * relevant global object of the context object, then throw a + * "NotSupportedError" DOMException. + * _Note:_ Typically user agents disable support for touch events in some + * configurations, in which case this clause would be triggered for the + * interface TouchEvent. + */ + // TODO: Implement realms + /** + * 5. Let event be the result of creating an event given constructor. + * 6. Initialize event’s type attribute to the empty string. + * 7. Initialize event’s timeStamp attribute to a DOMHighResTimeStamp + * representing the high resolution time from the time origin to now. + * 8. Initialize event’s isTrusted attribute to false. + * 9. Unset event’s initialized flag. + */ + var event = new constructor(""); + event._type = ""; + event._timeStamp = new Date().getTime(); + event._isTrusted = false; + event._initializedFlag = false; + /** + * 10. Return event. + */ + return event; +} +exports.event_createLegacyEvent = event_createLegacyEvent; +/** + * Getter of an event handler IDL attribute. + * + * @param eventTarget - event target + * @param name - event name + */ +function event_getterEventHandlerIDLAttribute(thisObj, name) { + /** + * 1. Let eventTarget be the result of determining the target of an event + * handler given this object and name. + * 2. If eventTarget is null, then return null. + * 3. Return the result of getting the current value of the event handler + * given eventTarget and name. + */ + var eventTarget = event_determineTheTargetOfAnEventHandler(thisObj, name); + if (eventTarget === null) + return null; + return event_getTheCurrentValueOfAnEventHandler(eventTarget, name); +} +exports.event_getterEventHandlerIDLAttribute = event_getterEventHandlerIDLAttribute; +/** + * Setter of an event handler IDL attribute. + * + * @param eventTarget - event target + * @param name - event name + * @param value - event handler + */ +function event_setterEventHandlerIDLAttribute(thisObj, name, value) { + /** + * 1. Let eventTarget be the result of determining the target of an event + * handler given this object and name. + * 2. If eventTarget is null, then return. + * 3. If the given value is null, then deactivate an event handler given + * eventTarget and name. + * 4. Otherwise: + * 4.1. Let handlerMap be eventTarget's event handler map. + * 4.2. Let eventHandler be handlerMap[name]. + * 4.3. Set eventHandler's value to the given value. + * 4.4. Activate an event handler given eventTarget and name. + */ + var eventTarget = event_determineTheTargetOfAnEventHandler(thisObj, name); + if (eventTarget === null) + return; + if (value === null) { + event_deactivateAnEventHandler(eventTarget, name); + } + else { + var handlerMap = eventTarget._eventHandlerMap; + var eventHandler = handlerMap["onabort"]; + if (eventHandler !== undefined) { + eventHandler.value = value; + } + event_activateAnEventHandler(eventTarget, name); + } +} +exports.event_setterEventHandlerIDLAttribute = event_setterEventHandlerIDLAttribute; +/** + * Determines the target of an event handler. + * + * @param eventTarget - event target + * @param name - event name + */ +function event_determineTheTargetOfAnEventHandler(eventTarget, name) { + // TODO: Implement in HTML DOM + return null; +} +exports.event_determineTheTargetOfAnEventHandler = event_determineTheTargetOfAnEventHandler; +/** + * Gets the current value of an event handler. + * + * @param eventTarget - event target + * @param name - event name + */ +function event_getTheCurrentValueOfAnEventHandler(eventTarget, name) { + // TODO: Implement in HTML DOM + return null; +} +exports.event_getTheCurrentValueOfAnEventHandler = event_getTheCurrentValueOfAnEventHandler; +/** + * Activates an event handler. + * + * @param eventTarget - event target + * @param name - event name + */ +function event_activateAnEventHandler(eventTarget, name) { + // TODO: Implement in HTML DOM +} +exports.event_activateAnEventHandler = event_activateAnEventHandler; +/** + * Deactivates an event handler. + * + * @param eventTarget - event target + * @param name - event name + */ +function event_deactivateAnEventHandler(eventTarget, name) { + // TODO: Implement in HTML DOM +} +exports.event_deactivateAnEventHandler = event_deactivateAnEventHandler; +//# sourceMappingURL=EventAlgorithm.js.map + +/***/ }), +/* 827 */, +/* 828 */, +/* 829 */, +/* 830 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const {MAX_LENGTH} = __webpack_require__(181) +const { re, t } = __webpack_require__(976) +const SemVer = __webpack_require__(65) + +const parseOptions = __webpack_require__(143) +const parse = (version, options) => { + options = parseOptions(options) + + if (version instanceof SemVer) { + return version + } + + if (typeof version !== 'string') { + return null + } + + if (version.length > MAX_LENGTH) { + return null + } + + const r = options.loose ? re[t.LOOSE] : re[t.FULL] + if (!r.test(version)) { + return null + } + + try { + return new SemVer(version, options) + } catch (er) { + return null + } +} + +module.exports = parse + + +/***/ }), +/* 831 */, +/* 832 */, +/* 833 */, +/* 834 */, +/* 835 */ /***/ (function(module) { module.exports = require("url"); /***/ }), - -/***/ 844: -/***/ (function(__unusedmodule, exports) { +/* 836 */, +/* 837 */, +/* 838 */, +/* 839 */, +/* 840 */, +/* 841 */ +/***/ (function(module, __unusedexports, __webpack_require__) { "use strict"; -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents a set of objects with a size limit. - */ -class FixedSizeSet { - /** - * Initializes a new instance of `FixedSizeSet`. - * - * @param limit - maximum number of items to keep in the set. When the limit - * is exceeded the first item is removed from the set. - */ - constructor(limit = 1000) { - this._items = new Set(); - this._limit = limit; - } - /** - * Adds a new item to the set. - * - * @param item - an item - */ - add(item) { - this._items.add(item); - if (this._items.size > this._limit) { - const it = this._items.values().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - return this; - } - /** - * Removes an item from the set. - * - * @param item - an item - */ - delete(item) { - return this._items.delete(item); - } - /** - * Determines if an item is in the set. - * - * @param item - an item - */ - has(item) { - return this._items.has(item); - } - /** - * Removes all items from the set. - */ - clear() { - this._items.clear(); - } - /** - * Gets the number of items in the set. - */ - get size() { return this._items.size; } - /** - * Applies the given callback function to all elements of the set. - */ - forEach(callback, thisArg) { - this._items.forEach(e => callback.call(thisArg, e, e, this)); - } - /** - * Iterates through the items in the set. - */ - *keys() { - yield* this._items.keys(); - } - /** - * Iterates through the items in the set. - */ - *values() { - yield* this._items.values(); - } - /** - * Iterates through the items in the set. - */ - *entries() { - yield* this._items.entries(); - } - /** - * Iterates through the items in the set. - */ - *[Symbol.iterator]() { - yield* this._items; - } - /** - * Returns the string tag of the set. - */ - get [Symbol.toStringTag]() { - return "FixedSizeSet"; - } + +var Type = __webpack_require__(945); + +var YAML_DATE_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9])' + // [2] month + '-([0-9][0-9])$'); // [3] day + +var YAML_TIMESTAMP_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9]?)' + // [2] month + '-([0-9][0-9]?)' + // [3] day + '(?:[Tt]|[ \\t]+)' + // ... + '([0-9][0-9]?)' + // [4] hour + ':([0-9][0-9])' + // [5] minute + ':([0-9][0-9])' + // [6] second + '(?:\\.([0-9]*))?' + // [7] fraction + '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour + '(?::([0-9][0-9]))?))?$'); // [11] tz_minute + +function resolveYamlTimestamp(data) { + if (data === null) return false; + if (YAML_DATE_REGEXP.exec(data) !== null) return true; + if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true; + return false; } -exports.FixedSizeSet = FixedSizeSet; -//# sourceMappingURL=FixedSizeSet.js.map + +function constructYamlTimestamp(data) { + var match, year, month, day, hour, minute, second, fraction = 0, + delta = null, tz_hour, tz_minute, date; + + match = YAML_DATE_REGEXP.exec(data); + if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data); + + if (match === null) throw new Error('Date resolve error'); + + // match: [1] year [2] month [3] day + + year = +(match[1]); + month = +(match[2]) - 1; // JS month starts with 0 + day = +(match[3]); + + if (!match[4]) { // no hour + return new Date(Date.UTC(year, month, day)); + } + + // match: [4] hour [5] minute [6] second [7] fraction + + hour = +(match[4]); + minute = +(match[5]); + second = +(match[6]); + + if (match[7]) { + fraction = match[7].slice(0, 3); + while (fraction.length < 3) { // milli-seconds + fraction += '0'; + } + fraction = +fraction; + } + + // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute + + if (match[9]) { + tz_hour = +(match[10]); + tz_minute = +(match[11] || 0); + delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds + if (match[9] === '-') delta = -delta; + } + + date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); + + if (delta) date.setTime(date.getTime() - delta); + + return date; +} + +function representYamlTimestamp(object /*, style*/) { + return object.toISOString(); +} + +module.exports = new Type('tag:yaml.org,2002:timestamp', { + kind: 'scalar', + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp +}); + /***/ }), +/* 842 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 859: +"use strict"; + + +var Type = __webpack_require__(945); + +var _hasOwnProperty = Object.prototype.hasOwnProperty; +var _toString = Object.prototype.toString; + +function resolveYamlOmap(data) { + if (data === null) return true; + + var objectKeys = [], index, length, pair, pairKey, pairHasKey, + object = data; + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + pairHasKey = false; + + if (_toString.call(pair) !== '[object Object]') return false; + + for (pairKey in pair) { + if (_hasOwnProperty.call(pair, pairKey)) { + if (!pairHasKey) pairHasKey = true; + else return false; + } + } + + if (!pairHasKey) return false; + + if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey); + else return false; + } + + return true; +} + +function constructYamlOmap(data) { + return data !== null ? data : []; +} + +module.exports = new Type('tag:yaml.org,2002:omap', { + kind: 'sequence', + resolve: resolveYamlOmap, + construct: constructYamlOmap +}); + + +/***/ }), +/* 843 */, +/* 844 */, +/* 845 */, +/* 846 */, +/* 847 */, +/* 848 */, +/* 849 */, +/* 850 */, +/* 851 */, +/* 852 */, +/* 853 */, +/* 854 */, +/* 855 */, +/* 856 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = __webpack_require__(141); + + +/***/ }), +/* 857 */, +/* 858 */, +/* 859 */, +/* 860 */, +/* 861 */, +/* 862 */, +/* 863 */, +/* 864 */, +/* 865 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(42); -const util_2 = __webpack_require__(457); +var ObjectReader_1 = __webpack_require__(50); +var BaseReader_1 = __webpack_require__(305); +var js_yaml_1 = __webpack_require__(414); /** - * Parses the given byte sequence representing a JSON string into an object. - * - * @param bytes - a byte sequence + * Parses XML nodes from a YAML string. */ -function parseJSONFromBytes(bytes) { - /** - * 1. Let jsonText be the result of running UTF-8 decode on bytes. [ENCODING] - * 2. Return ? Call(%JSONParse%, undefined, « jsonText »). - */ - const jsonText = util_2.utf8Decode(bytes); - return JSON.parse.call(undefined, jsonText); -} -exports.parseJSONFromBytes = parseJSONFromBytes; -/** - * Serialize the given JavaScript value into a byte sequence. - * - * @param value - a JavaScript value - */ -function serializeJSONToBytes(value) { - /** - * 1. Let jsonString be ? Call(%JSONStringify%, undefined, « value »). - * 2. Return the result of running UTF-8 encode on jsonString. [ENCODING] - */ - const jsonString = JSON.stringify.call(undefined, value); - return util_2.utf8Encode(jsonString); -} -exports.serializeJSONToBytes = serializeJSONToBytes; -/** - * Parses the given JSON string into a Realm-independent JavaScript value. - * - * @param jsonText - a JSON string - */ -function parseJSONIntoInfraValues(jsonText) { - /** - * 1. Let jsValue be ? Call(%JSONParse%, undefined, « jsonText »). - * 2. Return the result of converting a JSON-derived JavaScript value to an - * Infra value, given jsValue. - */ - const jsValue = JSON.parse.call(undefined, jsonText); - return convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue); -} -exports.parseJSONIntoInfraValues = parseJSONIntoInfraValues; -/** - * Parses the value into a Realm-independent JavaScript value. - * - * @param jsValue - a JavaScript value - */ -function convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue) { - /** - * 1. If Type(jsValue) is Null, String, or Number, then return jsValue. - */ - if (jsValue === null || util_1.isString(jsValue) || util_1.isNumber(jsValue)) - return jsValue; - /** - * 2. If IsArray(jsValue) is true, then: - * 2.1. Let result be an empty list. - * 2.2. Let length be ! ToLength(! Get(jsValue, "length")). - * 2.3. For each index of the range 0 to length − 1, inclusive: - * 2.3.1. Let indexName be ! ToString(index). - * 2.3.2. Let jsValueAtIndex be ! Get(jsValue, indexName). - * 2.3.3. Let infraValueAtIndex be the result of converting a JSON-derived - * JavaScript value to an Infra value, given jsValueAtIndex. - * 2.3.4. Append infraValueAtIndex to result. - * 2.8. Return result. - */ - if (util_1.isArray(jsValue)) { - const result = new Array(); - for (const jsValueAtIndex of jsValue) { - result.push(convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtIndex)); - } - return result; +var YAMLReader = /** @class */ (function (_super) { + __extends(YAMLReader, _super); + function YAMLReader() { + return _super !== null && _super.apply(this, arguments) || this; } - else if (util_1.isObject(jsValue)) { - /** - * 3. Let result be an empty ordered map. - * 4. For each key of ! jsValue.[[OwnPropertyKeys]](): - * 4.1. Let jsValueAtKey be ! Get(jsValue, key). - * 4.2. Let infraValueAtKey be the result of converting a JSON-derived - * JavaScript value to an Infra value, given jsValueAtKey. - * 4.3. Set result[key] to infraValueAtKey. - * 5. Return result. - */ - const result = new Map(); - for (const key in jsValue) { - /* istanbul ignore else */ - if (jsValue.hasOwnProperty(key)) { - const jsValueAtKey = jsValue[key]; - result.set(key, convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtKey)); - } + /** + * Parses the given document representation. + * + * @param node - node receive parsed XML nodes + * @param str - YAML string to parse + */ + YAMLReader.prototype._parse = function (node, str) { + var result = js_yaml_1.safeLoad(str); + /* istanbul ignore next */ + if (result === undefined) { + throw new Error("Unable to parse YAML document."); } - return result; - } - /* istanbul ignore next */ - return jsValue; -} -exports.convertAJSONDerivedJavaScriptValueToAnInfraValue = convertAJSONDerivedJavaScriptValueToAnInfraValue; -//# sourceMappingURL=JSON.js.map + return new ObjectReader_1.ObjectReader(this._builderOptions).parse(node, result); + }; + return YAMLReader; +}(BaseReader_1.BaseReader)); +exports.YAMLReader = YAMLReader; +//# sourceMappingURL=YAMLReader.js.map /***/ }), - -/***/ 866: +/* 866 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(970); -const NodeImpl_1 = __webpack_require__(935); -const algorithm_1 = __webpack_require__(163); -const WebIDLAlgorithm_1 = __webpack_require__(495); +var interfaces_1 = __webpack_require__(970); +var NodeImpl_1 = __webpack_require__(935); +var algorithm_1 = __webpack_require__(163); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** * Represents an attribute of an element node. */ -class AttrImpl extends NodeImpl_1.NodeImpl { +var AttrImpl = /** @class */ (function (_super) { + __extends(AttrImpl, _super); /** * Initializes a new instance of `Attr`. * * @param localName - local name */ - constructor(localName) { - super(); - this._namespace = null; - this._namespacePrefix = null; - this._element = null; - this._value = ''; - this._localName = localName; + function AttrImpl(localName) { + var _this = _super.call(this) || this; + _this._namespace = null; + _this._namespacePrefix = null; + _this._element = null; + _this._value = ''; + _this._localName = localName; + return _this; } - /** @inheritdoc */ - get ownerElement() { return this._element; } - /** @inheritdoc */ - get namespaceURI() { return this._namespace; } - /** @inheritdoc */ - get prefix() { return this._namespacePrefix; } - /** @inheritdoc */ - get localName() { return this._localName; } - /** @inheritdoc */ - get name() { return this._qualifiedName; } - /** @inheritdoc */ - get value() { return this._value; } - set value(value) { + Object.defineProperty(AttrImpl.prototype, "ownerElement", { + /** @inheritdoc */ + get: function () { return this._element; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AttrImpl.prototype, "namespaceURI", { + /** @inheritdoc */ + get: function () { return this._namespace; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AttrImpl.prototype, "prefix", { + /** @inheritdoc */ + get: function () { return this._namespacePrefix; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AttrImpl.prototype, "localName", { + /** @inheritdoc */ + get: function () { return this._localName; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AttrImpl.prototype, "name", { + /** @inheritdoc */ + get: function () { return this._qualifiedName; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AttrImpl.prototype, "value", { + /** @inheritdoc */ + get: function () { return this._value; }, + set: function (value) { + /** + * The value attribute’s setter must set an existing attribute value with + * context object and the given value. + */ + algorithm_1.attr_setAnExistingAttributeValue(this, value); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AttrImpl.prototype, "_qualifiedName", { /** - * The value attribute’s setter must set an existing attribute value with - * context object and the given value. + * Returns the qualified name. */ - algorithm_1.attr_setAnExistingAttributeValue(this, value); - } - /** - * Returns the qualified name. - */ - get _qualifiedName() { - /** - * An attribute’s qualified name is its local name if its namespace prefix - * is null, and its namespace prefix, followed by ":", followed by its - * local name, otherwise. - */ - return (this._namespacePrefix !== null ? - this._namespacePrefix + ':' + this._localName : - this._localName); - } + get: function () { + /** + * An attribute’s qualified name is its local name if its namespace prefix + * is null, and its namespace prefix, followed by ":", followed by its + * local name, otherwise. + */ + return (this._namespacePrefix !== null ? + this._namespacePrefix + ':' + this._localName : + this._localName); + }, + enumerable: true, + configurable: true + }); /** * Creates an `Attr`. * * @param document - owner document * @param localName - local name */ - static _create(document, localName) { - const node = new AttrImpl(localName); + AttrImpl._create = function (document, localName) { + var node = new AttrImpl(localName); node._nodeDocument = document; return node; - } -} + }; + return AttrImpl; +}(NodeImpl_1.NodeImpl)); exports.AttrImpl = AttrImpl; /** * Initialize prototype properties @@ -31821,15 +40000,31 @@ WebIDLAlgorithm_1.idl_defineConst(AttrImpl.prototype, "specified", true); //# sourceMappingURL=AttrImpl.js.map /***/ }), - -/***/ 873: +/* 867 */, +/* 868 */, +/* 869 */, +/* 870 */, +/* 871 */, +/* 872 */, +/* 873 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(918); -const interfaces_1 = __webpack_require__(970); +var util_1 = __webpack_require__(918); +var interfaces_1 = __webpack_require__(970); /** * Gets the next descendant of the given node of the tree rooted at `root` * in depth-first pre-order. @@ -31838,7 +40033,8 @@ const interfaces_1 = __webpack_require__(970); * @param node - a node * @param shadow - whether to visit shadow tree nodes */ -function _getNextDescendantNode(root, node, shadow = false) { +function _getNextDescendantNode(root, node, shadow) { + if (shadow === void 0) { shadow = false; } // traverse shadow tree if (shadow && util_1.Guard.isElementNode(node) && util_1.Guard.isShadowRoot(node.shadowRoot)) { if (node.shadowRoot._firstChild) @@ -31853,7 +40049,7 @@ function _getNextDescendantNode(root, node, shadow = false) { if (node._nextSibling) return node._nextSibling; // traverse parent's next sibling - let parent = node._parent; + var parent = node._parent; while (parent && parent !== root) { if (parent._nextSibling) return parent._nextSibling; @@ -31862,15 +40058,16 @@ function _getNextDescendantNode(root, node, shadow = false) { return null; } function _emptyIterator() { - return { - [Symbol.iterator]: () => { + var _a; + return _a = {}, + _a[Symbol.iterator] = function () { return { - next: () => { + next: function () { return { done: true, value: null }; } }; - } - }; + }, + _a; } /** * Returns the first descendant node of the tree rooted at `node` in @@ -31881,8 +40078,10 @@ function _emptyIterator() { * @param shadow - whether to visit shadow tree nodes * @param filter - a function to filter nodes */ -function tree_getFirstDescendantNode(node, self = false, shadow = false, filter) { - let firstNode = (self ? node : _getNextDescendantNode(node, node, shadow)); +function tree_getFirstDescendantNode(node, self, shadow, filter) { + if (self === void 0) { self = false; } + if (shadow === void 0) { shadow = false; } + var firstNode = (self ? node : _getNextDescendantNode(node, node, shadow)); while (firstNode && filter && !filter(firstNode)) { firstNode = _getNextDescendantNode(node, firstNode, shadow); } @@ -31899,8 +40098,10 @@ exports.tree_getFirstDescendantNode = tree_getFirstDescendantNode; * @param shadow - whether to visit shadow tree nodes * @param filter - a function to filter nodes */ -function tree_getNextDescendantNode(node, currentNode, self = false, shadow = false, filter) { - let nextNode = _getNextDescendantNode(node, currentNode, shadow); +function tree_getNextDescendantNode(node, currentNode, self, shadow, filter) { + if (self === void 0) { self = false; } + if (shadow === void 0) { shadow = false; } + var nextNode = _getNextDescendantNode(node, currentNode, shadow); while (nextNode && filter && !filter(nextNode)) { nextNode = _getNextDescendantNode(node, nextNode, shadow); } @@ -31916,15 +40117,18 @@ exports.tree_getNextDescendantNode = tree_getNextDescendantNode; * @param shadow - whether to visit shadow tree nodes * @param filter - a function to filter nodes */ -function tree_getDescendantNodes(node, self = false, shadow = false, filter) { +function tree_getDescendantNodes(node, self, shadow, filter) { + var _a; + if (self === void 0) { self = false; } + if (shadow === void 0) { shadow = false; } if (!self && node._children.size === 0) { return _emptyIterator(); } - return { - [Symbol.iterator]: () => { - let currentNode = (self ? node : _getNextDescendantNode(node, node, shadow)); + return _a = {}, + _a[Symbol.iterator] = function () { + var currentNode = (self ? node : _getNextDescendantNode(node, node, shadow)); return { - next: () => { + next: function () { while (currentNode && filter && !filter(currentNode)) { currentNode = _getNextDescendantNode(node, currentNode, shadow); } @@ -31932,14 +40136,14 @@ function tree_getDescendantNodes(node, self = false, shadow = false, filter) { return { done: true, value: null }; } else { - const result = { done: false, value: currentNode }; + var result = { done: false, value: currentNode }; currentNode = _getNextDescendantNode(node, currentNode, shadow); return result; } } }; - } - }; + }, + _a; } exports.tree_getDescendantNodes = tree_getDescendantNodes; /** @@ -31951,16 +40155,19 @@ exports.tree_getDescendantNodes = tree_getDescendantNodes; * @param shadow - whether to visit shadow tree nodes * @param filter - a function to filter nodes */ -function tree_getDescendantElements(node, self = false, shadow = false, filter) { +function tree_getDescendantElements(node, self, shadow, filter) { + var _a; + if (self === void 0) { self = false; } + if (shadow === void 0) { shadow = false; } if (!self && node._children.size === 0) { return _emptyIterator(); } - return { - [Symbol.iterator]: () => { - const it = tree_getDescendantNodes(node, self, shadow, (e) => util_1.Guard.isElementNode(e))[Symbol.iterator](); - let currentNode = it.next().value; + return _a = {}, + _a[Symbol.iterator] = function () { + var it = tree_getDescendantNodes(node, self, shadow, function (e) { return util_1.Guard.isElementNode(e); })[Symbol.iterator](); + var currentNode = it.next().value; return { - next() { + next: function () { while (currentNode && filter && !filter(currentNode)) { currentNode = it.next().value; } @@ -31968,14 +40175,14 @@ function tree_getDescendantElements(node, self = false, shadow = false, filter) return { done: true, value: null }; } else { - const result = { done: false, value: currentNode }; + var result = { done: false, value: currentNode }; currentNode = it.next().value; return result; } } }; - } - }; + }, + _a; } exports.tree_getDescendantElements = tree_getDescendantElements; /** @@ -31985,15 +40192,17 @@ exports.tree_getDescendantElements = tree_getDescendantElements; * @param self - whether to include `node` in traversal * @param filter - a function to filter nodes */ -function tree_getSiblingNodes(node, self = false, filter) { +function tree_getSiblingNodes(node, self, filter) { + var _a; + if (self === void 0) { self = false; } if (!node._parent || node._parent._children.size === 0) { return _emptyIterator(); } - return { - [Symbol.iterator]() { - let currentNode = node._parent ? node._parent._firstChild : null; + return _a = {}, + _a[Symbol.iterator] = function () { + var currentNode = node._parent ? node._parent._firstChild : null; return { - next() { + next: function () { while (currentNode && (filter && !filter(currentNode) || (!self && currentNode === node))) { currentNode = currentNode._nextSibling; } @@ -32001,14 +40210,14 @@ function tree_getSiblingNodes(node, self = false, filter) { return { done: true, value: null }; } else { - const result = { done: false, value: currentNode }; + var result = { done: false, value: currentNode }; currentNode = currentNode._nextSibling; return result; } } }; - } - }; + }, + _a; } exports.tree_getSiblingNodes = tree_getSiblingNodes; /** @@ -32018,8 +40227,9 @@ exports.tree_getSiblingNodes = tree_getSiblingNodes; * @param self - whether to include `node` in traversal * @param filter - a function to filter nodes */ -function tree_getFirstAncestorNode(node, self = false, filter) { - let firstNode = self ? node : node._parent; +function tree_getFirstAncestorNode(node, self, filter) { + if (self === void 0) { self = false; } + var firstNode = self ? node : node._parent; while (firstNode && filter && !filter(firstNode)) { firstNode = firstNode._parent; } @@ -32033,8 +40243,9 @@ exports.tree_getFirstAncestorNode = tree_getFirstAncestorNode; * @param self - whether to include `node` in traversal * @param filter - a function to filter nodes */ -function tree_getNextAncestorNode(node, currentNode, self = false, filter) { - let nextNode = currentNode._parent; +function tree_getNextAncestorNode(node, currentNode, self, filter) { + if (self === void 0) { self = false; } + var nextNode = currentNode._parent; while (nextNode && filter && !filter(nextNode)) { nextNode = nextNode._parent; } @@ -32048,27 +40259,29 @@ exports.tree_getNextAncestorNode = tree_getNextAncestorNode; * @param self - whether to include `node` in traversal * @param filter - a function to filter nodes */ -function tree_getAncestorNodes(node, self = false, filter) { +function tree_getAncestorNodes(node, self, filter) { + var _a; + if (self === void 0) { self = false; } if (!self && !node._parent) { return _emptyIterator(); } - return { - [Symbol.iterator]() { - let currentNode = tree_getFirstAncestorNode(node, self, filter); + return _a = {}, + _a[Symbol.iterator] = function () { + var currentNode = tree_getFirstAncestorNode(node, self, filter); return { - next() { + next: function () { if (currentNode === null) { return { done: true, value: null }; } else { - const result = { done: false, value: currentNode }; + var result = { done: false, value: currentNode }; currentNode = tree_getNextAncestorNode(node, currentNode, self, filter); return result; } } }; - } - }; + }, + _a; } exports.tree_getAncestorNodes = tree_getAncestorNodes; /** @@ -32082,25 +40295,25 @@ function tree_getCommonAncestor(nodeA, nodeB) { return nodeA._parent; } // lists of parent nodes - const parentsA = []; - const parentsB = []; - let pA = tree_getFirstAncestorNode(nodeA, true); + var parentsA = []; + var parentsB = []; + var pA = tree_getFirstAncestorNode(nodeA, true); while (pA !== null) { parentsA.push(pA); pA = tree_getNextAncestorNode(nodeA, pA, true); } - let pB = tree_getFirstAncestorNode(nodeB, true); + var pB = tree_getFirstAncestorNode(nodeB, true); while (pB !== null) { parentsB.push(pB); pB = tree_getNextAncestorNode(nodeB, pB, true); } // walk through parents backwards until they differ - let pos1 = parentsA.length; - let pos2 = parentsB.length; - let parent = null; - for (let i = Math.min(pos1, pos2); i > 0; i--) { - const parent1 = parentsA[--pos1]; - const parent2 = parentsB[--pos2]; + var pos1 = parentsA.length; + var pos2 = parentsB.length; + var parent = null; + for (var i = Math.min(pos1, pos2); i > 0; i--) { + var parent1 = parentsA[--pos1]; + var parent2 = parentsB[--pos2]; if (parent1 !== parent2) { break; } @@ -32124,7 +40337,7 @@ function tree_getFollowingNode(root, node) { } else { while (true) { - const parent = node._parent; + var parent = node._parent; if (parent === null || parent === root) { return null; } @@ -32184,44 +40397,65 @@ exports.tree_getPrecedingNode = tree_getPrecedingNode; * @param node - the root of the tree */ function tree_isConstrained(node) { + var e_1, _a, e_2, _b, e_3, _c; switch (node._nodeType) { case interfaces_1.NodeType.Document: - let hasDocType = false; - let hasElement = false; - for (const childNode of node._children) { - switch (childNode._nodeType) { - case interfaces_1.NodeType.ProcessingInstruction: - case interfaces_1.NodeType.Comment: - break; - case interfaces_1.NodeType.DocumentType: - if (hasDocType || hasElement) + var hasDocType = false; + var hasElement = false; + try { + for (var _d = __values(node._children), _e = _d.next(); !_e.done; _e = _d.next()) { + var childNode = _e.value; + switch (childNode._nodeType) { + case interfaces_1.NodeType.ProcessingInstruction: + case interfaces_1.NodeType.Comment: + break; + case interfaces_1.NodeType.DocumentType: + if (hasDocType || hasElement) + return false; + hasDocType = true; + break; + case interfaces_1.NodeType.Element: + if (hasElement) + return false; + hasElement = true; + break; + default: return false; - hasDocType = true; - break; - case interfaces_1.NodeType.Element: - if (hasElement) - return false; - hasElement = true; - break; - default: - return false; + } } } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_e && !_e.done && (_a = _d.return)) _a.call(_d); + } + finally { if (e_1) throw e_1.error; } + } break; case interfaces_1.NodeType.DocumentFragment: case interfaces_1.NodeType.Element: - for (const childNode of node._children) { - switch (childNode._nodeType) { - case interfaces_1.NodeType.Element: - case interfaces_1.NodeType.Text: - case interfaces_1.NodeType.ProcessingInstruction: - case interfaces_1.NodeType.CData: - case interfaces_1.NodeType.Comment: - break; - default: - return false; + try { + for (var _f = __values(node._children), _g = _f.next(); !_g.done; _g = _f.next()) { + var childNode = _g.value; + switch (childNode._nodeType) { + case interfaces_1.NodeType.Element: + case interfaces_1.NodeType.Text: + case interfaces_1.NodeType.ProcessingInstruction: + case interfaces_1.NodeType.CData: + case interfaces_1.NodeType.Comment: + break; + default: + return false; + } } } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_g && !_g.done && (_b = _f.return)) _b.call(_f); + } + finally { if (e_2) throw e_2.error; } + } break; case interfaces_1.NodeType.DocumentType: case interfaces_1.NodeType.Text: @@ -32230,10 +40464,20 @@ function tree_isConstrained(node) { case interfaces_1.NodeType.Comment: return (!node.hasChildNodes()); } - for (const childNode of node._children) { - // recursively check child nodes - if (!tree_isConstrained(childNode)) - return false; + try { + for (var _h = __values(node._children), _j = _h.next(); !_j.done; _j = _h.next()) { + var childNode = _j.value; + // recursively check child nodes + if (!tree_isConstrained(childNode)) + return false; + } + } + catch (e_3_1) { e_3 = { error: e_3_1 }; } + finally { + try { + if (_j && !_j.done && (_c = _h.return)) _c.call(_h); + } + finally { if (e_3) throw e_3.error; } } return true; } @@ -32288,14 +40532,15 @@ exports.tree_isEmpty = tree_isEmpty; * @param shadow - `true` to return shadow-including root, otherwise * `false` */ -function tree_rootNode(node, shadow = false) { +function tree_rootNode(node, shadow) { + if (shadow === void 0) { shadow = false; } /** * The root of an object is itself, if its parent is null, or else it is the * root of its parent. The root of a tree is any object participating in * that tree whose parent is null. */ if (shadow) { - const root = tree_rootNode(node, false); + var root = tree_rootNode(node, false); if (util_1.Guard.isShadowRoot(root)) return tree_rootNode(root._host, true); else @@ -32320,14 +40565,16 @@ exports.tree_rootNode = tree_rootNode; * @param shadow - if `true`, traversal includes the * node's and its descendant's shadow trees as well. */ -function tree_isDescendantOf(node, other, self = false, shadow = false) { +function tree_isDescendantOf(node, other, self, shadow) { + if (self === void 0) { self = false; } + if (shadow === void 0) { shadow = false; } /** * An object A is called a descendant of an object B, if either A is a * child of B or A is a child of an object C that is a descendant of B. * * An inclusive descendant is an object or one of its descendants. */ - let child = tree_getFirstDescendantNode(node, self, shadow); + var child = tree_getFirstDescendantNode(node, self, shadow); while (child !== null) { if (child === other) { return true; @@ -32348,8 +40595,10 @@ exports.tree_isDescendantOf = tree_isDescendantOf; * @param shadow - if `true`, traversal includes the * node's and its descendant's shadow trees as well. */ -function tree_isAncestorOf(node, other, self = false, shadow = false) { - let ancestor = self ? node : shadow && util_1.Guard.isShadowRoot(node) ? +function tree_isAncestorOf(node, other, self, shadow) { + if (self === void 0) { self = false; } + if (shadow === void 0) { shadow = false; } + var ancestor = self ? node : shadow && util_1.Guard.isShadowRoot(node) ? node._host : node._parent; while (ancestor !== null) { if (ancestor === other) @@ -32370,10 +40619,11 @@ exports.tree_isAncestorOf = tree_isAncestorOf; * @param other - the node to check * @param self - if `true`, traversal includes `node` itself */ -function tree_isHostIncludingAncestorOf(node, other, self = false) { +function tree_isHostIncludingAncestorOf(node, other, self) { + if (self === void 0) { self = false; } if (tree_isAncestorOf(node, other, self)) return true; - const root = tree_rootNode(node); + var root = tree_rootNode(node); if (util_1.Guard.isDocumentFragmentNode(root) && root._host !== null && tree_isHostIncludingAncestorOf(root._host, other, self)) return true; @@ -32389,7 +40639,8 @@ exports.tree_isHostIncludingAncestorOf = tree_isHostIncludingAncestorOf; * @param other - the node to check * @param self - if `true`, traversal includes `node` itself */ -function tree_isSiblingOf(node, other, self = false) { +function tree_isSiblingOf(node, other, self) { + if (self === void 0) { self = false; } /** * An object A is called a sibling of an object B, if and only if B and A * share the same non-null parent. @@ -32419,8 +40670,8 @@ function tree_isPreceding(node, other) { * An object A is preceding an object B if A and B are in the same tree and * A comes before B in tree order. */ - const nodePos = tree_treePosition(node); - const otherPos = tree_treePosition(other); + var nodePos = tree_treePosition(node); + var otherPos = tree_treePosition(other); if (nodePos === -1 || otherPos === -1) return false; else if (tree_rootNode(node) !== tree_rootNode(other)) @@ -32442,8 +40693,8 @@ function tree_isFollowing(node, other) { * An object A is following an object B if A and B are in the same tree and * A comes after B in tree order. */ - const nodePos = tree_treePosition(node); - const otherPos = tree_treePosition(other); + var nodePos = tree_treePosition(node); + var otherPos = tree_treePosition(other); if (nodePos === -1 || otherPos === -1) return false; else if (tree_rootNode(node) !== tree_rootNode(other)) @@ -32546,9 +40797,9 @@ exports.tree_lastChild = tree_lastChild; * @param node - the node to get the index of */ function tree_treePosition(node) { - const root = tree_rootNode(node); - let pos = 0; - let childNode = tree_getFirstDescendantNode(root); + var root = tree_rootNode(node); + var pos = 0; + var childNode = tree_getFirstDescendantNode(root); while (childNode !== null) { pos++; if (childNode === node) @@ -32570,7 +40821,7 @@ function tree_index(node) { * The index of an object is its number of preceding siblings, or 0 if it * has none. */ - let n = 0; + var n = 0; while (node._previousSibling !== null) { n++; node = node._previousSibling; @@ -32600,7 +40851,7 @@ function tree_retarget(a, b) { if (!a || !util_1.Guard.isNode(a)) { return a; } - const rootOfA = tree_rootNode(a); + var rootOfA = tree_rootNode(a); if (!util_1.Guard.isShadowRoot(rootOfA)) { return a; } @@ -32614,76 +40865,237 @@ exports.tree_retarget = tree_retarget; //# sourceMappingURL=TreeAlgorithm.js.map /***/ }), +/* 874 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 879: -/***/ (function(__unusedmodule, exports) { +const SemVer = __webpack_require__(65) +const compare = (a, b, loose) => + new SemVer(a, loose).compare(new SemVer(b, loose)) -"use strict"; +module.exports = compare -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents a cache for storing order between equal objects. - * - * This cache is used when an algorithm compares two objects and finds them to - * be equal but still needs to establish an order between those two objects. - * When two such objects `a` and `b` are passed to the `check` method, a random - * number is generated with `Math.random()`. If the random number is less than - * `0.5` it is assumed that `a < b` otherwise `a > b`. The random number along - * with `a` and `b` is stored in the cache, so that subsequent checks result - * in the same consistent result. - * - * The cache has a size limit which is defined on initialization. - */ -class CompareCache { - /** - * Initializes a new instance of `CompareCache`. - * - * @param limit - maximum number of items to keep in the cache. When the limit - * is exceeded the first item is removed from the cache. - */ - constructor(limit = 1000) { - this._items = new Map(); - this._limit = limit; - } - /** - * Compares and caches the given objects. Returns `true` if `objA < objB` and - * `false` otherwise. - * - * @param objA - an item to compare - * @param objB - an item to compare - */ - check(objA, objB) { - if (this._items.get(objA) === objB) - return true; - else if (this._items.get(objB) === objA) - return false; - const result = (Math.random() < 0.5); - if (result) { - this._items.set(objA, objB); - } - else { - this._items.set(objB, objA); - } - if (this._items.size > this._limit) { - const it = this._items.keys().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - return result; - } -} -exports.CompareCache = CompareCache; -//# sourceMappingURL=CompareCache.js.map /***/ }), +/* 875 */, +/* 876 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 884: +// just pre-load all the stuff that index.js lazily exports +const internalRe = __webpack_require__(976) +module.exports = { + re: internalRe.re, + src: internalRe.src, + tokens: internalRe.t, + SEMVER_SPEC_VERSION: __webpack_require__(181).SEMVER_SPEC_VERSION, + SemVer: __webpack_require__(65), + compareIdentifiers: __webpack_require__(954).compareIdentifiers, + rcompareIdentifiers: __webpack_require__(954).rcompareIdentifiers, + parse: __webpack_require__(830), + valid: __webpack_require__(714), + clean: __webpack_require__(503), + inc: __webpack_require__(928), + diff: __webpack_require__(822), + major: __webpack_require__(744), + minor: __webpack_require__(803), + patch: __webpack_require__(489), + prerelease: __webpack_require__(650), + compare: __webpack_require__(874), + rcompare: __webpack_require__(630), + compareLoose: __webpack_require__(283), + compareBuild: __webpack_require__(16), + sort: __webpack_require__(120), + rsort: __webpack_require__(593), + gt: __webpack_require__(486), + lt: __webpack_require__(586), + eq: __webpack_require__(298), + neq: __webpack_require__(85), + gte: __webpack_require__(167), + lte: __webpack_require__(898), + cmp: __webpack_require__(752), + coerce: __webpack_require__(499), + Comparator: __webpack_require__(536), + Range: __webpack_require__(124), + satisfies: __webpack_require__(310), + toComparators: __webpack_require__(219), + maxSatisfying: __webpack_require__(14), + minSatisfying: __webpack_require__(890), + minVersion: __webpack_require__(960), + validRange: __webpack_require__(480), + outside: __webpack_require__(881), + gtr: __webpack_require__(531), + ltr: __webpack_require__(323), + intersects: __webpack_require__(259), + simplifyRange: __webpack_require__(877), + subset: __webpack_require__(999), +} + + +/***/ }), +/* 877 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +// given a set of versions and a range, create a "simplified" range +// that includes the same versions that the original range does +// If the original range is shorter than the simplified one, return that. +const satisfies = __webpack_require__(310) +const compare = __webpack_require__(874) +module.exports = (versions, range, options) => { + const set = [] + let min = null + let prev = null + const v = versions.sort((a, b) => compare(a, b, options)) + for (const version of v) { + const included = satisfies(version, range, options) + if (included) { + prev = version + if (!min) + min = version + } else { + if (prev) { + set.push([min, prev]) + } + prev = null + min = null + } + } + if (min) + set.push([min, null]) + + const ranges = [] + for (const [min, max] of set) { + if (min === max) + ranges.push(min) + else if (!max && min === v[0]) + ranges.push('*') + else if (!max) + ranges.push(`>=${min}`) + else if (min === v[0]) + ranges.push(`<=${max}`) + else + ranges.push(`${min} - ${max}`) + } + const simplified = ranges.join(' || ') + const original = typeof range.raw === 'string' ? range.raw : String(range) + return simplified.length < original.length ? simplified : range +} + + +/***/ }), +/* 878 */, +/* 879 */, +/* 880 */, +/* 881 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const Comparator = __webpack_require__(536) +const {ANY} = Comparator +const Range = __webpack_require__(124) +const satisfies = __webpack_require__(310) +const gt = __webpack_require__(486) +const lt = __webpack_require__(586) +const lte = __webpack_require__(898) +const gte = __webpack_require__(167) + +const outside = (version, range, hilo, options) => { + version = new SemVer(version, options) + range = new Range(range, options) + + let gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case '>': + gtfn = gt + ltefn = lte + ltfn = lt + comp = '>' + ecomp = '>=' + break + case '<': + gtfn = lt + ltefn = gte + ltfn = gt + comp = '<' + ecomp = '<=' + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + + // If it satisfies the range it is not outside + if (satisfies(version, range, options)) { + return false + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for (let i = 0; i < range.set.length; ++i) { + const comparators = range.set[i] + + let high = null + let low = null + + comparators.forEach((comparator) => { + if (comparator.semver === ANY) { + comparator = new Comparator('>=0.0.0') + } + high = high || comparator + low = low || comparator + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator + } + }) + + // If the edge version comparator has a operator then our version + // isn't outside it + if (high.operator === comp || high.operator === ecomp) { + return false + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ((!low.operator || low.operator === comp) && + ltefn(version, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false + } + } + return true +} + +module.exports = outside + + +/***/ }), +/* 882 */, +/* 883 */, +/* 884 */ /***/ (function(__unusedmodule, exports, __webpack_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.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) { @@ -32693,14 +41105,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge step((generator = generator.apply(thisArg, _arguments || [])).next()); }); }; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; Object.defineProperty(exports, "__esModule", { value: true }); +exports.deleteKey = exports.importKey = exports.PRIVATE_KEY_FILE = void 0; const fs = __importStar(__webpack_require__(747)); const path = __importStar(__webpack_require__(622)); const io = __importStar(__webpack_require__(1)); @@ -32723,13 +41129,7 @@ function importKey(privateKey) { } } }; - yield exec.exec('gpg', [ - '--batch', - '--import-options', - 'import-show', - '--import', - exports.PRIVATE_KEY_FILE - ], options); + yield exec.exec('gpg', ['--batch', '--import-options', 'import-show', '--import', exports.PRIVATE_KEY_FILE], options); yield io.rmRF(exports.PRIVATE_KEY_FILE); const match = output.match(PRIVATE_KEY_FINGERPRINT_REGEX); return match && match[0]; @@ -32738,7 +41138,9 @@ function importKey(privateKey) { exports.importKey = importKey; function deleteKey(keyFingerprint) { return __awaiter(this, void 0, void 0, function* () { - yield exec.exec('gpg', ['--batch', '--yes', '--delete-secret-keys', keyFingerprint], { silent: true }); + yield exec.exec('gpg', ['--batch', '--yes', '--delete-secret-keys', keyFingerprint], { + silent: true + }); yield exec.exec('gpg', ['--batch', '--yes', '--delete-keys', keyFingerprint], { silent: true }); }); } @@ -32746,24 +41148,66 @@ exports.deleteKey = deleteKey; /***/ }), - -/***/ 889: +/* 885 */, +/* 886 */, +/* 887 */, +/* 888 */, +/* 889 */ /***/ (function(__unusedmodule, exports) { "use strict"; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); /** * Represents a cache of objects with a size limit. */ -class ObjectCache { +var ObjectCache = /** @class */ (function () { /** * Initializes a new instance of `ObjectCache`. * * @param limit - maximum number of items to keep in the cache. When the limit * is exceeded the first item is removed from the cache. */ - constructor(limit = 1000) { + function ObjectCache(limit) { + if (limit === void 0) { limit = 1000; } this._items = new Map(); this._limit = limit; } @@ -32772,141 +41216,252 @@ class ObjectCache { * * @param key - object key */ - get(key) { + ObjectCache.prototype.get = function (key) { return this._items.get(key); - } + }; /** * Adds a new item to the cache. * * @param key - object key * @param value - object value */ - set(key, value) { + ObjectCache.prototype.set = function (key, value) { this._items.set(key, value); if (this._items.size > this._limit) { - const it = this._items.keys().next(); + var it_1 = this._items.keys().next(); /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); + if (!it_1.done) { + this._items.delete(it_1.value); } } - } + }; /** * Removes an item from the cache. * * @param item - an item */ - delete(key) { + ObjectCache.prototype.delete = function (key) { return this._items.delete(key); - } + }; /** * Determines if an item is in the cache. * * @param item - an item */ - has(key) { + ObjectCache.prototype.has = function (key) { return this._items.has(key); - } + }; /** * Removes all items from the cache. */ - clear() { + ObjectCache.prototype.clear = function () { this._items.clear(); - } - /** - * Gets the number of items in the cache. - */ - get size() { return this._items.size; } + }; + Object.defineProperty(ObjectCache.prototype, "size", { + /** + * Gets the number of items in the cache. + */ + get: function () { return this._items.size; }, + enumerable: true, + configurable: true + }); /** * Applies the given callback function to all elements of the cache. */ - forEach(callback, thisArg) { - this._items.forEach((v, k) => callback.call(thisArg, k, v)); - } + ObjectCache.prototype.forEach = function (callback, thisArg) { + this._items.forEach(function (v, k) { return callback.call(thisArg, k, v); }); + }; /** * Iterates through the items in the set. */ - *keys() { - yield* this._items.keys(); - } + ObjectCache.prototype.keys = function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(this._items.keys())]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }; /** * Iterates through the items in the set. */ - *values() { - yield* this._items.values(); - } + ObjectCache.prototype.values = function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(this._items.values())]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }; /** * Iterates through the items in the set. */ - *entries() { - yield* this._items.entries(); - } + ObjectCache.prototype.entries = function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(this._items.entries())]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }; /** * Iterates through the items in the set. */ - *[Symbol.iterator]() { - yield* this._items; - } - /** - * Returns the string tag of the cache. - */ - get [Symbol.toStringTag]() { - return "ObjectCache"; - } -} + ObjectCache.prototype[Symbol.iterator] = function () { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [5 /*yield**/, __values(this._items)]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }; + Object.defineProperty(ObjectCache.prototype, Symbol.toStringTag, { + /** + * Returns the string tag of the cache. + */ + get: function () { + return "ObjectCache"; + }, + enumerable: true, + configurable: true + }); + return ObjectCache; +}()); exports.ObjectCache = ObjectCache; //# sourceMappingURL=ObjectCache.js.map /***/ }), +/* 890 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 904: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const Guard_1 = __webpack_require__(783); -/** - * Contains type casts for DOM objects. - */ -class Cast { - /** - * Casts the given object to a `Node`. - * - * @param a - the object to cast - */ - static asNode(a) { - if (Guard_1.Guard.isNode(a)) { - return a; - } - else { - throw new Error("Invalid object. Node expected."); - } +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) +const minSatisfying = (versions, range, options) => { + let min = null + let minSV = null + let rangeObj = null + try { + rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!min || minSV.compare(v) === 1) { + // compare(min, v, true) + min = v + minSV = new SemVer(min, options) + } } + }) + return min } -exports.Cast = Cast; -//# sourceMappingURL=Cast.js.map +module.exports = minSatisfying + /***/ }), +/* 891 */, +/* 892 */, +/* 893 */, +/* 894 */, +/* 895 */, +/* 896 */, +/* 897 */, +/* 898 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 911: +const compare = __webpack_require__(874) +const lte = (a, b, loose) => compare(a, b, loose) <= 0 +module.exports = lte + + +/***/ }), +/* 899 */, +/* 900 */, +/* 901 */, +/* 902 */, +/* 903 */, +/* 904 */, +/* 905 */, +/* 906 */, +/* 907 */, +/* 908 */, +/* 909 */, +/* 910 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; +// JS-YAML's default schema for `load` function. +// It is not described in the YAML specification. +// +// This schema is based on JS-YAML's default safe schema and includes +// JavaScript-specific types: !!js/undefined, !!js/regexp and !!js/function. +// +// Also this schema is used as default base schema at `Schema.create` function. + + + + + +var Schema = __webpack_require__(733); + + +module.exports = Schema.DEFAULT = new Schema({ + include: [ + __webpack_require__(723) + ], + explicit: [ + __webpack_require__(386), + __webpack_require__(629), + __webpack_require__(352) + ] +}); + + +/***/ }), +/* 911 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const interfaces_1 = __webpack_require__(172); +var interfaces_1 = __webpack_require__(172); /** * Represents a lexer for XML content in a string. */ -class XMLStringLexer { +var XMLStringLexer = /** @class */ (function () { /** * Initializes a new instance of `XMLStringLexer`. * * @param str - the string to tokenize and lex * @param options - lexer options */ - constructor(str, options) { + function XMLStringLexer(str, options) { this._options = { skipWhitespaceOnlyText: false }; @@ -32921,11 +41476,11 @@ class XMLStringLexer { /** * Returns the next token. */ - nextToken() { + XMLStringLexer.prototype.nextToken = function () { if (this.eof()) { return { type: interfaces_1.TokenType.EOF }; } - let token = (this.skipIfStartsWith('<') ? this.openBracket() : this.text()); + var token = (this.skipIfStartsWith('<') ? this.openBracket() : this.text()); if (this._options.skipWhitespaceOnlyText) { if (token.type === interfaces_1.TokenType.Text && XMLStringLexer.isWhiteSpaceToken(token)) { @@ -32933,11 +41488,11 @@ class XMLStringLexer { } } return token; - } + }; /** * Branches from an opening bracket (`<`). */ - openBracket() { + XMLStringLexer.prototype.openBracket = function () { if (this.skipIfStartsWith('?')) { if (this.skipIfStartsWith('xml')) { if (XMLStringLexer.isSpace(this._str[this._index])) { @@ -32973,14 +41528,14 @@ class XMLStringLexer { else { return this.openTag(); } - } + }; /** * Produces an XML declaration token. */ - declaration() { - let version = ''; - let encoding = ''; - let standalone = ''; + XMLStringLexer.prototype.declaration = function () { + var version = ''; + var encoding = ''; + var standalone = ''; while (!this.eof()) { this.skipSpace(); if (this.skipIfStartsWith('?>')) { @@ -32988,7 +41543,7 @@ class XMLStringLexer { } else { // attribute name - const [attName, attValue] = this.attribute(); + var _a = __read(this.attribute(), 2), attName = _a[0], attValue = _a[1]; if (attName === 'version') version = attValue; else if (attName === 'encoding') @@ -33000,16 +41555,16 @@ class XMLStringLexer { } } this.throwError('Missing declaration end symbol `?>`'); - } + }; /** * Produces a doc type token. */ - doctype() { - let pubId = ''; - let sysId = ''; + XMLStringLexer.prototype.doctype = function () { + var pubId = ''; + var sysId = ''; // name this.skipSpace(); - const name = this.takeUntil2('[', '>', true); + var name = this.takeUntil2('[', '>', true); this.skipSpace(); if (this.skipIfStartsWith('PUBLIC')) { pubId = this.quotedString(); @@ -33032,12 +41587,12 @@ class XMLStringLexer { this.throwError('Missing doctype end symbol `>`'); } return { type: interfaces_1.TokenType.DocType, name: name, pubId: pubId, sysId: sysId }; - } + }; /** * Produces a processing instruction token. */ - pi() { - const target = this.takeUntilStartsWith('?>', true); + XMLStringLexer.prototype.pi = function () { + var target = this.takeUntilStartsWith('?>', true); if (this.eof()) { this.throwError('Missing processing instruction end symbol `?>`'); } @@ -33045,52 +41600,52 @@ class XMLStringLexer { if (this.skipIfStartsWith('?>')) { return { type: interfaces_1.TokenType.PI, target: target, data: '' }; } - const data = this.takeUntilStartsWith('?>'); + var data = this.takeUntilStartsWith('?>'); if (this.eof()) { this.throwError('Missing processing instruction end symbol `?>`'); } this.seek(2); return { type: interfaces_1.TokenType.PI, target: target, data: data }; - } + }; /** * Produces a text token. * */ - text() { - const data = this.takeUntil('<'); + XMLStringLexer.prototype.text = function () { + var data = this.takeUntil('<'); return { type: interfaces_1.TokenType.Text, data: data }; - } + }; /** * Produces a comment token. * */ - comment() { - const data = this.takeUntilStartsWith('-->'); + XMLStringLexer.prototype.comment = function () { + var data = this.takeUntilStartsWith('-->'); if (this.eof()) { this.throwError('Missing comment end symbol `-->`'); } this.seek(3); return { type: interfaces_1.TokenType.Comment, data: data }; - } + }; /** * Produces a CDATA token. * */ - cdata() { - const data = this.takeUntilStartsWith(']]>'); + XMLStringLexer.prototype.cdata = function () { + var data = this.takeUntilStartsWith(']]>'); if (this.eof()) { this.throwError('Missing CDATA end symbol `]>`'); } this.seek(3); return { type: interfaces_1.TokenType.CDATA, data: data }; - } + }; /** * Produces an element token. */ - openTag() { + XMLStringLexer.prototype.openTag = function () { // element name this.skipSpace(); - const name = this.takeUntil2('>', '/', true); + var name = this.takeUntil2('>', '/', true); this.skipSpace(); if (this.skipIfStartsWith('>')) { return { type: interfaces_1.TokenType.Element, name: name, attributes: [], selfClosing: false }; @@ -33099,7 +41654,7 @@ class XMLStringLexer { return { type: interfaces_1.TokenType.Element, name: name, attributes: [], selfClosing: true }; } // attributes - const attributes = []; + var attributes = []; while (!this.eof()) { // end tag this.skipSpace(); @@ -33109,66 +41664,66 @@ class XMLStringLexer { else if (this.skipIfStartsWith('/>')) { return { type: interfaces_1.TokenType.Element, name: name, attributes: attributes, selfClosing: true }; } - const attr = this.attribute(); + var attr = this.attribute(); attributes.push(attr); } this.throwError('Missing opening element tag end symbol `>`'); - } + }; /** * Produces a closing tag token. * */ - closeTag() { + XMLStringLexer.prototype.closeTag = function () { this.skipSpace(); - const name = this.takeUntil('>', true); + var name = this.takeUntil('>', true); this.skipSpace(); if (!this.skipIfStartsWith('>')) { this.throwError('Missing closing element tag end symbol `>`'); } return { type: interfaces_1.TokenType.ClosingTag, name: name }; - } + }; /** * Reads an attribute name, value pair */ - attribute() { + XMLStringLexer.prototype.attribute = function () { // attribute name this.skipSpace(); - const name = this.takeUntil('=', true); + var name = this.takeUntil('=', true); this.skipSpace(); if (!this.skipIfStartsWith('=')) { this.throwError('Missing equals sign before attribute value'); } // attribute value - const value = this.quotedString(); + var value = this.quotedString(); return [name, value]; - } + }; /** * Reads a string between double or single quotes. */ - quotedString() { + XMLStringLexer.prototype.quotedString = function () { this.skipSpace(); - const startQuote = this.take(1); + var startQuote = this.take(1); if (!XMLStringLexer.isQuote(startQuote)) { this.throwError('Missing start quote character before quoted value'); } - const value = this.takeUntil(startQuote); + var value = this.takeUntil(startQuote); if (!this.skipIfStartsWith(startQuote)) { this.throwError('Missing end quote character after quoted value'); } return value; - } + }; /** * Determines if the current index is at or past the end of input string. */ - eof() { return this._index >= this._length; } + XMLStringLexer.prototype.eof = function () { return this._index >= this._length; }; /** * Skips the length of the given string if the string from current position * starts with the given string. * * @param str - the string to match */ - skipIfStartsWith(str) { - const strLength = str.length; + XMLStringLexer.prototype.skipIfStartsWith = function (str) { + var strLength = str.length; if (strLength === 1) { if (this._str[this._index] === str) { this._index++; @@ -33178,56 +41733,57 @@ class XMLStringLexer { return false; } } - for (let i = 0; i < strLength; i++) { + for (var i = 0; i < strLength; i++) { if (this._str[this._index + i] !== str[i]) return false; } this._index += strLength; return true; - } + }; /** * Seeks a number of character codes. * * @param count - number of characters to skip */ - seek(count) { + XMLStringLexer.prototype.seek = function (count) { this._index += count; if (this._index < 0) this._index = 0; if (this._index > this._length) this._index = this._length; - } + }; /** * Skips space characters. */ - skipSpace() { + XMLStringLexer.prototype.skipSpace = function () { while (!this.eof() && (XMLStringLexer.isSpace(this._str[this._index]))) { this._index++; } - } + }; /** * Takes a given number of characters. * * @param count - character count */ - take(count) { + XMLStringLexer.prototype.take = function (count) { if (count === 1) { return this._str[this._index++]; } - const startIndex = this._index; + var startIndex = this._index; this.seek(count); return this._str.slice(startIndex, this._index); - } + }; /** * Takes characters until the next character matches `char`. * * @param char - a character to match * @param space - whether a space character stops iteration */ - takeUntil(char, space = false) { - const startIndex = this._index; + XMLStringLexer.prototype.takeUntil = function (char, space) { + if (space === void 0) { space = false; } + var startIndex = this._index; while (this._index < this._length) { - const c = this._str[this._index]; + var c = this._str[this._index]; if (c !== char && (!space || !XMLStringLexer.isSpace(c))) { this._index++; } @@ -33236,7 +41792,7 @@ class XMLStringLexer { } } return this._str.slice(startIndex, this._index); - } + }; /** * Takes characters until the next character matches `char1` or `char1`. * @@ -33244,10 +41800,11 @@ class XMLStringLexer { * @param char2 - a character to match * @param space - whether a space character stops iteration */ - takeUntil2(char1, char2, space = false) { - const startIndex = this._index; + XMLStringLexer.prototype.takeUntil2 = function (char1, char2, space) { + if (space === void 0) { space = false; } + var startIndex = this._index; while (this._index < this._length) { - const c = this._str[this._index]; + var c = this._str[this._index]; if (c !== char1 && c !== char2 && (!space || !XMLStringLexer.isSpace(c))) { this._index++; } @@ -33256,21 +41813,22 @@ class XMLStringLexer { } } return this._str.slice(startIndex, this._index); - } + }; /** * Takes characters until the next characters matches `str`. * * @param str - a string to match * @param space - whether a space character stops iteration */ - takeUntilStartsWith(str, space = false) { - const startIndex = this._index; - const strLength = str.length; + XMLStringLexer.prototype.takeUntilStartsWith = function (str, space) { + if (space === void 0) { space = false; } + var startIndex = this._index; + var strLength = str.length; while (this._index < this._length) { - let match = true; - for (let i = 0; i < strLength; i++) { - const c = this._str[this._index + i]; - const char = str[i]; + var match = true; + for (var i = 0; i < strLength; i++) { + var c = this._str[this._index + i]; + var char = str[i]; if (space && XMLStringLexer.isSpace(c)) { return this._str.slice(startIndex, this._index); } @@ -33285,15 +41843,15 @@ class XMLStringLexer { } this._index = this._length; return this._str.slice(startIndex); - } + }; /** * Skips characters until the next character matches `char`. * * @param char - a character to match */ - skipUntil(char) { + XMLStringLexer.prototype.skipUntil = function (char) { while (this._index < this._length) { - const c = this._str[this._index]; + var c = this._str[this._index]; if (c !== char) { this._index++; } @@ -33301,49 +41859,49 @@ class XMLStringLexer { break; } } - } + }; /** * Determines if the given token is entirely whitespace. * * @param token - the token to check */ - static isWhiteSpaceToken(token) { - const str = token.data; - for (let i = 0; i < str.length; i++) { - const c = str[i]; + XMLStringLexer.isWhiteSpaceToken = function (token) { + var str = token.data; + for (var i = 0; i < str.length; i++) { + var c = str[i]; if (c !== ' ' && c !== '\n' && c !== '\r' && c !== '\t' && c !== '\f') return false; } return true; - } + }; /** * Determines if the given character is whitespace. * * @param char - the character to check */ - static isSpace(char) { + XMLStringLexer.isSpace = function (char) { return char === ' ' || char === '\n' || char === '\r' || char === '\t'; - } + }; /** * Determines if the given character is a quote character. * * @param char - the character to check */ - static isQuote(char) { + XMLStringLexer.isQuote = function (char) { return (char === '"' || char === '\''); - } + }; /** * Throws a parser error and records the line and column numbers in the parsed * string. * * @param msg - error message */ - throwError(msg) { - const regexp = /\r\n|\r|\n/g; - let match = null; - let line = 0; - let firstNewLineIndex = 0; - let lastNewlineIndex = this._str.length; + XMLStringLexer.prototype.throwError = function (msg) { + var regexp = /\r\n|\r|\n/g; + var match = null; + var line = 0; + var firstNewLineIndex = 0; + var lastNewlineIndex = this._str.length; while ((match = regexp.exec(this._str)) !== null) { if (match === null) break; @@ -33364,15 +41922,15 @@ class XMLStringLexer { throw new Error(msg + "\nIndex: " + this.err.index + "\nLn: " + this.err.line + ", Col: " + this.err.col + "\nInput: " + this.err.str); - } + }; /** * Returns an iterator for the lexer. */ - [Symbol.iterator]() { + XMLStringLexer.prototype[Symbol.iterator] = function () { this._index = 0; return { next: function () { - const token = this.nextToken(); + var token = this.nextToken(); if (token.type === interfaces_1.TokenType.EOF) { return { done: true, value: null }; } @@ -33381,14 +41939,162 @@ class XMLStringLexer { } }.bind(this) }; - } -} + }; + return XMLStringLexer; +}()); exports.XMLStringLexer = XMLStringLexer; //# sourceMappingURL=XMLStringLexer.js.map /***/ }), +/* 912 */, +/* 913 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 916: +"use strict"; + + +/*eslint-disable no-bitwise*/ + +var NodeBuffer; + +try { + // A trick for browserified version, to not include `Buffer` shim + var _require = require; + NodeBuffer = _require('buffer').Buffer; +} catch (__) {} + +var Type = __webpack_require__(945); + + +// [ 64, 65, 66 ] -> [ padding, CR, LF ] +var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r'; + + +function resolveYamlBinary(data) { + if (data === null) return false; + + var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP; + + // Convert one by one. + for (idx = 0; idx < max; idx++) { + code = map.indexOf(data.charAt(idx)); + + // Skip CR/LF + if (code > 64) continue; + + // Fail on illegal characters + if (code < 0) return false; + + bitlen += 6; + } + + // If there are any bits left, source was corrupted + return (bitlen % 8) === 0; +} + +function constructYamlBinary(data) { + var idx, tailbits, + input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan + max = input.length, + map = BASE64_MAP, + bits = 0, + result = []; + + // Collect by 6*4 bits (3 bytes) + + for (idx = 0; idx < max; idx++) { + if ((idx % 4 === 0) && idx) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } + + bits = (bits << 6) | map.indexOf(input.charAt(idx)); + } + + // Dump tail + + tailbits = (max % 4) * 6; + + if (tailbits === 0) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } else if (tailbits === 18) { + result.push((bits >> 10) & 0xFF); + result.push((bits >> 2) & 0xFF); + } else if (tailbits === 12) { + result.push((bits >> 4) & 0xFF); + } + + // Wrap into Buffer for NodeJS and leave Array for browser + if (NodeBuffer) { + // Support node 6.+ Buffer API when available + return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result); + } + + return result; +} + +function representYamlBinary(object /*, style*/) { + var result = '', bits = 0, idx, tail, + max = object.length, + map = BASE64_MAP; + + // Convert every three bytes to 4 ASCII characters. + + for (idx = 0; idx < max; idx++) { + if ((idx % 3 === 0) && idx) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } + + bits = (bits << 8) + object[idx]; + } + + // Dump tail + + tail = max % 3; + + if (tail === 0) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } else if (tail === 2) { + result += map[(bits >> 10) & 0x3F]; + result += map[(bits >> 4) & 0x3F]; + result += map[(bits << 2) & 0x3F]; + result += map[64]; + } else if (tail === 1) { + result += map[(bits >> 2) & 0x3F]; + result += map[(bits << 4) & 0x3F]; + result += map[64]; + result += map[64]; + } + + return result; +} + +function isBinary(object) { + return NodeBuffer && NodeBuffer.isBuffer(object); +} + +module.exports = new Type('tag:yaml.org,2002:binary', { + kind: 'scalar', + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary +}); + + +/***/ }), +/* 914 */, +/* 915 */, +/* 916 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -33403,14 +42109,14 @@ exports.XLink = "http://www.w3.org/1999/xlink"; //# sourceMappingURL=Namespace.js.map /***/ }), - -/***/ 918: +/* 917 */, +/* 918 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -var Cast_1 = __webpack_require__(904); +var Cast_1 = __webpack_require__(533); exports.Cast = Cast_1.Cast; var Guard_1 = __webpack_require__(783); exports.Guard = Guard_1.Guard; @@ -33419,27 +42125,41 @@ exports.EmptySet = EmptySet_1.EmptySet; //# sourceMappingURL=index.js.map /***/ }), - -/***/ 920: +/* 919 */, +/* 920 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const TextImpl_1 = __webpack_require__(820); -const interfaces_1 = __webpack_require__(970); -const WebIDLAlgorithm_1 = __webpack_require__(495); +var TextImpl_1 = __webpack_require__(820); +var interfaces_1 = __webpack_require__(970); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** * Represents a CDATA node. */ -class CDATASectionImpl extends TextImpl_1.TextImpl { +var CDATASectionImpl = /** @class */ (function (_super) { + __extends(CDATASectionImpl, _super); /** * Initializes a new instance of `CDATASection`. * * @param data - node contents */ - constructor(data) { - super(data); + function CDATASectionImpl(data) { + return _super.call(this, data) || this; } /** * Creates a new `CDATASection`. @@ -33447,12 +42167,14 @@ class CDATASectionImpl extends TextImpl_1.TextImpl { * @param document - owner document * @param data - node contents */ - static _create(document, data = '') { - const node = new CDATASectionImpl(data); + CDATASectionImpl._create = function (document, data) { + if (data === void 0) { data = ''; } + var node = new CDATASectionImpl(data); node._nodeDocument = document; return node; - } -} + }; + return CDATASectionImpl; +}(TextImpl_1.TextImpl)); exports.CDATASectionImpl = CDATASectionImpl; /** * Initialize prototype properties @@ -33461,553 +42183,448 @@ WebIDLAlgorithm_1.idl_defineConst(CDATASectionImpl.prototype, "_nodeType", inter //# sourceMappingURL=CDATASectionImpl.js.map /***/ }), - -/***/ 923: -/***/ (function(__unusedmodule, exports, __webpack_require__) { +/* 921 */ +/***/ (function(module, __unusedexports, __webpack_require__) { "use strict"; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const core = __importStar(__webpack_require__(470)); -const io = __importStar(__webpack_require__(1)); -const exec = __importStar(__webpack_require__(986)); -const httpm = __importStar(__webpack_require__(539)); -const tc = __importStar(__webpack_require__(533)); -const fs = __importStar(__webpack_require__(747)); -const path = __importStar(__webpack_require__(622)); -const semver = __importStar(__webpack_require__(280)); -const util = __importStar(__webpack_require__(322)); -const tempDirectory = util.getTempDir(); -const IS_WINDOWS = util.isWindows(); -function getJava(version, arch, jdkFile, javaPackage) { - return __awaiter(this, void 0, void 0, function* () { - let toolPath = tc.find(javaPackage, version); - if (toolPath) { - core.debug(`Tool found in cache ${toolPath}`); - } - else { - let compressedFileExtension = ''; - if (!jdkFile) { - core.debug('Downloading JDK from Azul'); - const http = new httpm.HttpClient('setup-java', undefined, { - allowRetries: true, - maxRetries: 3 - }); - const url = 'https://static.azul.com/zulu/bin/'; - const response = yield http.get(url); - const statusCode = response.message.statusCode || 0; - if (statusCode < 200 || statusCode > 299) { - let body = ''; - try { - body = yield response.readBody(); - } - catch (err) { - core.debug(`Unable to read body: ${err.message}`); - } - const message = `Unexpected HTTP status code '${response.message.statusCode}' when retrieving versions from '${url}'. ${body}`.trim(); - throw new Error(message); - } - const contents = yield response.readBody(); - const refs = contents.match(//gi) || []; - const downloadInfo = getDownloadInfo(refs, version, arch, javaPackage); - jdkFile = yield tc.downloadTool(downloadInfo.url); - version = downloadInfo.version; - compressedFileExtension = IS_WINDOWS ? '.zip' : '.tar.gz'; - } - else { - core.debug('Retrieving Jdk from local path'); - } - compressedFileExtension = compressedFileExtension || getFileEnding(jdkFile); - let tempDir = path.join(tempDirectory, 'temp_' + Math.floor(Math.random() * 2000000000)); - const jdkDir = yield unzipJavaDownload(jdkFile, compressedFileExtension, tempDir); - core.debug(`jdk extracted to ${jdkDir}`); - toolPath = yield tc.cacheDir(jdkDir, javaPackage, getCacheVersionString(version), arch); - } - let extendedJavaHome = 'JAVA_HOME_' + version + '_' + arch; - core.exportVariable(extendedJavaHome, toolPath); //TODO: remove for v2 - // For portability reasons environment variables should only consist of - // uppercase letters, digits, and the underscore. Therefore we convert - // the extendedJavaHome variable to upper case and replace '.' symbols and - // any other non-alphanumeric characters with an underscore. - extendedJavaHome = extendedJavaHome.toUpperCase().replace(/[^0-9A-Z_]/g, '_'); - core.exportVariable('JAVA_HOME', toolPath); - core.exportVariable(extendedJavaHome, toolPath); - core.addPath(path.join(toolPath, 'bin')); - core.setOutput('path', toolPath); - core.setOutput('version', version); - }); -} -exports.getJava = getJava; -function getCacheVersionString(version) { - const versionArray = version.split('.'); - const major = versionArray[0]; - const minor = versionArray.length > 1 ? versionArray[1] : '0'; - const patch = versionArray.length > 2 ? versionArray[2] : '0'; - return `${major}.${minor}.${patch}`; -} -function getFileEnding(file) { - let fileEnding = ''; - if (file.endsWith('.tar')) { - fileEnding = '.tar'; - } - else if (file.endsWith('.tar.gz')) { - fileEnding = '.tar.gz'; - } - else if (file.endsWith('.zip')) { - fileEnding = '.zip'; - } - else if (file.endsWith('.7z')) { - fileEnding = '.7z'; - } - else { - throw new Error(`${file} has an unsupported file extension`); - } - return fileEnding; -} -function extractFiles(file, fileEnding, destinationFolder) { - return __awaiter(this, void 0, void 0, function* () { - const stats = fs.statSync(file); - if (!stats) { - throw new Error(`Failed to extract ${file} - it doesn't exist`); - } - else if (stats.isDirectory()) { - throw new Error(`Failed to extract ${file} - it is a directory`); - } - if ('.tar' === fileEnding || '.tar.gz' === fileEnding) { - yield tc.extractTar(file, destinationFolder); - } - else if ('.zip' === fileEnding) { - yield tc.extractZip(file, destinationFolder); - } - else { - // fall through and use sevenZip - yield tc.extract7z(file, destinationFolder); - } - }); -} -// This method recursively finds all .pack files under fsPath and unpacks them with the unpack200 tool -function unpackJars(fsPath, javaBinPath) { - return __awaiter(this, void 0, void 0, function* () { - if (fs.existsSync(fsPath)) { - if (fs.lstatSync(fsPath).isDirectory()) { - for (const file in fs.readdirSync(fsPath)) { - const curPath = path.join(fsPath, file); - yield unpackJars(curPath, javaBinPath); - } - } - else if (path.extname(fsPath).toLowerCase() === '.pack') { - // Unpack the pack file synchonously - const p = path.parse(fsPath); - const toolName = IS_WINDOWS ? 'unpack200.exe' : 'unpack200'; - const args = IS_WINDOWS ? '-r -v -l ""' : ''; - const name = path.join(p.dir, p.name); - yield exec.exec(`"${path.join(javaBinPath, toolName)}"`, [ - `${args} "${name}.pack" "${name}.jar"` - ]); - } - } - }); -} -function unzipJavaDownload(repoRoot, fileEnding, destinationFolder, extension) { - return __awaiter(this, void 0, void 0, function* () { - // Create the destination folder if it doesn't exist - yield io.mkdirP(destinationFolder); - const jdkFile = path.normalize(repoRoot); - const stats = fs.statSync(jdkFile); - if (stats.isFile()) { - yield extractFiles(jdkFile, fileEnding, destinationFolder); - const jdkDirectory = path.join(destinationFolder, fs.readdirSync(destinationFolder)[0]); - yield unpackJars(jdkDirectory, path.join(jdkDirectory, 'bin')); - return jdkDirectory; - } - else { - throw new Error(`Jdk argument ${jdkFile} is not a file`); - } - }); -} -function getDownloadInfo(refs, version, arch, javaPackage) { - version = normalizeVersion(version); - const archExtension = arch === 'x86' ? 'i686' : 'x64'; - let extension = ''; - if (IS_WINDOWS) { - extension = `-win_${archExtension}.zip`; - } - else { - if (process.platform === 'darwin') { - extension = `-macosx_${archExtension}.tar.gz`; - } - else { - extension = `-linux_${archExtension}.tar.gz`; - } - } - core.debug(`Searching for files with extension: ${extension}`); - let pkgRegexp = new RegExp(''); - let pkgTypeLength = 0; - if (javaPackage === 'jdk') { - pkgRegexp = /jdk.*-/gi; - pkgTypeLength = 'jdk'.length; - } - else if (javaPackage == 'jre') { - pkgRegexp = /jre.*-/gi; - pkgTypeLength = 'jre'.length; - } - else if (javaPackage == 'jdk+fx') { - pkgRegexp = /fx-jdk.*-/gi; - pkgTypeLength = 'fx-jdk'.length; - } - else { - throw new Error(`package argument ${javaPackage} is not in [jdk | jre | jdk+fx]`); - } - // Maps version to url - let versionMap = new Map(); - // Filter by platform - refs.forEach(ref => { - if (!ref.endsWith(extension + '">')) { - return; - } - // If we haven't returned, means we're looking at the correct platform - let versions = ref.match(pkgRegexp) || []; - if (versions.length > 1) { - throw new Error(`Invalid ref received from https://static.azul.com/zulu/bin/: ${ref}`); - } - if (versions.length == 0) { - return; - } - const refVersion = versions[0].slice(pkgTypeLength, versions[0].length - 1); - if (semver.satisfies(refVersion, version)) { - versionMap.set(refVersion, 'https://static.azul.com/zulu/bin/' + - ref.slice(''.length)); - } - }); - // Choose the most recent satisfying version - let curVersion = '0.0.0'; - let curUrl = ''; - for (const entry of versionMap.entries()) { - const entryVersion = entry[0]; - const entryUrl = entry[1]; - if (semver.gt(entryVersion, curVersion)) { - curUrl = entryUrl; - curVersion = entryVersion; - } - } - if (curUrl == '') { - throw new Error(`No valid download found for version ${version} and package ${javaPackage}. Check https://static.azul.com/zulu/bin/ for a list of valid versions or download your own jdk file and add the jdkFile argument`); - } - return { version: curVersion, url: curUrl }; -} -function normalizeVersion(version) { - if (version.slice(0, 2) === '1.') { - // Trim leading 1. for versions like 1.8 - version = version.slice(2); - if (!version) { - throw new Error('1. is not a valid version'); - } - } - if (version.endsWith('-ea')) { - // convert e.g. 14-ea to 14.0.0-ea - if (version.indexOf('.') == -1) { - version = version.slice(0, version.length - 3) + '.0.0-ea'; - } - // match anything in -ea.X (semver won't do .x matching on pre-release versions) - if (version[0] >= '0' && version[0] <= '9') { - version = '>=' + version; - } - } - else if (version.split('.').length < 3) { - // For non-ea versions, add trailing .x if it is missing - if (version[version.length - 1] != 'x') { - version = version + '.x'; - } - } - return version; -} + +var Type = __webpack_require__(945); + +module.exports = new Type('tag:yaml.org,2002:seq', { + kind: 'sequence', + construct: function (data) { return data !== null ? data : []; } +}); /***/ }), +/* 922 */, +/* 923 */, +/* 924 */, +/* 925 */, +/* 926 */, +/* 927 */, +/* 928 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 932: +const SemVer = __webpack_require__(65) + +const inc = (version, release, options, identifier) => { + if (typeof (options) === 'string') { + identifier = options + options = undefined + } + + try { + return new SemVer(version, options).inc(release, identifier).version + } catch (er) { + return null + } +} +module.exports = inc + + +/***/ }), +/* 929 */, +/* 930 */, +/* 931 */, +/* 932 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -const EventTargetImpl_1 = __webpack_require__(597); -const util_1 = __webpack_require__(337); -const algorithm_1 = __webpack_require__(163); +var EventTargetImpl_1 = __webpack_require__(597); +var util_1 = __webpack_require__(592); +var algorithm_1 = __webpack_require__(163); /** * Represents a window containing a DOM document. */ -class WindowImpl extends EventTargetImpl_1.EventTargetImpl { +var WindowImpl = /** @class */ (function (_super) { + __extends(WindowImpl, _super); /** * Initializes a new instance of `Window`. */ - constructor() { - super(); - this._signalSlots = new Set(); - this._mutationObserverMicrotaskQueued = false; - this._mutationObservers = new Set(); - this._iteratorList = new util_1.FixedSizeSet(); - this._associatedDocument = algorithm_1.create_document(); + function WindowImpl() { + var _this = _super.call(this) || this; + _this._signalSlots = new Set(); + _this._mutationObserverMicrotaskQueued = false; + _this._mutationObservers = new Set(); + _this._iteratorList = new util_1.FixedSizeSet(); + _this._associatedDocument = algorithm_1.create_document(); + return _this; } - /** @inheritdoc */ - get document() { return this._associatedDocument; } - /** @inheritdoc */ - get event() { return this._currentEvent; } + Object.defineProperty(WindowImpl.prototype, "document", { + /** @inheritdoc */ + get: function () { return this._associatedDocument; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(WindowImpl.prototype, "event", { + /** @inheritdoc */ + get: function () { return this._currentEvent; }, + enumerable: true, + configurable: true + }); /** * Creates a new window with a blank document. */ - static _create() { + WindowImpl._create = function () { return new WindowImpl(); - } -} + }; + return WindowImpl; +}(EventTargetImpl_1.EventTargetImpl)); exports.WindowImpl = WindowImpl; //# sourceMappingURL=WindowImpl.js.map /***/ }), - -/***/ 934: +/* 933 */, +/* 934 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(918); -const algorithm_1 = __webpack_require__(163); +var util_1 = __webpack_require__(918); +var algorithm_1 = __webpack_require__(163); /** * Represents a mixin that extends parent nodes that can have children. * This mixin is implemented by {@link Element}, {@link Document} and * {@link DocumentFragment}. */ -class ParentNodeImpl { - /** @inheritdoc */ - get children() { - /** - * The children attribute’s getter must return an HTMLCollection collection - * rooted at context object matching only element children. - */ - return algorithm_1.create_htmlCollection(util_1.Cast.asNode(this)); +var ParentNodeImpl = /** @class */ (function () { + function ParentNodeImpl() { } + Object.defineProperty(ParentNodeImpl.prototype, "children", { + /** @inheritdoc */ + get: function () { + /** + * The children attribute’s getter must return an HTMLCollection collection + * rooted at context object matching only element children. + */ + return algorithm_1.create_htmlCollection(util_1.Cast.asNode(this)); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParentNodeImpl.prototype, "firstElementChild", { + /** @inheritdoc */ + get: function () { + /** + * The firstElementChild attribute’s getter must return the first child + * that is an element, and null otherwise. + */ + var node = util_1.Cast.asNode(this)._firstChild; + while (node) { + if (util_1.Guard.isElementNode(node)) + return node; + else + node = node._nextSibling; + } + return null; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParentNodeImpl.prototype, "lastElementChild", { + /** @inheritdoc */ + get: function () { + /** + * The lastElementChild attribute’s getter must return the last child that + * is an element, and null otherwise. + */ + var node = util_1.Cast.asNode(this)._lastChild; + while (node) { + if (util_1.Guard.isElementNode(node)) + return node; + else + node = node._previousSibling; + } + return null; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParentNodeImpl.prototype, "childElementCount", { + /** @inheritdoc */ + get: function () { + var e_1, _a; + /** + * The childElementCount attribute’s getter must return the number of + * children of context object that are elements. + */ + var count = 0; + try { + for (var _b = __values(util_1.Cast.asNode(this)._children), _c = _b.next(); !_c.done; _c = _b.next()) { + var childNode = _c.value; + if (util_1.Guard.isElementNode(childNode)) + count++; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + return count; + }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get firstElementChild() { - /** - * The firstElementChild attribute’s getter must return the first child - * that is an element, and null otherwise. - */ - let node = util_1.Cast.asNode(this)._firstChild; - while (node) { - if (util_1.Guard.isElementNode(node)) - return node; - else - node = node._nextSibling; + ParentNodeImpl.prototype.prepend = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; } - return null; - } - /** @inheritdoc */ - get lastElementChild() { - /** - * The lastElementChild attribute’s getter must return the last child that - * is an element, and null otherwise. - */ - let node = util_1.Cast.asNode(this)._lastChild; - while (node) { - if (util_1.Guard.isElementNode(node)) - return node; - else - node = node._previousSibling; - } - return null; - } - /** @inheritdoc */ - get childElementCount() { - /** - * The childElementCount attribute’s getter must return the number of - * children of context object that are elements. - */ - let count = 0; - for (const childNode of util_1.Cast.asNode(this)._children) { - if (util_1.Guard.isElementNode(childNode)) - count++; - } - return count; - } - /** @inheritdoc */ - prepend(...nodes) { /** * 1. Let node be the result of converting nodes into a node given nodes * and context object’s node document. * 2. Pre-insert node into context object before the context object’s first * child. */ - const node = util_1.Cast.asNode(this); - const childNode = algorithm_1.parentNode_convertNodesIntoANode(nodes, node._nodeDocument); + var node = util_1.Cast.asNode(this); + var childNode = algorithm_1.parentNode_convertNodesIntoANode(nodes, node._nodeDocument); algorithm_1.mutation_preInsert(childNode, node, node._firstChild); - } + }; /** @inheritdoc */ - append(...nodes) { + ParentNodeImpl.prototype.append = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } /** * 1. Let node be the result of converting nodes into a node given nodes * and context object’s node document. * 2. Append node to context object. */ - const node = util_1.Cast.asNode(this); - const childNode = algorithm_1.parentNode_convertNodesIntoANode(nodes, node._nodeDocument); + var node = util_1.Cast.asNode(this); + var childNode = algorithm_1.parentNode_convertNodesIntoANode(nodes, node._nodeDocument); algorithm_1.mutation_append(childNode, node); - } + }; /** @inheritdoc */ - querySelector(selectors) { + ParentNodeImpl.prototype.querySelector = function (selectors) { /** * The querySelector(selectors) method, when invoked, must return the first * result of running scope-match a selectors string selectors against * context object, if the result is not an empty list, and null otherwise. */ - const node = util_1.Cast.asNode(this); - const result = algorithm_1.selectors_scopeMatchASelectorsString(selectors, node); + var node = util_1.Cast.asNode(this); + var result = algorithm_1.selectors_scopeMatchASelectorsString(selectors, node); return (result.length === 0 ? null : result[0]); - } + }; /** @inheritdoc */ - querySelectorAll(selectors) { + ParentNodeImpl.prototype.querySelectorAll = function (selectors) { /** * The querySelectorAll(selectors) method, when invoked, must return the * static result of running scope-match a selectors string selectors against * context object. */ - const node = util_1.Cast.asNode(this); - const result = algorithm_1.selectors_scopeMatchASelectorsString(selectors, node); + var node = util_1.Cast.asNode(this); + var result = algorithm_1.selectors_scopeMatchASelectorsString(selectors, node); return algorithm_1.create_nodeListStatic(node, result); - } -} + }; + return ParentNodeImpl; +}()); exports.ParentNodeImpl = ParentNodeImpl; //# sourceMappingURL=ParentNodeImpl.js.map /***/ }), - -/***/ 935: +/* 935 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +}; Object.defineProperty(exports, "__esModule", { value: true }); -const _1 = __webpack_require__(113); -const interfaces_1 = __webpack_require__(970); -const EventTargetImpl_1 = __webpack_require__(597); -const util_1 = __webpack_require__(918); -const DOMException_1 = __webpack_require__(35); -const algorithm_1 = __webpack_require__(163); -const URLAlgorithm_1 = __webpack_require__(813); -const WebIDLAlgorithm_1 = __webpack_require__(495); +var DOMImpl_1 = __webpack_require__(648); +var interfaces_1 = __webpack_require__(970); +var EventTargetImpl_1 = __webpack_require__(597); +var util_1 = __webpack_require__(918); +var DOMException_1 = __webpack_require__(35); +var algorithm_1 = __webpack_require__(163); +var URLAlgorithm_1 = __webpack_require__(813); +var WebIDLAlgorithm_1 = __webpack_require__(495); /** * Represents a generic XML node. */ -class NodeImpl extends EventTargetImpl_1.EventTargetImpl { +var NodeImpl = /** @class */ (function (_super) { + __extends(NodeImpl, _super); /** * Initializes a new instance of `Node`. */ - constructor() { - super(); - this._parent = null; - this._firstChild = null; - this._lastChild = null; - this._previousSibling = null; - this._nextSibling = null; + function NodeImpl() { + var _this = _super.call(this) || this; + _this._parent = null; + _this._firstChild = null; + _this._lastChild = null; + _this._previousSibling = null; + _this._nextSibling = null; + return _this; } - get _childNodes() { - return this.__childNodes || (this.__childNodes = algorithm_1.create_nodeList(this)); - } - get _nodeDocument() { return this._nodeDocumentOverride || _1.dom.window._associatedDocument; } - set _nodeDocument(val) { this._nodeDocumentOverride = val; } - get _registeredObserverList() { - return this.__registeredObserverList || (this.__registeredObserverList = []); - } - /** @inheritdoc */ - get nodeType() { return this._nodeType; } - /** - * Returns a string appropriate for the type of node. - */ - get nodeName() { - if (util_1.Guard.isElementNode(this)) { - return this._htmlUppercasedQualifiedName; - } - else if (util_1.Guard.isAttrNode(this)) { - return this._qualifiedName; - } - else if (util_1.Guard.isExclusiveTextNode(this)) { - return "#text"; - } - else if (util_1.Guard.isCDATASectionNode(this)) { - return "#cdata-section"; - } - else if (util_1.Guard.isProcessingInstructionNode(this)) { - return this._target; - } - else if (util_1.Guard.isCommentNode(this)) { - return "#comment"; - } - else if (util_1.Guard.isDocumentNode(this)) { - return "#document"; - } - else if (util_1.Guard.isDocumentTypeNode(this)) { - return this._name; - } - else if (util_1.Guard.isDocumentFragmentNode(this)) { - return "#document-fragment"; - } - else { - return ""; - } - } - /** - * Gets the absolute base URL of the node. - */ - get baseURI() { + Object.defineProperty(NodeImpl.prototype, "_childNodes", { + get: function () { + return this.__childNodes || (this.__childNodes = algorithm_1.create_nodeList(this)); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "_nodeDocument", { + get: function () { return this._nodeDocumentOverride || DOMImpl_1.dom.window._associatedDocument; }, + set: function (val) { this._nodeDocumentOverride = val; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "_registeredObserverList", { + get: function () { + return this.__registeredObserverList || (this.__registeredObserverList = []); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "nodeType", { + /** @inheritdoc */ + get: function () { return this._nodeType; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "nodeName", { /** - * The baseURI attribute’s getter must return node document’s document - * base URL, serialized. - * TODO: Implement in HTML DOM - * https://html.spec.whatwg.org/multipage/urls-and-fetching.html#document-base-url + * Returns a string appropriate for the type of node. */ - return URLAlgorithm_1.urlSerializer(this._nodeDocument._URL); - } - /** - * Returns whether the node is rooted to a document node. - */ - get isConnected() { + get: function () { + if (util_1.Guard.isElementNode(this)) { + return this._htmlUppercasedQualifiedName; + } + else if (util_1.Guard.isAttrNode(this)) { + return this._qualifiedName; + } + else if (util_1.Guard.isExclusiveTextNode(this)) { + return "#text"; + } + else if (util_1.Guard.isCDATASectionNode(this)) { + return "#cdata-section"; + } + else if (util_1.Guard.isProcessingInstructionNode(this)) { + return this._target; + } + else if (util_1.Guard.isCommentNode(this)) { + return "#comment"; + } + else if (util_1.Guard.isDocumentNode(this)) { + return "#document"; + } + else if (util_1.Guard.isDocumentTypeNode(this)) { + return this._name; + } + else if (util_1.Guard.isDocumentFragmentNode(this)) { + return "#document-fragment"; + } + else { + return ""; + } + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "baseURI", { /** - * The isConnected attribute’s getter must return true, if context object - * is connected, and false otherwise. + * Gets the absolute base URL of the node. */ - return util_1.Guard.isElementNode(this) && algorithm_1.shadowTree_isConnected(this); - } - /** - * Returns the parent document. - */ - get ownerDocument() { + get: function () { + /** + * The baseURI attribute’s getter must return node document’s document + * base URL, serialized. + * TODO: Implement in HTML DOM + * https://html.spec.whatwg.org/multipage/urls-and-fetching.html#document-base-url + */ + return URLAlgorithm_1.urlSerializer(this._nodeDocument._URL); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "isConnected", { /** - * The ownerDocument attribute’s getter must return null, if the context - * object is a document, and the context object’s node document otherwise. - * _Note:_ The node document of a document is that document itself. All - * nodes have a node document at all times. + * Returns whether the node is rooted to a document node. */ - if (this._nodeType === interfaces_1.NodeType.Document) - return null; - else - return this._nodeDocument; - } + get: function () { + /** + * The isConnected attribute’s getter must return true, if context object + * is connected, and false otherwise. + */ + return util_1.Guard.isElementNode(this) && algorithm_1.shadowTree_isConnected(this); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "ownerDocument", { + /** + * Returns the parent document. + */ + get: function () { + /** + * The ownerDocument attribute’s getter must return null, if the context + * object is a document, and the context object’s node document otherwise. + * _Note:_ The node document of a document is that document itself. All + * nodes have a node document at all times. + */ + if (this._nodeType === interfaces_1.NodeType.Document) + return null; + else + return this._nodeDocument; + }, + enumerable: true, + configurable: true + }); /** * Returns the root node. * @@ -34015,164 +42632,200 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { * returns the node's shadow-including root, otherwise it returns * the node's root node. */ - getRootNode(options) { + NodeImpl.prototype.getRootNode = function (options) { /** * The getRootNode(options) method, when invoked, must return context * object’s shadow-including root if options’s composed is true, * and context object’s root otherwise. */ return algorithm_1.tree_rootNode(this, !!options && options.composed); - } - /** - * Returns the parent node. - */ - get parentNode() { + }; + Object.defineProperty(NodeImpl.prototype, "parentNode", { /** - * The parentNode attribute’s getter must return the context object’s parent. - * _Note:_ An Attr node has no parent. + * Returns the parent node. */ - if (this._nodeType === interfaces_1.NodeType.Attribute) { - return null; - } - else { - return this._parent; - } - } - /** - * Returns the parent element. - */ - get parentElement() { + get: function () { + /** + * The parentNode attribute’s getter must return the context object’s parent. + * _Note:_ An Attr node has no parent. + */ + if (this._nodeType === interfaces_1.NodeType.Attribute) { + return null; + } + else { + return this._parent; + } + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "parentElement", { /** - * The parentElement attribute’s getter must return the context object’s - * parent element. + * Returns the parent element. */ - if (this._parent && util_1.Guard.isElementNode(this._parent)) { - return this._parent; - } - else { - return null; - } - } + get: function () { + /** + * The parentElement attribute’s getter must return the context object’s + * parent element. + */ + if (this._parent && util_1.Guard.isElementNode(this._parent)) { + return this._parent; + } + else { + return null; + } + }, + enumerable: true, + configurable: true + }); /** * Determines whether a node has any children. */ - hasChildNodes() { + NodeImpl.prototype.hasChildNodes = function () { /** * The hasChildNodes() method, when invoked, must return true if the context * object has children, and false otherwise. */ return (this._firstChild !== null); - } - /** - * Returns a {@link NodeList} of child nodes. - */ - get childNodes() { + }; + Object.defineProperty(NodeImpl.prototype, "childNodes", { /** - * The childNodes attribute’s getter must return a NodeList rooted at the - * context object matching only children. + * Returns a {@link NodeList} of child nodes. */ - return this._childNodes; - } - /** - * Returns the first child node. - */ - get firstChild() { + get: function () { + /** + * The childNodes attribute’s getter must return a NodeList rooted at the + * context object matching only children. + */ + return this._childNodes; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "firstChild", { /** - * The firstChild attribute’s getter must return the context object’s first - * child. + * Returns the first child node. */ - return this._firstChild; - } - /** - * Returns the last child node. - */ - get lastChild() { + get: function () { + /** + * The firstChild attribute’s getter must return the context object’s first + * child. + */ + return this._firstChild; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "lastChild", { /** - * The lastChild attribute’s getter must return the context object’s last - * child. + * Returns the last child node. */ - return this._lastChild; - } - /** - * Returns the previous sibling node. - */ - get previousSibling() { + get: function () { + /** + * The lastChild attribute’s getter must return the context object’s last + * child. + */ + return this._lastChild; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "previousSibling", { /** - * The previousSibling attribute’s getter must return the context object’s - * previous sibling. - * _Note:_ An Attr node has no siblings. + * Returns the previous sibling node. */ - return this._previousSibling; - } - /** - * Returns the next sibling node. - */ - get nextSibling() { + get: function () { + /** + * The previousSibling attribute’s getter must return the context object’s + * previous sibling. + * _Note:_ An Attr node has no siblings. + */ + return this._previousSibling; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "nextSibling", { /** - * The nextSibling attribute’s getter must return the context object’s - * next sibling. + * Returns the next sibling node. */ - return this._nextSibling; - } - /** - * Gets or sets the data associated with a {@link CharacterData} node or the - * value of an {@link @Attr} node. For other node types returns `null`. - */ - get nodeValue() { - if (util_1.Guard.isAttrNode(this)) { - return this._value; - } - else if (util_1.Guard.isCharacterDataNode(this)) { - return this._data; - } - else { - return null; - } - } - set nodeValue(value) { - if (value === null) { - value = ''; - } - if (util_1.Guard.isAttrNode(this)) { - algorithm_1.attr_setAnExistingAttributeValue(this, value); - } - else if (util_1.Guard.isCharacterDataNode(this)) { - algorithm_1.characterData_replaceData(this, 0, this._data.length, value); - } - } - /** - * Returns the concatenation of data of all the {@link Text} - * node descendants in tree order. When set, replaces the text - * contents of the node with the given value. - */ - get textContent() { - if (util_1.Guard.isDocumentFragmentNode(this) || util_1.Guard.isElementNode(this)) { - return algorithm_1.text_descendantTextContent(this); - } - else if (util_1.Guard.isAttrNode(this)) { - return this._value; - } - else if (util_1.Guard.isCharacterDataNode(this)) { - return this._data; - } - else { - return null; - } - } - set textContent(value) { - if (value === null) { - value = ''; - } - if (util_1.Guard.isDocumentFragmentNode(this) || util_1.Guard.isElementNode(this)) { - algorithm_1.node_stringReplaceAll(value, this); - } - else if (util_1.Guard.isAttrNode(this)) { - algorithm_1.attr_setAnExistingAttributeValue(this, value); - } - else if (util_1.Guard.isCharacterDataNode(this)) { - algorithm_1.characterData_replaceData(this, 0, algorithm_1.tree_nodeLength(this), value); - } - } + get: function () { + /** + * The nextSibling attribute’s getter must return the context object’s + * next sibling. + */ + return this._nextSibling; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "nodeValue", { + /** + * Gets or sets the data associated with a {@link CharacterData} node or the + * value of an {@link @Attr} node. For other node types returns `null`. + */ + get: function () { + if (util_1.Guard.isAttrNode(this)) { + return this._value; + } + else if (util_1.Guard.isCharacterDataNode(this)) { + return this._data; + } + else { + return null; + } + }, + set: function (value) { + if (value === null) { + value = ''; + } + if (util_1.Guard.isAttrNode(this)) { + algorithm_1.attr_setAnExistingAttributeValue(this, value); + } + else if (util_1.Guard.isCharacterDataNode(this)) { + algorithm_1.characterData_replaceData(this, 0, this._data.length, value); + } + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NodeImpl.prototype, "textContent", { + /** + * Returns the concatenation of data of all the {@link Text} + * node descendants in tree order. When set, replaces the text + * contents of the node with the given value. + */ + get: function () { + if (util_1.Guard.isDocumentFragmentNode(this) || util_1.Guard.isElementNode(this)) { + return algorithm_1.text_descendantTextContent(this); + } + else if (util_1.Guard.isAttrNode(this)) { + return this._value; + } + else if (util_1.Guard.isCharacterDataNode(this)) { + return this._data; + } + else { + return null; + } + }, + set: function (value) { + if (value === null) { + value = ''; + } + if (util_1.Guard.isDocumentFragmentNode(this) || util_1.Guard.isElementNode(this)) { + algorithm_1.node_stringReplaceAll(value, this); + } + else if (util_1.Guard.isAttrNode(this)) { + algorithm_1.attr_setAnExistingAttributeValue(this, value); + } + else if (util_1.Guard.isCharacterDataNode(this)) { + algorithm_1.characterData_replaceData(this, 0, algorithm_1.tree_nodeLength(this), value); + } + }, + enumerable: true, + configurable: true + }); /** * Puts all {@link Text} nodes in the full depth of the sub-tree * underneath this node into a "normal" form where only markup @@ -34180,51 +42833,62 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { * and entity references) separates {@link Text} nodes, i.e., there * are no adjacent Text nodes. */ - normalize() { + NodeImpl.prototype.normalize = function () { + var e_1, _a, e_2, _b; /** * The normalize() method, when invoked, must run these steps for each * descendant exclusive Text node node of context object: */ - const descendantNodes = []; - let node = algorithm_1.tree_getFirstDescendantNode(this, false, false, (e) => util_1.Guard.isExclusiveTextNode(e)); + var descendantNodes = []; + var node = algorithm_1.tree_getFirstDescendantNode(this, false, false, function (e) { return util_1.Guard.isExclusiveTextNode(e); }); while (node !== null) { descendantNodes.push(node); - node = algorithm_1.tree_getNextDescendantNode(this, node, false, false, (e) => util_1.Guard.isExclusiveTextNode(e)); + node = algorithm_1.tree_getNextDescendantNode(this, node, false, false, function (e) { return util_1.Guard.isExclusiveTextNode(e); }); } - for (let i = 0; i < descendantNodes.length; i++) { - const node = descendantNodes[i]; - if (node._parent === null) + for (var i = 0; i < descendantNodes.length; i++) { + var node_1 = descendantNodes[i]; + if (node_1._parent === null) continue; /** * 1. Let length be node’s length. * 2. If length is zero, then remove node and continue with the next * exclusive Text node, if any. */ - let length = algorithm_1.tree_nodeLength(node); + var length = algorithm_1.tree_nodeLength(node_1); if (length === 0) { - algorithm_1.mutation_remove(node, node._parent); + algorithm_1.mutation_remove(node_1, node_1._parent); continue; } /** * 3. Let data be the concatenation of the data of node’s contiguous * exclusive Text nodes (excluding itself), in tree order. */ - const textSiblings = []; - let data = ''; - for (const sibling of algorithm_1.text_contiguousExclusiveTextNodes(node)) { - textSiblings.push(sibling); - data += sibling._data; + var textSiblings = []; + var data = ''; + try { + for (var _c = (e_1 = void 0, __values(algorithm_1.text_contiguousExclusiveTextNodes(node_1))), _d = _c.next(); !_d.done; _d = _c.next()) { + var sibling = _d.value; + textSiblings.push(sibling); + data += sibling._data; + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_d && !_d.done && (_a = _c.return)) _a.call(_c); + } + finally { if (e_1) throw e_1.error; } } /** * 4. Replace data with node node, offset length, count 0, and data data. */ - algorithm_1.characterData_replaceData(node, length, 0, data); + algorithm_1.characterData_replaceData(node_1, length, 0, data); /** * 5. Let currentNode be node’s next sibling. * 6. While currentNode is an exclusive Text node: */ - if (_1.dom.rangeList.size !== 0) { - let currentNode = node._nextSibling; + if (DOMImpl_1.dom.rangeList.size !== 0) { + var currentNode = node_1._nextSibling; while (currentNode !== null && util_1.Guard.isExclusiveTextNode(currentNode)) { /** * 6.1. For each live range whose start node is currentNode, add length @@ -34238,25 +42902,35 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { * end offset is currentNode’s index, set its end node to node and its * end offset to length. */ - const cn = currentNode; - const index = algorithm_1.tree_index(cn); - for (const range of _1.dom.rangeList) { - if (range._start[0] === cn) { - range._start[0] = node; - range._start[1] += length; + var cn = currentNode; + var index = algorithm_1.tree_index(cn); + try { + for (var _e = (e_2 = void 0, __values(DOMImpl_1.dom.rangeList)), _f = _e.next(); !_f.done; _f = _e.next()) { + var range = _f.value; + if (range._start[0] === cn) { + range._start[0] = node_1; + range._start[1] += length; + } + if (range._end[0] === cn) { + range._end[0] = node_1; + range._end[1] += length; + } + if (range._start[0] === cn._parent && range._start[1] === index) { + range._start[0] = node_1; + range._start[1] = length; + } + if (range._end[0] === cn._parent && range._end[1] === index) { + range._end[0] = node_1; + range._end[1] = length; + } } - if (range._end[0] === cn) { - range._end[0] = node; - range._end[1] += length; - } - if (range._start[0] === cn._parent && range._start[1] === index) { - range._start[0] = node; - range._start[1] = length; - } - if (range._end[0] === cn._parent && range._end[1] === index) { - range._end[0] = node; - range._end[1] = length; + } + catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { + try { + if (_f && !_f.done && (_b = _e.return)) _b.call(_e); } + finally { if (e_2) throw e_2.error; } } /** * 6.5. Add currentNode’s length to length. @@ -34270,14 +42944,14 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { * 7. Remove node’s contiguous exclusive Text nodes (excluding itself), * in tree order. */ - for (let i = 0; i < textSiblings.length; i++) { - const sibling = textSiblings[i]; + for (var i_1 = 0; i_1 < textSiblings.length; i_1++) { + var sibling = textSiblings[i_1]; if (sibling._parent === null) continue; algorithm_1.mutation_remove(sibling, sibling._parent); } } - } + }; /** * Returns a duplicate of this node, i.e., serves as a generic copy * constructor for nodes. The duplicate node has no parent @@ -34287,7 +42961,8 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { * specified node. If `false`, clone only the node itself (and its * attributes, if it is an {@link Element}). */ - cloneNode(deep = false) { + NodeImpl.prototype.cloneNode = function (deep) { + if (deep === void 0) { deep = false; } /** * 1. If context object is a shadow root, then throw a "NotSupportedError" * DOMException. @@ -34297,37 +42972,39 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { if (util_1.Guard.isShadowRoot(this)) throw new DOMException_1.NotSupportedError(); return algorithm_1.node_clone(this, null, deep); - } + }; /** * Determines if the given node is equal to this one. * * @param node - the node to compare with */ - isEqualNode(node = null) { + NodeImpl.prototype.isEqualNode = function (node) { + if (node === void 0) { node = null; } /** * The isEqualNode(otherNode) method, when invoked, must return true if * otherNode is non-null and context object equals otherNode, and false * otherwise. */ return (node !== null && algorithm_1.node_equals(this, node)); - } + }; /** * Determines if the given node is reference equal to this one. * * @param node - the node to compare with */ - isSameNode(node = null) { + NodeImpl.prototype.isSameNode = function (node) { + if (node === void 0) { node = null; } /** * The isSameNode(otherNode) method, when invoked, must return true if * otherNode is context object, and false otherwise. */ return (this === node); - } + }; /** * Returns a bitmask indicating the position of the given `node` * relative to this node. */ - compareDocumentPosition(other) { + NodeImpl.prototype.compareDocumentPosition = function (other) { /** * 1. If context object is other, then return zero. * 2. Let node1 be other and node2 be context object. @@ -34336,10 +43013,10 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { */ if (other === this) return 0; - let node1 = other; - let node2 = this; - let attr1 = null; - let attr2 = null; + var node1 = other; + var node2 = this; + var attr1 = null; + var attr2 = null; /** * 4. If node1 is an attribute, then set attr1 to node1 and node1 to * attr1’s element. @@ -34364,8 +43041,8 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { /** * 5.2. For each attr in node2’s attribute list: */ - for (let i = 0; i < node2._attributeList.length; i++) { - const attr = node2._attributeList[i]; + for (var i = 0; i < node2._attributeList.length; i++) { + var attr = node2._attributeList[i]; /** * 5.2.1. If attr equals attr1, then return the result of adding * DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and @@ -34395,7 +43072,7 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { // nodes are disconnected // return a random result but cache the value for consistency return interfaces_1.Position.Disconnected | interfaces_1.Position.ImplementationSpecific | - (_1.dom.compareCache.check(this, other) ? interfaces_1.Position.Preceding : interfaces_1.Position.Following); + (DOMImpl_1.dom.compareCache.check(this, other) ? interfaces_1.Position.Preceding : interfaces_1.Position.Following); } /** * 7. If node1 is an ancestor of node2 and attr1 is null, or node1 is node2 @@ -34424,14 +43101,14 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { * 10. Return DOCUMENT_POSITION_FOLLOWING. */ return interfaces_1.Position.Following; - } + }; /** * Returns `true` if given node is an inclusive descendant of this * node, and `false` otherwise (including when other node is `null`). * * @param other - the node to check */ - contains(other) { + NodeImpl.prototype.contains = function (other) { /** * The contains(other) method, when invoked, must return true if other is an * inclusive descendant of context object, and false otherwise (including @@ -34440,14 +43117,14 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { if (other === null) return false; return algorithm_1.tree_isDescendantOf(this, other, true); - } + }; /** * Returns the prefix for a given namespace URI, if present, and * `null` if not. * * @param namespace - the namespace to search */ - lookupPrefix(namespace) { + NodeImpl.prototype.lookupPrefix = function (namespace) { /** * 1. If namespace is null or the empty string, then return null. * 2. Switch on the context object: @@ -34500,28 +43177,28 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { return null; } } - } + }; /** * Returns the namespace URI for a given prefix if present, and `null` * if not. * * @param prefix - the prefix to search */ - lookupNamespaceURI(prefix) { + NodeImpl.prototype.lookupNamespaceURI = function (prefix) { /** * 1. If prefix is the empty string, then set it to null. * 2. Return the result of running locate a namespace for the context object * using prefix. */ return algorithm_1.node_locateANamespace(this, prefix || null); - } + }; /** * Returns `true` if the namespace is the default namespace on this * node or `false` if not. * * @param namespace - the namespace to check */ - isDefaultNamespace(namespace) { + NodeImpl.prototype.isDefaultNamespace = function (namespace) { /** * 1. If namespace is the empty string, then set it to null. * 2. Let defaultNamespace be the result of running locate a namespace for @@ -34530,9 +43207,9 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { */ if (!namespace) namespace = null; - const defaultNamespace = algorithm_1.node_locateANamespace(this, null); + var defaultNamespace = algorithm_1.node_locateANamespace(this, null); return (defaultNamespace === namespace); - } + }; /** * Inserts the node `newChild` before the existing child node * `refChild`. If `refChild` is `null`, inserts `newChild` at the end @@ -34549,13 +43226,13 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { * * @returns the newly inserted child node */ - insertBefore(newChild, refChild) { + NodeImpl.prototype.insertBefore = function (newChild, refChild) { /** * The insertBefore(node, child) method, when invoked, must return the * result of pre-inserting node into context object before child. */ return algorithm_1.mutation_preInsert(newChild, this, refChild); - } + }; /** * Adds the node `newChild` to the end of the list of children of this * node, and returns it. If `newChild` is already in the tree, it is @@ -34569,13 +43246,13 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { * * @returns the newly inserted child node */ - appendChild(newChild) { + NodeImpl.prototype.appendChild = function (newChild) { /** * The appendChild(node) method, when invoked, must return the result of * appending node to context object. */ return algorithm_1.mutation_append(newChild, this); - } + }; /** * Replaces the child node `oldChild` with `newChild` in the list of * children, and returns the `oldChild` node. If `newChild` is already @@ -34586,13 +43263,13 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { * * @returns the removed child node */ - replaceChild(newChild, oldChild) { + NodeImpl.prototype.replaceChild = function (newChild, oldChild) { /** * The replaceChild(node, child) method, when invoked, must return the * result of replacing child with node within context object. */ return algorithm_1.mutation_replace(oldChild, newChild, this); - } + }; /** * Removes the child node indicated by `oldChild` from the list of * children, and returns it. @@ -34601,19 +43278,19 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { * * @returns the removed child node */ - removeChild(oldChild) { + NodeImpl.prototype.removeChild = function (oldChild) { /** * The removeChild(child) method, when invoked, must return the result of * pre-removing child from context object. */ return algorithm_1.mutation_preRemove(oldChild, this); - } + }; /** * Gets the parent event target for the given event. * * @param event - an event */ - _getTheParent(event) { + NodeImpl.prototype._getTheParent = function (event) { /** * A node’s get the parent algorithm, given an event, returns the node’s * assigned slot, if node is assigned, and node’s parent otherwise. @@ -34624,27 +43301,28 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl { else { return this._parent; } - } -} + }; + NodeImpl.ELEMENT_NODE = 1; + NodeImpl.ATTRIBUTE_NODE = 2; + NodeImpl.TEXT_NODE = 3; + NodeImpl.CDATA_SECTION_NODE = 4; + NodeImpl.ENTITY_REFERENCE_NODE = 5; + NodeImpl.ENTITY_NODE = 6; + NodeImpl.PROCESSING_INSTRUCTION_NODE = 7; + NodeImpl.COMMENT_NODE = 8; + NodeImpl.DOCUMENT_NODE = 9; + NodeImpl.DOCUMENT_TYPE_NODE = 10; + NodeImpl.DOCUMENT_FRAGMENT_NODE = 11; + NodeImpl.NOTATION_NODE = 12; + NodeImpl.DOCUMENT_POSITION_DISCONNECTED = 0x01; + NodeImpl.DOCUMENT_POSITION_PRECEDING = 0x02; + NodeImpl.DOCUMENT_POSITION_FOLLOWING = 0x04; + NodeImpl.DOCUMENT_POSITION_CONTAINS = 0x08; + NodeImpl.DOCUMENT_POSITION_CONTAINED_BY = 0x10; + NodeImpl.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20; + return NodeImpl; +}(EventTargetImpl_1.EventTargetImpl)); exports.NodeImpl = NodeImpl; -NodeImpl.ELEMENT_NODE = 1; -NodeImpl.ATTRIBUTE_NODE = 2; -NodeImpl.TEXT_NODE = 3; -NodeImpl.CDATA_SECTION_NODE = 4; -NodeImpl.ENTITY_REFERENCE_NODE = 5; -NodeImpl.ENTITY_NODE = 6; -NodeImpl.PROCESSING_INSTRUCTION_NODE = 7; -NodeImpl.COMMENT_NODE = 8; -NodeImpl.DOCUMENT_NODE = 9; -NodeImpl.DOCUMENT_TYPE_NODE = 10; -NodeImpl.DOCUMENT_FRAGMENT_NODE = 11; -NodeImpl.NOTATION_NODE = 12; -NodeImpl.DOCUMENT_POSITION_DISCONNECTED = 0x01; -NodeImpl.DOCUMENT_POSITION_PRECEDING = 0x02; -NodeImpl.DOCUMENT_POSITION_FOLLOWING = 0x04; -NodeImpl.DOCUMENT_POSITION_CONTAINS = 0x08; -NodeImpl.DOCUMENT_POSITION_CONTAINED_BY = 0x10; -NodeImpl.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20; /** * A performance tweak to share an empty set between all node classes. This will * be overwritten by element, document and document fragment nodes to supply an @@ -34675,72 +43353,85 @@ WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "DOCUMENT_POSITION_IMPLEME //# sourceMappingURL=NodeImpl.js.map /***/ }), - -/***/ 938: -/***/ (function(__unusedmodule, exports) { +/* 936 */, +/* 937 */, +/* 938 */, +/* 939 */, +/* 940 */, +/* 941 */, +/* 942 */, +/* 943 */, +/* 944 */, +/* 945 */ +/***/ (function(module, __unusedexports, __webpack_require__) { "use strict"; -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents a cache for storing order between equal objects. - * - * This cache is used when an algorithm compares two objects and finds them to - * be equal but still needs to establish an order between those two objects. - * When two such objects `a` and `b` are passed to the `check` method, a random - * number is generated with `Math.random()`. If the random number is less than - * `0.5` it is assumed that `a < b` otherwise `a > b`. The random number along - * with `a` and `b` is stored in the cache, so that subsequent checks result - * in the same consistent result. - * - * The cache has a size limit which is defined on initialization. - */ -class CompareCache { - /** - * Initializes a new instance of `CompareCache`. - * - * @param limit - maximum number of items to keep in the cache. When the limit - * is exceeded the first item is removed from the cache. - */ - constructor(limit = 1000) { - this._items = new Map(); - this._limit = limit; - } - /** - * Compares and caches the given objects. Returns `true` if `objA < objB` and - * `false` otherwise. - * - * @param objA - an item to compare - * @param objB - an item to compare - */ - check(objA, objB) { - if (this._items.get(objA) === objB) - return true; - else if (this._items.get(objB) === objA) - return false; - const result = (Math.random() < 0.5); - if (result) { - this._items.set(objA, objB); - } - else { - this._items.set(objB, objA); - } - if (this._items.size > this._limit) { - const it = this._items.keys().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - return result; - } + +var YAMLException = __webpack_require__(556); + +var TYPE_CONSTRUCTOR_OPTIONS = [ + 'kind', + 'resolve', + 'construct', + 'instanceOf', + 'predicate', + 'represent', + 'defaultStyle', + 'styleAliases' +]; + +var YAML_NODE_KINDS = [ + 'scalar', + 'sequence', + 'mapping' +]; + +function compileStyleAliases(map) { + var result = {}; + + if (map !== null) { + Object.keys(map).forEach(function (style) { + map[style].forEach(function (alias) { + result[String(alias)] = style; + }); + }); + } + + return result; } -exports.CompareCache = CompareCache; -//# sourceMappingURL=CompareCache.js.map + +function Type(tag, options) { + options = options || {}; + + Object.keys(options).forEach(function (name) { + if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) { + throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.'); + } + }); + + // TODO: Add tag format check. + this.tag = tag; + this.kind = options['kind'] || null; + this.resolve = options['resolve'] || function () { return true; }; + this.construct = options['construct'] || function (data) { return data; }; + this.instanceOf = options['instanceOf'] || null; + this.predicate = options['predicate'] || null; + this.represent = options['represent'] || null; + this.defaultStyle = options['defaultStyle'] || null; + this.styleAliases = compileStyleAliases(options['styleAliases'] || null); + + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); + } +} + +module.exports = Type; + /***/ }), - -/***/ 947: +/* 946 */, +/* 947 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -34749,40 +43440,45 @@ Object.defineProperty(exports, "__esModule", { value: true }); /** * Represents an object with lazy initialization. */ -class Lazy { +var Lazy = /** @class */ (function () { /** * Initializes a new instance of `Lazy`. * * @param initFunc - initializer function */ - constructor(initFunc) { + function Lazy(initFunc) { this._initialized = false; this._value = undefined; this._initFunc = initFunc; } - /** - * Gets the value of the object. - */ - get value() { - if (!this._initialized) { - this._value = this._initFunc(); - this._initialized = true; - } - return this._value; - } -} + Object.defineProperty(Lazy.prototype, "value", { + /** + * Gets the value of the object. + */ + get: function () { + if (!this._initialized) { + this._value = this._initFunc(); + this._initialized = true; + } + return this._value; + }, + enumerable: true, + configurable: true + }); + return Lazy; +}()); exports.Lazy = Lazy; //# sourceMappingURL=Lazy.js.map /***/ }), - -/***/ 950: -/***/ (function(__unusedmodule, exports, __webpack_require__) { +/* 948 */, +/* 949 */, +/* 950 */ +/***/ (function(__unusedmodule, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const url = __webpack_require__(835); function getProxyUrl(reqUrl) { let usingSsl = reqUrl.protocol === 'https:'; let proxyUrl; @@ -34797,7 +43493,7 @@ function getProxyUrl(reqUrl) { proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY']; } if (proxyVar) { - proxyUrl = url.parse(proxyVar); + proxyUrl = new URL(proxyVar); } return proxyUrl; } @@ -34841,62 +43537,298 @@ exports.checkBypass = checkBypass; /***/ }), +/* 951 */, +/* 952 */, +/* 953 */, +/* 954 */ +/***/ (function(module) { -/***/ 968: +const numeric = /^[0-9]+$/ +const compareIdentifiers = (a, b) => { + const anum = numeric.test(a) + const bnum = numeric.test(b) + + if (anum && bnum) { + a = +a + b = +b + } + + return a === b ? 0 + : (anum && !bnum) ? -1 + : (bnum && !anum) ? 1 + : a < b ? -1 + : 1 +} + +const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a) + +module.exports = { + compareIdentifiers, + rcompareIdentifiers +} + + +/***/ }), +/* 955 */, +/* 956 */, +/* 957 */, +/* 958 */, +/* 959 */, +/* 960 */ +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) +const gt = __webpack_require__(486) + +const minVersion = (range, loose) => { + range = new Range(range, loose) + + let minver = new SemVer('0.0.0') + if (range.test(minver)) { + return minver + } + + minver = new SemVer('0.0.0-0') + if (range.test(minver)) { + return minver + } + + minver = null + for (let i = 0; i < range.set.length; ++i) { + const comparators = range.set[i] + + let setMin = null + comparators.forEach((comparator) => { + // Clone to avoid manipulating the comparator's semver object. + const compver = new SemVer(comparator.semver.version) + switch (comparator.operator) { + case '>': + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + /* fallthrough */ + case '': + case '>=': + if (!setMin || gt(compver, setMin)) { + setMin = compver + } + break + case '<': + case '<=': + /* Ignore maximum versions */ + break + /* istanbul ignore next */ + default: + throw new Error(`Unexpected operation: ${comparator.operator}`) + } + }) + if (setMin && (!minver || gt(minver, setMin))) + minver = setMin + } + + if (minver && range.test(minver)) { + return minver + } + + return null +} +module.exports = minVersion + + +/***/ }), +/* 961 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var interfaces_1 = __webpack_require__(625); +var util_1 = __webpack_require__(592); +var util_2 = __webpack_require__(918); +var _1 = __webpack_require__(535); +var dom_1 = __webpack_require__(743); +/** @inheritdoc */ +function builder(p1, p2) { + var options = formatBuilderOptions(isXMLBuilderCreateOptions(p1) ? p1 : interfaces_1.DefaultBuilderOptions); + var nodes = util_2.Guard.isNode(p1) || util_1.isArray(p1) ? p1 : p2; + if (nodes === undefined) { + throw new Error("Invalid arguments."); + } + if (util_1.isArray(nodes)) { + var builders = []; + for (var i = 0; i < nodes.length; i++) { + var builder_1 = new _1.XMLBuilderImpl(nodes[i]); + builder_1.set(options); + builders.push(builder_1); + } + return builders; + } + else { + var builder_2 = new _1.XMLBuilderImpl(nodes); + builder_2.set(options); + return builder_2; + } +} +exports.builder = builder; +/** @inheritdoc */ +function create(p1, p2) { + var options = formatBuilderOptions(p1 === undefined || isXMLBuilderCreateOptions(p1) ? + p1 : interfaces_1.DefaultBuilderOptions); + var contents = isXMLBuilderCreateOptions(p1) ? p2 : p1; + var doc = dom_1.createDocument(); + setOptions(doc, options); + var builder = new _1.XMLBuilderImpl(doc); + if (contents !== undefined) { + // parse contents + builder.ele(contents); + } + return builder; +} +exports.create = create; +/** @inheritdoc */ +function fragment(p1, p2) { + var options = formatBuilderOptions(p1 === undefined || isXMLBuilderCreateOptions(p1) ? + p1 : interfaces_1.DefaultBuilderOptions); + var contents = isXMLBuilderCreateOptions(p1) ? p2 : p1; + var doc = dom_1.createDocument(); + setOptions(doc, options, true); + var builder = new _1.XMLBuilderImpl(doc.createDocumentFragment()); + if (contents !== undefined) { + // parse contents + builder.ele(contents); + } + return builder; +} +exports.fragment = fragment; +/** @inheritdoc */ +function convert(p1, p2, p3) { + var builderOptions; + var contents; + var convertOptions; + if (isXMLBuilderCreateOptions(p1) && p2 !== undefined) { + builderOptions = p1; + contents = p2; + convertOptions = p3; + } + else { + builderOptions = interfaces_1.DefaultBuilderOptions; + contents = p1; + convertOptions = p2 || undefined; + } + return create(builderOptions, contents).end(convertOptions); +} +exports.convert = convert; +function isXMLBuilderCreateOptions(obj) { + if (!util_1.isPlainObject(obj)) + return false; + for (var key in obj) { + /* istanbul ignore else */ + if (obj.hasOwnProperty(key)) { + if (!interfaces_1.XMLBuilderOptionKeys.has(key)) + return false; + } + } + return true; +} +function formatBuilderOptions(createOptions) { + if (createOptions === void 0) { createOptions = {}; } + var options = util_1.applyDefaults(createOptions, interfaces_1.DefaultBuilderOptions); + if (options.convert.att.length === 0 || + options.convert.ins.length === 0 || + options.convert.text.length === 0 || + options.convert.cdata.length === 0 || + options.convert.comment.length === 0) { + throw new Error("JS object converter strings cannot be zero length."); + } + return options; +} +function setOptions(doc, options, isFragment) { + var docWithSettings = doc; + docWithSettings._xmlBuilderOptions = options; + docWithSettings._isFragment = isFragment; +} +//# sourceMappingURL=BuilderFunctions.js.map + +/***/ }), +/* 962 */, +/* 963 */, +/* 964 */, +/* 965 */, +/* 966 */, +/* 967 */, +/* 968 */ /***/ (function(__unusedmodule, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -class EmptySet { - get size() { - return 0; +var EmptySet = /** @class */ (function () { + function EmptySet() { } - add(value) { + Object.defineProperty(EmptySet.prototype, "size", { + get: function () { + return 0; + }, + enumerable: true, + configurable: true + }); + EmptySet.prototype.add = function (value) { throw new Error("Cannot add to an empty set."); - } - clear() { + }; + EmptySet.prototype.clear = function () { // no-op - } - delete(value) { + }; + EmptySet.prototype.delete = function (value) { return false; - } - forEach(callbackfn, thisArg) { + }; + EmptySet.prototype.forEach = function (callbackfn, thisArg) { // no-op - } - has(value) { + }; + EmptySet.prototype.has = function (value) { return false; - } - [Symbol.iterator]() { + }; + EmptySet.prototype[Symbol.iterator] = function () { return new EmptySetIterator(); - } - entries() { + }; + EmptySet.prototype.entries = function () { return new EmptySetIterator(); - } - keys() { + }; + EmptySet.prototype.keys = function () { return new EmptySetIterator(); - } - values() { + }; + EmptySet.prototype.values = function () { return new EmptySetIterator(); - } - get [Symbol.toStringTag]() { - return "EmptySet"; - } -} + }; + Object.defineProperty(EmptySet.prototype, Symbol.toStringTag, { + get: function () { + return "EmptySet"; + }, + enumerable: true, + configurable: true + }); + return EmptySet; +}()); exports.EmptySet = EmptySet; -class EmptySetIterator { - [Symbol.iterator]() { +var EmptySetIterator = /** @class */ (function () { + function EmptySetIterator() { + } + EmptySetIterator.prototype[Symbol.iterator] = function () { return this; - } - next() { + }; + EmptySetIterator.prototype.next = function () { return { done: true, value: null }; - } -} + }; + return EmptySetIterator; +}()); //# sourceMappingURL=EmptySet.js.map /***/ }), - -/***/ 970: +/* 969 */, +/* 970 */ /***/ (function(__unusedmodule, exports) { "use strict"; @@ -34993,277 +43925,202 @@ var HowToCompare; //# sourceMappingURL=interfaces.js.map /***/ }), +/* 971 */, +/* 972 */, +/* 973 */, +/* 974 */, +/* 975 */, +/* 976 */ +/***/ (function(module, exports, __webpack_require__) { -/***/ 973: -/***/ (function(__unusedmodule, exports) { +const { MAX_SAFE_COMPONENT_LENGTH } = __webpack_require__(181) +const debug = __webpack_require__(548) +exports = module.exports = {} -"use strict"; +// The actual regexps go on exports.re +const re = exports.re = [] +const src = exports.src = [] +const t = exports.t = {} +let R = 0 -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents a cache of objects with a size limit. - */ -class ObjectCache { - /** - * Initializes a new instance of `ObjectCache`. - * - * @param limit - maximum number of items to keep in the cache. When the limit - * is exceeded the first item is removed from the cache. - */ - constructor(limit = 1000) { - this._items = new Map(); - this._limit = limit; - } - /** - * Gets an item from the cache. - * - * @param key - object key - */ - get(key) { - return this._items.get(key); - } - /** - * Adds a new item to the cache. - * - * @param key - object key - * @param value - object value - */ - set(key, value) { - this._items.set(key, value); - if (this._items.size > this._limit) { - const it = this._items.keys().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - } - /** - * Removes an item from the cache. - * - * @param item - an item - */ - delete(key) { - return this._items.delete(key); - } - /** - * Determines if an item is in the cache. - * - * @param item - an item - */ - has(key) { - return this._items.has(key); - } - /** - * Removes all items from the cache. - */ - clear() { - this._items.clear(); - } - /** - * Gets the number of items in the cache. - */ - get size() { return this._items.size; } - /** - * Applies the given callback function to all elements of the cache. - */ - forEach(callback, thisArg) { - this._items.forEach((v, k) => callback.call(thisArg, k, v)); - } - /** - * Iterates through the items in the set. - */ - *keys() { - yield* this._items.keys(); - } - /** - * Iterates through the items in the set. - */ - *values() { - yield* this._items.values(); - } - /** - * Iterates through the items in the set. - */ - *entries() { - yield* this._items.entries(); - } - /** - * Iterates through the items in the set. - */ - *[Symbol.iterator]() { - yield* this._items; - } - /** - * Returns the string tag of the cache. - */ - get [Symbol.toStringTag]() { - return "ObjectCache"; - } +const createToken = (name, value, isGlobal) => { + const index = R++ + debug(index, value) + t[name] = index + src[index] = value + re[index] = new RegExp(value, isGlobal ? 'g' : undefined) } -exports.ObjectCache = ObjectCache; -//# sourceMappingURL=ObjectCache.js.map + +// The following Regular Expressions can be used for tokenizing, +// validating, and parsing SemVer version strings. + +// ## Numeric Identifier +// A single `0`, or a non-zero digit followed by zero or more digits. + +createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*') +createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+') + +// ## Non-numeric Identifier +// Zero or more digits, followed by a letter or hyphen, and then zero or +// more letters, digits, or hyphens. + +createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*') + +// ## Main Version +// Three dot-separated numeric identifiers. + +createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` + + `(${src[t.NUMERICIDENTIFIER]})\\.` + + `(${src[t.NUMERICIDENTIFIER]})`) + +createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + + `(${src[t.NUMERICIDENTIFIERLOOSE]})`) + +// ## Pre-release Version Identifier +// A numeric identifier, or a non-numeric identifier. + +createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER] +}|${src[t.NONNUMERICIDENTIFIER]})`) + +createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE] +}|${src[t.NONNUMERICIDENTIFIER]})`) + +// ## Pre-release Version +// Hyphen, followed by one or more dot-separated pre-release version +// identifiers. + +createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER] +}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`) + +createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE] +}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`) + +// ## Build Metadata Identifier +// Any combination of digits, letters, or hyphens. + +createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+') + +// ## Build Metadata +// Plus sign, followed by one or more period-separated build metadata +// identifiers. + +createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER] +}(?:\\.${src[t.BUILDIDENTIFIER]})*))`) + +// ## Full Version String +// A main version, followed optionally by a pre-release version and +// build metadata. + +// Note that the only major, minor, patch, and pre-release sections of +// the version string are capturing groups. The build metadata is not a +// capturing group, because it should not ever be used in version +// comparison. + +createToken('FULLPLAIN', `v?${src[t.MAINVERSION] +}${src[t.PRERELEASE]}?${ + src[t.BUILD]}?`) + +createToken('FULL', `^${src[t.FULLPLAIN]}$`) + +// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. +// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty +// common in the npm registry. +createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE] +}${src[t.PRERELEASELOOSE]}?${ + src[t.BUILD]}?`) + +createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`) + +createToken('GTLT', '((?:<|>)?=?)') + +// Something like "2.*" or "1.2.x". +// Note that "x.x" is a valid xRange identifer, meaning "any version" +// Only the first item is strictly required. +createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`) +createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`) + +createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + + `(?:${src[t.PRERELEASE]})?${ + src[t.BUILD]}?` + + `)?)?`) + +createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:${src[t.PRERELEASELOOSE]})?${ + src[t.BUILD]}?` + + `)?)?`) + +createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`) +createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`) + +// Coercion. +// Extract anything that could conceivably be a part of a valid semver +createToken('COERCE', `${'(^|[^\\d])' + + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + + `(?:$|[^\\d])`) +createToken('COERCERTL', src[t.COERCE], true) + +// Tilde ranges. +// Meaning is "reasonably at or greater than" +createToken('LONETILDE', '(?:~>?)') + +createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true) +exports.tildeTrimReplace = '$1~' + +createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`) +createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`) + +// Caret ranges. +// Meaning is "at least and backwards compatible with" +createToken('LONECARET', '(?:\\^)') + +createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true) +exports.caretTrimReplace = '$1^' + +createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`) +createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`) + +// A simple gt/lt/eq thing, or just "" to indicate "any version" +createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`) +createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`) + +// An expression to strip any whitespace between the gtlt and the thing +// it modifies, so that `> 1.2.3` ==> `>1.2.3` +createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT] +}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true) +exports.comparatorTrimReplace = '$1$2$3' + +// Something like `1.2.3 - 1.2.4` +// Note that these all use the loose form, because they'll be +// checked against either the strict or loose comparator form +// later. +createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` + + `\\s+-\\s+` + + `(${src[t.XRANGEPLAIN]})` + + `\\s*$`) + +createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + + `\\s+-\\s+` + + `(${src[t.XRANGEPLAINLOOSE]})` + + `\\s*$`) + +// Star ranges basically just allow anything at all. +createToken('STAR', '(<|>)?=?\\s*\\*') +// >=0.0.0 is like a star +createToken('GTE0', '^\\s*>=\\s*0\.0\.0\\s*$') +createToken('GTE0PRE', '^\\s*>=\\s*0\.0\.0-0\\s*$') + /***/ }), - -/***/ 983: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const util_1 = __webpack_require__(918); -const algorithm_1 = __webpack_require__(163); -/** - * Represents a mixin that extends child nodes that can have siblings - * including doctypes. This mixin is implemented by {@link Element}, - * {@link CharacterData} and {@link DocumentType}. - */ -class ChildNodeImpl { - /** @inheritdoc */ - before(...nodes) { - /** - * 1. Let parent be context object’s parent. - * 2. If parent is null, then return. - */ - const context = util_1.Cast.asNode(this); - const parent = context._parent; - if (parent === null) - return; - /** - * 3. Let viablePreviousSibling be context object’s first preceding - * sibling not in nodes, and null otherwise. - */ - let viablePreviousSibling = context._previousSibling; - let flag = true; - while (flag && viablePreviousSibling) { - flag = false; - for (let i = 0; i < nodes.length; i++) { - const child = nodes[i]; - if (child === viablePreviousSibling) { - viablePreviousSibling = viablePreviousSibling._previousSibling; - flag = true; - break; - } - } - } - /** - * 4. Let node be the result of converting nodes into a node, given nodes - * and context object’s node document. - */ - const node = algorithm_1.parentNode_convertNodesIntoANode(nodes, context._nodeDocument); - /** - * 5. If viablePreviousSibling is null, set it to parent’s first child, - * and to viablePreviousSibling’s next sibling otherwise. - */ - if (viablePreviousSibling === null) - viablePreviousSibling = parent._firstChild; - else - viablePreviousSibling = viablePreviousSibling._nextSibling; - /** - * 6. Pre-insert node into parent before viablePreviousSibling. - */ - algorithm_1.mutation_preInsert(node, parent, viablePreviousSibling); - } - /** @inheritdoc */ - after(...nodes) { - /** - * 1. Let parent be context object’s parent. - * 2. If parent is null, then return. - */ - const context = util_1.Cast.asNode(this); - const parent = context._parent; - if (!parent) - return; - /** - * 3. Let viableNextSibling be context object’s first following sibling not - * in nodes, and null otherwise. - */ - let viableNextSibling = context._nextSibling; - let flag = true; - while (flag && viableNextSibling) { - flag = false; - for (let i = 0; i < nodes.length; i++) { - const child = nodes[i]; - if (child === viableNextSibling) { - viableNextSibling = viableNextSibling._nextSibling; - flag = true; - break; - } - } - } - /** - * 4. Let node be the result of converting nodes into a node, given nodes - * and context object’s node document. - */ - const node = algorithm_1.parentNode_convertNodesIntoANode(nodes, context._nodeDocument); - /** - * 5. Pre-insert node into parent before viableNextSibling. - */ - algorithm_1.mutation_preInsert(node, parent, viableNextSibling); - } - /** @inheritdoc */ - replaceWith(...nodes) { - /** - * 1. Let parent be context object’s parent. - * 2. If parent is null, then return. - */ - const context = util_1.Cast.asNode(this); - const parent = context._parent; - if (!parent) - return; - /** - * 3. Let viableNextSibling be context object’s first following sibling not - * in nodes, and null otherwise. - */ - let viableNextSibling = context._nextSibling; - let flag = true; - while (flag && viableNextSibling) { - flag = false; - for (let i = 0; i < nodes.length; i++) { - const child = nodes[i]; - if (child === viableNextSibling) { - viableNextSibling = viableNextSibling._nextSibling; - flag = true; - break; - } - } - } - /** - * 4. Let node be the result of converting nodes into a node, given nodes - * and context object’s node document. - */ - const node = algorithm_1.parentNode_convertNodesIntoANode(nodes, context._nodeDocument); - /** - * 5. If context object’s parent is parent, replace the context object with - * node within parent. - * _Note:_ Context object could have been inserted into node. - * 6. Otherwise, pre-insert node into parent before viableNextSibling. - */ - if (context._parent === parent) - algorithm_1.mutation_replace(context, node, parent); - else - algorithm_1.mutation_preInsert(node, parent, viableNextSibling); - } - /** @inheritdoc */ - remove() { - /** - * 1. If context object’s parent is null, then return. - * 2. Remove the context object from context object’s parent. - */ - const context = util_1.Cast.asNode(this); - const parent = context._parent; - if (!parent) - return; - algorithm_1.mutation_remove(context, parent); - } -} -exports.ChildNodeImpl = ChildNodeImpl; -//# sourceMappingURL=ChildNodeImpl.js.map - -/***/ }), - -/***/ 986: +/* 977 */, +/* 978 */, +/* 979 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; @@ -35277,8 +44134,267 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge step((generator = generator.apply(thisArg, _arguments || [])).next()); }); }; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; Object.defineProperty(exports, "__esModule", { value: true }); -const tr = __webpack_require__(9); +const core = __importStar(__webpack_require__(470)); +/** + * Internal class for retries + */ +class RetryHelper { + constructor(maxAttempts, minSeconds, maxSeconds) { + if (maxAttempts < 1) { + throw new Error('max attempts should be greater than or equal to 1'); + } + this.maxAttempts = maxAttempts; + this.minSeconds = Math.floor(minSeconds); + this.maxSeconds = Math.floor(maxSeconds); + if (this.minSeconds > this.maxSeconds) { + throw new Error('min seconds should be less than or equal to max seconds'); + } + } + execute(action, isRetryable) { + return __awaiter(this, void 0, void 0, function* () { + let attempt = 1; + while (attempt < this.maxAttempts) { + // Try + try { + return yield action(); + } + catch (err) { + if (isRetryable && !isRetryable(err)) { + throw err; + } + core.info(err.message); + } + // Sleep + const seconds = this.getSleepAmount(); + core.info(`Waiting ${seconds} seconds before trying again`); + yield this.sleep(seconds); + attempt++; + } + // Last attempt + return yield action(); + }); + } + getSleepAmount() { + return (Math.floor(Math.random() * (this.maxSeconds - this.minSeconds + 1)) + + this.minSeconds); + } + sleep(seconds) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise(resolve => setTimeout(resolve, seconds * 1000)); + }); + } +} +exports.RetryHelper = RetryHelper; +//# sourceMappingURL=retry-helper.js.map + +/***/ }), +/* 980 */, +/* 981 */, +/* 982 */, +/* 983 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +var util_1 = __webpack_require__(918); +var algorithm_1 = __webpack_require__(163); +/** + * Represents a mixin that extends child nodes that can have siblings + * including doctypes. This mixin is implemented by {@link Element}, + * {@link CharacterData} and {@link DocumentType}. + */ +var ChildNodeImpl = /** @class */ (function () { + function ChildNodeImpl() { + } + /** @inheritdoc */ + ChildNodeImpl.prototype.before = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + /** + * 1. Let parent be context object’s parent. + * 2. If parent is null, then return. + */ + var context = util_1.Cast.asNode(this); + var parent = context._parent; + if (parent === null) + return; + /** + * 3. Let viablePreviousSibling be context object’s first preceding + * sibling not in nodes, and null otherwise. + */ + var viablePreviousSibling = context._previousSibling; + var flag = true; + while (flag && viablePreviousSibling) { + flag = false; + for (var i = 0; i < nodes.length; i++) { + var child = nodes[i]; + if (child === viablePreviousSibling) { + viablePreviousSibling = viablePreviousSibling._previousSibling; + flag = true; + break; + } + } + } + /** + * 4. Let node be the result of converting nodes into a node, given nodes + * and context object’s node document. + */ + var node = algorithm_1.parentNode_convertNodesIntoANode(nodes, context._nodeDocument); + /** + * 5. If viablePreviousSibling is null, set it to parent’s first child, + * and to viablePreviousSibling’s next sibling otherwise. + */ + if (viablePreviousSibling === null) + viablePreviousSibling = parent._firstChild; + else + viablePreviousSibling = viablePreviousSibling._nextSibling; + /** + * 6. Pre-insert node into parent before viablePreviousSibling. + */ + algorithm_1.mutation_preInsert(node, parent, viablePreviousSibling); + }; + /** @inheritdoc */ + ChildNodeImpl.prototype.after = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + /** + * 1. Let parent be context object’s parent. + * 2. If parent is null, then return. + */ + var context = util_1.Cast.asNode(this); + var parent = context._parent; + if (!parent) + return; + /** + * 3. Let viableNextSibling be context object’s first following sibling not + * in nodes, and null otherwise. + */ + var viableNextSibling = context._nextSibling; + var flag = true; + while (flag && viableNextSibling) { + flag = false; + for (var i = 0; i < nodes.length; i++) { + var child = nodes[i]; + if (child === viableNextSibling) { + viableNextSibling = viableNextSibling._nextSibling; + flag = true; + break; + } + } + } + /** + * 4. Let node be the result of converting nodes into a node, given nodes + * and context object’s node document. + */ + var node = algorithm_1.parentNode_convertNodesIntoANode(nodes, context._nodeDocument); + /** + * 5. Pre-insert node into parent before viableNextSibling. + */ + algorithm_1.mutation_preInsert(node, parent, viableNextSibling); + }; + /** @inheritdoc */ + ChildNodeImpl.prototype.replaceWith = function () { + var nodes = []; + for (var _i = 0; _i < arguments.length; _i++) { + nodes[_i] = arguments[_i]; + } + /** + * 1. Let parent be context object’s parent. + * 2. If parent is null, then return. + */ + var context = util_1.Cast.asNode(this); + var parent = context._parent; + if (!parent) + return; + /** + * 3. Let viableNextSibling be context object’s first following sibling not + * in nodes, and null otherwise. + */ + var viableNextSibling = context._nextSibling; + var flag = true; + while (flag && viableNextSibling) { + flag = false; + for (var i = 0; i < nodes.length; i++) { + var child = nodes[i]; + if (child === viableNextSibling) { + viableNextSibling = viableNextSibling._nextSibling; + flag = true; + break; + } + } + } + /** + * 4. Let node be the result of converting nodes into a node, given nodes + * and context object’s node document. + */ + var node = algorithm_1.parentNode_convertNodesIntoANode(nodes, context._nodeDocument); + /** + * 5. If context object’s parent is parent, replace the context object with + * node within parent. + * _Note:_ Context object could have been inserted into node. + * 6. Otherwise, pre-insert node into parent before viableNextSibling. + */ + if (context._parent === parent) + algorithm_1.mutation_replace(context, node, parent); + else + algorithm_1.mutation_preInsert(node, parent, viableNextSibling); + }; + /** @inheritdoc */ + ChildNodeImpl.prototype.remove = function () { + /** + * 1. If context object’s parent is null, then return. + * 2. Remove the context object from context object’s parent. + */ + var context = util_1.Cast.asNode(this); + var parent = context._parent; + if (!parent) + return; + algorithm_1.mutation_remove(context, parent); + }; + return ChildNodeImpl; +}()); +exports.ChildNodeImpl = ChildNodeImpl; +//# sourceMappingURL=ChildNodeImpl.js.map + +/***/ }), +/* 984 */, +/* 985 */, +/* 986 */ +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const tr = __importStar(__webpack_require__(658)); /** * Exec a command. * Output will be streamed to the live console. @@ -35306,22 +44422,38 @@ exports.exec = exec; //# sourceMappingURL=exec.js.map /***/ }), +/* 987 */, +/* 988 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 990: +"use strict"; + + +var Type = __webpack_require__(945); + +module.exports = new Type('tag:yaml.org,2002:map', { + kind: 'mapping', + construct: function (data) { return data !== null ? data : {}; } +}); + + +/***/ }), +/* 989 */, +/* 990 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const algorithm_1 = __webpack_require__(163); +var algorithm_1 = __webpack_require__(163); /** * Represents a controller that allows to abort DOM requests. */ -class AbortControllerImpl { +var AbortControllerImpl = /** @class */ (function () { /** * Initializes a new instance of `AbortController`. */ - constructor() { + function AbortControllerImpl() { /** * 1. Let signal be a new AbortSignal object. * 2. Let controller be a new AbortController object whose signal is signal. @@ -35329,128 +44461,196 @@ class AbortControllerImpl { */ this._signal = algorithm_1.create_abortSignal(); } + Object.defineProperty(AbortControllerImpl.prototype, "signal", { + /** @inheritdoc */ + get: function () { return this._signal; }, + enumerable: true, + configurable: true + }); /** @inheritdoc */ - get signal() { return this._signal; } - /** @inheritdoc */ - abort() { + AbortControllerImpl.prototype.abort = function () { algorithm_1.abort_signalAbort(this._signal); - } -} + }; + return AbortControllerImpl; +}()); exports.AbortControllerImpl = AbortControllerImpl; //# sourceMappingURL=AbortControllerImpl.js.map /***/ }), +/* 991 */, +/* 992 */, +/* 993 */, +/* 994 */, +/* 995 */, +/* 996 */, +/* 997 */, +/* 998 */, +/* 999 */ +/***/ (function(module, __unusedexports, __webpack_require__) { -/***/ 995: -/***/ (function(__unusedmodule, exports) { +const Range = __webpack_require__(124) +const { ANY } = __webpack_require__(536) +const satisfies = __webpack_require__(310) +const compare = __webpack_require__(874) -"use strict"; +// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff: +// - Every simple range `r1, r2, ...` is a subset of some `R1, R2, ...` +// +// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff: +// - If c is only the ANY comparator +// - If C is only the ANY comparator, return true +// - Else return false +// - Let EQ be the set of = comparators in c +// - If EQ is more than one, return true (null set) +// - Let GT be the highest > or >= comparator in c +// - Let LT be the lowest < or <= comparator in c +// - If GT and LT, and GT.semver > LT.semver, return true (null set) +// - If EQ +// - If GT, and EQ does not satisfy GT, return true (null set) +// - If LT, and EQ does not satisfy LT, return true (null set) +// - If EQ satisfies every C, return true +// - Else return false +// - If GT +// - If GT.semver is lower than any > or >= comp in C, return false +// - If GT is >=, and GT.semver does not satisfy every C, return false +// - If LT +// - If LT.semver is greater than any < or <= comp in C, return false +// - If LT is <=, and LT.semver does not satisfy every C, return false +// - If any C is a = range, and GT or LT are set, return false +// - Else return true -Object.defineProperty(exports, "__esModule", { value: true }); -/** - * Represents a cache of objects with a size limit. - */ -class ObjectCache { - /** - * Initializes a new instance of `ObjectCache`. - * - * @param limit - maximum number of items to keep in the cache. When the limit - * is exceeded the first item is removed from the cache. - */ - constructor(limit = 1000) { - this._items = new Map(); - this._limit = limit; - } - /** - * Gets an item from the cache. - * - * @param key - object key - */ - get(key) { - return this._items.get(key); - } - /** - * Adds a new item to the cache. - * - * @param key - object key - * @param value - object value - */ - set(key, value) { - this._items.set(key, value); - if (this._items.size > this._limit) { - const it = this._items.keys().next(); - /* istanbul ignore else */ - if (!it.done) { - this._items.delete(it.value); - } - } - } - /** - * Removes an item from the cache. - * - * @param item - an item - */ - delete(key) { - return this._items.delete(key); - } - /** - * Determines if an item is in the cache. - * - * @param item - an item - */ - has(key) { - return this._items.has(key); - } - /** - * Removes all items from the cache. - */ - clear() { - this._items.clear(); - } - /** - * Gets the number of items in the cache. - */ - get size() { return this._items.size; } - /** - * Applies the given callback function to all elements of the cache. - */ - forEach(callback, thisArg) { - this._items.forEach((v, k) => callback.call(thisArg, k, v)); - } - /** - * Iterates through the items in the set. - */ - *keys() { - yield* this._items.keys(); - } - /** - * Iterates through the items in the set. - */ - *values() { - yield* this._items.values(); - } - /** - * Iterates through the items in the set. - */ - *entries() { - yield* this._items.entries(); - } - /** - * Iterates through the items in the set. - */ - *[Symbol.iterator]() { - yield* this._items; - } - /** - * Returns the string tag of the cache. - */ - get [Symbol.toStringTag]() { - return "ObjectCache"; +const subset = (sub, dom, options) => { + if (sub === dom) + return true + + sub = new Range(sub, options) + dom = new Range(dom, options) + let sawNonNull = false + + OUTER: for (const simpleSub of sub.set) { + for (const simpleDom of dom.set) { + const isSub = simpleSubset(simpleSub, simpleDom, options) + sawNonNull = sawNonNull || isSub !== null + if (isSub) + continue OUTER } + // the null set is a subset of everything, but null simple ranges in + // a complex range should be ignored. so if we saw a non-null range, + // then we know this isn't a subset, but if EVERY simple range was null, + // then it is a subset. + if (sawNonNull) + return false + } + return true } -exports.ObjectCache = ObjectCache; -//# sourceMappingURL=ObjectCache.js.map + +const simpleSubset = (sub, dom, options) => { + if (sub === dom) + return true + + if (sub.length === 1 && sub[0].semver === ANY) + return dom.length === 1 && dom[0].semver === ANY + + const eqSet = new Set() + let gt, lt + for (const c of sub) { + if (c.operator === '>' || c.operator === '>=') + gt = higherGT(gt, c, options) + else if (c.operator === '<' || c.operator === '<=') + lt = lowerLT(lt, c, options) + else + eqSet.add(c.semver) + } + + if (eqSet.size > 1) + return null + + let gtltComp + if (gt && lt) { + gtltComp = compare(gt.semver, lt.semver, options) + if (gtltComp > 0) + return null + else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) + return null + } + + // will iterate one or zero times + for (const eq of eqSet) { + if (gt && !satisfies(eq, String(gt), options)) + return null + + if (lt && !satisfies(eq, String(lt), options)) + return null + + for (const c of dom) { + if (!satisfies(eq, String(c), options)) + return false + } + + return true + } + + let higher, lower + let hasDomLT, hasDomGT + for (const c of dom) { + hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=' + hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=' + if (gt) { + if (c.operator === '>' || c.operator === '>=') { + higher = higherGT(gt, c, options) + if (higher === c && higher !== gt) + return false + } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) + return false + } + if (lt) { + if (c.operator === '<' || c.operator === '<=') { + lower = lowerLT(lt, c, options) + if (lower === c && lower !== lt) + return false + } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) + return false + } + if (!c.operator && (lt || gt) && gtltComp !== 0) + return false + } + + // if there was a < or >, and nothing in the dom, then must be false + // UNLESS it was limited by another range in the other direction. + // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0 + if (gt && hasDomLT && !lt && gtltComp !== 0) + return false + + if (lt && hasDomGT && !gt && gtltComp !== 0) + return false + + return true +} + +// >=1.2.3 is lower than >1.2.3 +const higherGT = (a, b, options) => { + if (!a) + return b + const comp = compare(a.semver, b.semver, options) + return comp > 0 ? a + : comp < 0 ? b + : b.operator === '>' && a.operator === '>=' ? b + : a +} + +// <=1.2.3 is higher than <1.2.3 +const lowerLT = (a, b, options) => { + if (!a) + return b + const comp = compare(a.semver, b.semver, options) + return comp < 0 ? a + : comp > 0 ? b + : b.operator === '<' && a.operator === '<=' ? b + : a +} + +module.exports = subset + /***/ }) - -/******/ }); \ No newline at end of file +/******/ ]); \ No newline at end of file diff --git a/dist/setup/unzip b/dist/setup/unzip deleted file mode 100644 index 4082418..0000000 Binary files a/dist/setup/unzip and /dev/null differ diff --git a/docs/advanced-usage.md b/docs/advanced-usage.md new file mode 100644 index 0000000..96d31fb --- /dev/null +++ b/docs/advanced-usage.md @@ -0,0 +1,291 @@ +# Usage +- [Selecting a Java distribution](#Selecting-a-Java-distribution) + - [Adopt](#Adopt) + - [Zulu](#Zulu) +- [Installing custom Java package type](#Installing-custom-Java-package-type) +- [Installing custom Java architecture](#Installing-custom-Java-architecture) +- [Installing custom Java distribution from local file](#Installing-Java-from-local-file) +- [Testing against different Java distributions](#Testing-against-different-Java-distributions) +- [Testing against different platforms](#Testing-against-different-platforms) +- [Publishing using Apache Maven](#Publishing-using-Apache-Maven) +- [Publishing using Gradle](#Publishing-using-Gradle) + +See [action.yml](../action.yml) for more details on task inputs. + +## Selecting a Java distribution +Inputs `java-version` and `distribution` are mandatory and needs to be provided. See [Supported distributions](../README.md#Supported-distributions) for a list of available options. + +### Adopt +```yaml +steps: +- uses: actions/checkout@v2 +- uses: actions/setup-java@v2-preview + with: + distribution: 'adopt' + java-version: '11' +- run: java -cp java HelloWorldApp +``` + +### Zulu +```yaml +steps: +- uses: actions/checkout@v2 +- uses: actions/setup-java@v2-preview + with: + distribution: 'zulu' + java-version: '11' + java-package: jdk # optional (jdk, jre, jdk+fx or jre+fx) - defaults to jdk +- run: java -cp java HelloWorldApp +``` + +## Installing custom Java package type +```yaml +steps: +- uses: actions/checkout@v2 +- uses: actions/setup-java@v2-preview + with: + distribution: '' + java-version: '11' + java-package: jdk # optional (jdk or jre) - defaults to jdk +- run: java -cp java HelloWorldApp +``` + + +## Installing custom Java architecture + +```yaml +steps: +- uses: actions/checkout@v2 +- uses: actions/setup-java@v2-preview + with: + distribution: '' + java-version: '11' + architecture: x86 # optional - defaults to x64 +- run: java -cp java HelloWorldApp +``` + +## Installing Java from local file +If your use-case requires a custom distribution or a version that is not provided by setup-java, you can download it manually and setup-java will take care of the installation and caching on the VM: + +```yaml +steps: +- run: | + download_url="https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.10%2B9/OpenJDK11U-jdk_x64_linux_hotspot_11.0.10_9.tar.gz" + wget -O $RUNNER_TEMP/java_package.tar.gz $download_url +- uses: actions/setup-java@v2-preview + with: + distribution: 'jdkFile' + jdkFile: ${{ runner.temp }}/java_package.tar.gz + java-version: '11.0.0' + architecture: x64 + +- run: java -cp java HelloWorldApp +``` + +## Testing against different Java distributions +**NOTE:** The different distributors can provide discrepant list of available versions / supported configurations. Please refer to the official documentation to see the list of supported versions. +```yaml +jobs: + build: + runs-on: ubuntu-20.04 + strategy: + matrix: + distribution: [ 'zulu', 'adopt' ] + java: [ '8', '11', '13', '15' ] + name: Java ${{ matrix.Java }} (${{ matrix.distribution }}) sample + steps: + - uses: actions/checkout@v2 + - name: Setup java + uses: actions/setup-java@v2-preview + with: + distribution: ${{ matrix.distribution }} + java-version: ${{ matrix.java }} + - run: java -cp java HelloWorldApp +``` + +#### Testing against different platforms +```yaml +jobs: + build: + runs-on: ${{ matrix.os }} + strategy: + matrix: + java: [ '8', '11' ] + os: [ 'ubuntu-latest', 'macos-latest', 'windows-latest' ] + name: Java ${{ matrix.Java }} (${{ matrix.os }}) sample + steps: + - uses: actions/checkout@v2 + - name: Setup java + uses: actions/setup-java@v2-preview + with: + distribution: 'adopt' + java-version: ${{ matrix.java }} + - run: java -cp java HelloWorldApp +``` + +## Publishing using Apache Maven +### Yaml example: +```yaml +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: Set up JDK 11 + uses: actions/setup-java@v2-preview + with: + distribution: '' + java-version: '11' + + - name: Build with Maven + run: mvn -B package --file pom.xml + + - name: Publish to GitHub Packages Apache Maven + run: mvn deploy + env: + GITHUB_TOKEN: ${{ github.token }} # GITHUB_TOKEN is the default env for the password + + - name: Set up Apache Maven Central + uses: actions/setup-java@v2-preview + with: # running setup-java again overwrites the settings.xml + distribution: 'adopt' + java-version: '11' + server-id: maven # Value of the distributionManagement/repository/id field of the pom.xml + server-username: MAVEN_USERNAME # env variable for username in deploy + server-password: MAVEN_CENTRAL_TOKEN # env variable for token in deploy + gpg-private-key: ${{ secrets.MAVEN_GPG_PRIVATE_KEY }} # Value of the GPG private key to import + gpg-passphrase: MAVEN_GPG_PASSPHRASE # env variable for GPG private key passphrase + + - name: Publish to Apache Maven Central + run: mvn deploy + env: + MAVEN_USERNAME: maven_username123 + MAVEN_CENTRAL_TOKEN: ${{ secrets.MAVEN_CENTRAL_TOKEN }} + MAVEN_GPG_PASSPHRASE: ${{ secrets.MAVEN_GPG_PASSPHRASE }} +``` + +The two `settings.xml` files created from the above example look like the following. + +`settings.xml` file created for the first deploy to GitHub Packages +```xml + + + + github + ${env.GITHUB_ACTOR} + ${env.GITHUB_TOKEN} + + + gpg.passphrase + ${env.GPG_PASSPHRASE} + + + +``` + +`settings.xml` file created for the second deploy to Apache Maven Central +```xml + + + + maven + ${env.MAVEN_USERNAME} + ${env.MAVEN_CENTRAL_TOKEN} + + + gpg.passphrase + ${env.MAVEN_GPG_PASSPHRASE} + + + +``` + +***NOTE: The `settings.xml` file is created in the Actions $HOME/.m2 directory. If you have an existing `settings.xml` file at that location, it will be overwritten. See below for using the `settings-path` to change your `settings.xml` file location.*** + +### Extra setup for pom.xml: + +The Maven GPG Plugin configuration in the pom.xml file should contain the following structure to avoid possible issues like `Inappropriate ioctl for device` or `gpg: signing failed: No such file or directory`: + +```xml + + + + --pinentry-mode + loopback + + +``` +GPG 2.1 requires `--pinentry-mode` to be set to `loopback` in order to pick up the `gpg.passphrase` value defined in Maven `settings.xml`. + +### GPG + +If `gpg-private-key` input is provided, the private key will be written to a file in the runner's temp directory, the private key file will be imported into the GPG keychain, and then the file will be promptly removed before proceeding with the rest of the setup process. A cleanup step will remove the imported private key from the GPG keychain after the job completes regardless of the job status. This ensures that the private key is no longer accessible on self-hosted runners and cannot "leak" between jobs (hosted runners are always clean instances). + +**GPG key should be exported by: `gpg --armor --export-secret-keys YOUR_ID`** + +See the help docs on [Publishing a Package](https://help.github.com/en/github/managing-packages-with-github-packages/configuring-apache-maven-for-use-with-github-packages#publishing-a-package) for more information on the `pom.xml` file. + +## Publishing using Gradle +```yaml +jobs: + + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - name: Set up JDK 11 + uses: actions/setup-java@v2-preview + with: + distribution: '' + java-version: '11' + + - name: Build with Gradle + run: gradle build + + - name: Publish to GitHub Packages + run: gradle publish + env: + USERNAME: ${{ github.actor }} + PASSWORD: ${{ secrets.GITHUB_TOKEN }} +``` + +***NOTE: The `USERNAME` and `PASSWORD` need to correspond to the credentials environment variables used in the publishing section of your `build.gradle`.*** + +See the help docs on [Publishing a Package with Gradle](https://help.github.com/en/github/managing-packages-with-github-packages/configuring-gradle-for-use-with-github-packages#example-using-gradle-groovy-for-a-single-package-in-a-repository) for more information on the `build.gradle` configuration file. + +## Apache Maven with a settings path + +When using an Actions self-hosted runner with multiple shared runners the default `$HOME` directory can be shared by a number runners at the same time which could overwrite existing settings file. Setting the `settings-path` variable allows you to choose a unique location for your settings file. + +```yaml +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: Set up JDK 11 for Shared Runner + uses: actions/setup-java@v2-preview + with: + distribution: '' + java-version: '11' + server-id: github # Value of the distributionManagement/repository/id field of the pom.xml + settings-path: ${{ github.workspace }} # location for the settings.xml file + + - name: Build with Maven + run: mvn -B package --file pom.xml + + - name: Publish to GitHub Packages Apache Maven + run: mvn deploy -s $GITHUB_WORKSPACE/settings.xml + env: + GITHUB_TOKEN: ${{ github.token }} +``` diff --git a/docs/switching-to-v2.md b/docs/switching-to-v2.md new file mode 100644 index 0000000..dd38623 --- /dev/null +++ b/docs/switching-to-v2.md @@ -0,0 +1,35 @@ +# Switching to V2 +## Java distribution +The major breaking change in V2 is the new mandatory `distribution` input. This field should be specified with one of supported distributions. See [Supported distributions](../README.md#Supported-distributions) for a list of available options. +Use the `zulu` keyword if you would like to continue using the same distribution as in V1. +```yaml +steps: +- uses: actions/checkout@v2 +- uses: actions/setup-java@v2-preview + with: + distribution: 'zulu' + java-version: '11' + java-package: jdk # optional (jdk or jre) - defaults to jdk +- run: java -cp java HelloWorldApp +``` + +**General recommendation** — configure CI with the same distribution that is used on your local dev machine. + +## Installing custom Java distribution from local file +Since the `distribution` input is required in V2, you should specify it using `jdkFile` to continue installing Java from a local file on the runner +```yaml +steps: +- run: | + download_url="https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.10%2B9/OpenJDK11U-jdk_x64_linux_hotspot_11.0.10_9.tar.gz" + wget -O $RUNNER_TEMP/java_package.tar.gz $download_url +- uses: actions/setup-java@v2-preview + with: + distribution: 'jdkFile' + jdkFile: ${{ runner.temp }}/java_package.tar.gz + java-version: '11.0.0' + architecture: x64 +``` + +## Dropping legacy Java version syntax 1.x +V1 supported legacy Java syntax such as `1.8` (same as `8`) and `1.8.0.212` (same as `8.0.212`). +V2 dropped support for legacy syntax so workflows should be updated accordingly. diff --git a/package-lock.json b/package-lock.json index 7ba66d9..aade7bb 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,6 +1,6 @@ { "name": "setup-java", - "version": "1.0.0", + "version": "2.0.0", "lockfileVersion": 1, "requires": true, "dependencies": { @@ -10,17 +10,17 @@ "integrity": "sha512-ZQYitnqiyBc3D+k7LsgSBmMDVkOVidaagDG7j3fOym77jNunWRuYx7VSHa9GNfFZh+zh61xsCjRj4JxMZlDqTA==" }, "@actions/exec": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/@actions/exec/-/exec-1.0.3.tgz", - "integrity": "sha512-TogJGnueOmM7ntCi0ASTUj4LapRRtDfj57Ja4IhPmg2fls28uVOPbAn8N+JifaOumN2UG3oEO/Ixek2A4NcYSA==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@actions/exec/-/exec-1.0.4.tgz", + "integrity": "sha512-4DPChWow9yc9W3WqEbUj8Nr86xkpyE29ZzWjXucHItclLbEW6jr80Zx4nqv18QL6KK65+cifiQZXvnqgTV6oHw==", "requires": { "@actions/io": "^1.0.1" } }, "@actions/http-client": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-1.0.8.tgz", - "integrity": "sha512-G4JjJ6f9Hb3Zvejj+ewLLKLf99ZC+9v+yCxoYf9vSyH+WkzPLB2LuUtRMGNkooMqdugGBFStIKXOuvH1W+EctA==", + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-1.0.9.tgz", + "integrity": "sha512-0O4SsJ7q+MK0ycvXPl2e6bMXV7dxAXOGjrXS1eTF9s2S401Tp6c/P3c3Joz04QefC1J6Gt942Wl2jbm3f4mLcg==", "requires": { "tunnel": "0.0.6" } @@ -31,69 +31,68 @@ "integrity": "sha512-J8KuFqVPr3p6U8W93DOXlXW6zFvrQAJANdS+vw0YhusLIq+bszW8zmK2Fh1C2kDPX8FMvwIl1OUcFgvJoXLbAg==" }, "@actions/tool-cache": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/@actions/tool-cache/-/tool-cache-1.3.1.tgz", - "integrity": "sha512-sKoEJv0/c7WzjPEq2PO12Sc8QdEp58XIBHMm3c4lUn/iZWgLz9HBeCuFGpLQjDvXJNfLZ4g+WD+rMjgOmpH4Ag==", + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/@actions/tool-cache/-/tool-cache-1.6.1.tgz", + "integrity": "sha512-F+vwEDwfqcHMKuSkj79pihOnsAMv23EkG76nMpc82UsnXwyQdyEsktGxrB0SNtm7pRqTXEIOoAPTgrSQclXYTg==", "requires": { - "@actions/core": "^1.2.0", + "@actions/core": "^1.2.6", "@actions/exec": "^1.0.0", - "@actions/http-client": "^1.0.3", + "@actions/http-client": "^1.0.8", "@actions/io": "^1.0.1", "semver": "^6.1.0", "uuid": "^3.3.2" + }, + "dependencies": { + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + } } }, "@babel/code-frame": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.8.3.tgz", - "integrity": "sha512-a9gxpmdXtZEInkCSHUJDLHZVBgb1QS0jhss4cPP93EW7s+uC5bikET2twEF3KV+7rDblJcmNvTR7VJejqd2C2g==", + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.12.13.tgz", + "integrity": "sha512-HV1Cm0Q3ZrpCR93tkWOYiuYIgLxZXZFVG2VgK+MBWjUqZTundupbfx2aXarXuw5Ko5aMcjtJgbSs4vUGBS5v6g==", "dev": true, "requires": { - "@babel/highlight": "^7.8.3" + "@babel/highlight": "^7.12.13" } }, + "@babel/compat-data": { + "version": "7.13.8", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.13.8.tgz", + "integrity": "sha512-EaI33z19T4qN3xLXsGf48M2cDqa6ei9tPZlfLdb2HC+e/cFtREiRd8hdSqDbwdLB0/+gLwqJmCYASH0z2bUdog==", + "dev": true + }, "@babel/core": { - "version": "7.8.4", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.8.4.tgz", - "integrity": "sha512-0LiLrB2PwrVI+a2/IEskBopDYSd8BCb3rOvH7D5tzoWd696TBEduBvuLVm4Nx6rltrLZqvI3MCalB2K2aVzQjA==", + "version": "7.13.8", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.13.8.tgz", + "integrity": "sha512-oYapIySGw1zGhEFRd6lzWNLWFX2s5dA/jm+Pw/+59ZdXtjyIuwlXbrId22Md0rgZVop+aVoqow2riXhBLNyuQg==", "dev": true, "requires": { - "@babel/code-frame": "^7.8.3", - "@babel/generator": "^7.8.4", - "@babel/helpers": "^7.8.4", - "@babel/parser": "^7.8.4", - "@babel/template": "^7.8.3", - "@babel/traverse": "^7.8.4", - "@babel/types": "^7.8.3", + "@babel/code-frame": "^7.12.13", + "@babel/generator": "^7.13.0", + "@babel/helper-compilation-targets": "^7.13.8", + "@babel/helper-module-transforms": "^7.13.0", + "@babel/helpers": "^7.13.0", + "@babel/parser": "^7.13.4", + "@babel/template": "^7.12.13", + "@babel/traverse": "^7.13.0", + "@babel/types": "^7.13.0", "convert-source-map": "^1.7.0", "debug": "^4.1.0", - "gensync": "^1.0.0-beta.1", - "json5": "^2.1.0", - "lodash": "^4.17.13", - "resolve": "^1.3.2", - "semver": "^5.4.1", + "gensync": "^1.0.0-beta.2", + "json5": "^2.1.2", + "lodash": "^4.17.19", + "semver": "^6.3.0", "source-map": "^0.5.0" }, "dependencies": { - "debug": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", - "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", - "dev": true, - "requires": { - "ms": "^2.1.1" - } - }, - "ms": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", - "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", - "dev": true - }, "semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", "dev": true }, "source-map": { @@ -105,14 +104,13 @@ } }, "@babel/generator": { - "version": "7.8.4", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.8.4.tgz", - "integrity": "sha512-PwhclGdRpNAf3IxZb0YVuITPZmmrXz9zf6fH8lT4XbrmfQKr6ryBzhv593P5C6poJRciFCL/eHGW2NuGrgEyxA==", + "version": "7.13.9", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.13.9.tgz", + "integrity": "sha512-mHOOmY0Axl/JCTkxTU6Lf5sWOg/v8nUa+Xkt4zMTftX0wqmb6Sh7J8gvcehBw7q0AhrhAR+FDacKjCZ2X8K+Sw==", "dev": true, "requires": { - "@babel/types": "^7.8.3", + "@babel/types": "^7.13.0", "jsesc": "^2.5.1", - "lodash": "^4.17.13", "source-map": "^0.5.0" }, "dependencies": { @@ -124,69 +122,290 @@ } } }, - "@babel/helper-function-name": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.8.3.tgz", - "integrity": "sha512-BCxgX1BC2hD/oBlIFUgOCQDOPV8nSINxCwM3o93xP4P9Fq6aV5sgv2cOOITDMtCfQ+3PvHp3l689XZvAM9QyOA==", + "@babel/helper-compilation-targets": { + "version": "7.13.8", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.8.tgz", + "integrity": "sha512-pBljUGC1y3xKLn1nrx2eAhurLMA8OqBtBP/JwG4U8skN7kf8/aqwwxpV1N6T0e7r6+7uNitIa/fUxPFagSXp3A==", "dev": true, "requires": { - "@babel/helper-get-function-arity": "^7.8.3", - "@babel/template": "^7.8.3", - "@babel/types": "^7.8.3" + "@babel/compat-data": "^7.13.8", + "@babel/helper-validator-option": "^7.12.17", + "browserslist": "^4.14.5", + "semver": "^6.3.0" + }, + "dependencies": { + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "dev": true + } + } + }, + "@babel/helper-function-name": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.12.13.tgz", + "integrity": "sha512-TZvmPn0UOqmvi5G4vvw0qZTpVptGkB1GL61R6lKvrSdIxGm5Pky7Q3fpKiIkQCAtRCBUwB0PaThlx9vebCDSwA==", + "dev": true, + "requires": { + "@babel/helper-get-function-arity": "^7.12.13", + "@babel/template": "^7.12.13", + "@babel/types": "^7.12.13" } }, "@babel/helper-get-function-arity": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.8.3.tgz", - "integrity": "sha512-FVDR+Gd9iLjUMY1fzE2SR0IuaJToR4RkCDARVfsBBPSP53GEqSFjD8gNyxg246VUyc/ALRxFaAK8rVG7UT7xRA==", + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.12.13.tgz", + "integrity": "sha512-DjEVzQNz5LICkzN0REdpD5prGoidvbdYk1BVgRUOINaWJP2t6avB27X1guXK1kXNrX0WMfsrm1A/ZBthYuIMQg==", "dev": true, "requires": { - "@babel/types": "^7.8.3" + "@babel/types": "^7.12.13" + } + }, + "@babel/helper-member-expression-to-functions": { + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.13.0.tgz", + "integrity": "sha512-yvRf8Ivk62JwisqV1rFRMxiSMDGnN6KH1/mDMmIrij4jztpQNRoHqqMG3U6apYbGRPJpgPalhva9Yd06HlUxJQ==", + "dev": true, + "requires": { + "@babel/types": "^7.13.0" + } + }, + "@babel/helper-module-imports": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.12.13.tgz", + "integrity": "sha512-NGmfvRp9Rqxy0uHSSVP+SRIW1q31a7Ji10cLBcqSDUngGentY4FRiHOFZFE1CLU5eiL0oE8reH7Tg1y99TDM/g==", + "dev": true, + "requires": { + "@babel/types": "^7.12.13" + } + }, + "@babel/helper-module-transforms": { + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.13.0.tgz", + "integrity": "sha512-Ls8/VBwH577+pw7Ku1QkUWIyRRNHpYlts7+qSqBBFCW3I8QteB9DxfcZ5YJpOwH6Ihe/wn8ch7fMGOP1OhEIvw==", + "dev": true, + "requires": { + "@babel/helper-module-imports": "^7.12.13", + "@babel/helper-replace-supers": "^7.13.0", + "@babel/helper-simple-access": "^7.12.13", + "@babel/helper-split-export-declaration": "^7.12.13", + "@babel/helper-validator-identifier": "^7.12.11", + "@babel/template": "^7.12.13", + "@babel/traverse": "^7.13.0", + "@babel/types": "^7.13.0", + "lodash": "^4.17.19" + } + }, + "@babel/helper-optimise-call-expression": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.12.13.tgz", + "integrity": "sha512-BdWQhoVJkp6nVjB7nkFWcn43dkprYauqtk++Py2eaf/GRDFm5BxRqEIZCiHlZUGAVmtwKcsVL1dC68WmzeFmiA==", + "dev": true, + "requires": { + "@babel/types": "^7.12.13" } }, "@babel/helper-plugin-utils": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.8.3.tgz", - "integrity": "sha512-j+fq49Xds2smCUNYmEHF9kGNkhbet6yVIBp4e6oeQpH1RUs/Ir06xUKzDjDkGcaaokPiTNs2JBWHjaE4csUkZQ==", + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.13.0.tgz", + "integrity": "sha512-ZPafIPSwzUlAoWT8DKs1W2VyF2gOWthGd5NGFMsBcMMol+ZhK+EQY/e6V96poa6PA/Bh+C9plWN0hXO1uB8AfQ==", "dev": true }, - "@babel/helper-split-export-declaration": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.8.3.tgz", - "integrity": "sha512-3x3yOeyBhW851hroze7ElzdkeRXQYQbFIb7gLK1WQYsw2GWDay5gAJNw1sWJ0VFP6z5J1whqeXH/WCdCjZv6dA==", + "@babel/helper-replace-supers": { + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.13.0.tgz", + "integrity": "sha512-Segd5me1+Pz+rmN/NFBOplMbZG3SqRJOBlY+mA0SxAv6rjj7zJqr1AVr3SfzUVTLCv7ZLU5FycOM/SBGuLPbZw==", "dev": true, "requires": { - "@babel/types": "^7.8.3" + "@babel/helper-member-expression-to-functions": "^7.13.0", + "@babel/helper-optimise-call-expression": "^7.12.13", + "@babel/traverse": "^7.13.0", + "@babel/types": "^7.13.0" } }, - "@babel/helpers": { - "version": "7.8.4", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.8.4.tgz", - "integrity": "sha512-VPbe7wcQ4chu4TDQjimHv/5tj73qz88o12EPkO2ValS2QiQS/1F2SsjyIGNnAD0vF/nZS6Cf9i+vW6HIlnaR8w==", + "@babel/helper-simple-access": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.12.13.tgz", + "integrity": "sha512-0ski5dyYIHEfwpWGx5GPWhH35j342JaflmCeQmsPWcrOQDtCN6C1zKAVRFVbK53lPW2c9TsuLLSUDf0tIGJ5hA==", "dev": true, "requires": { - "@babel/template": "^7.8.3", - "@babel/traverse": "^7.8.4", - "@babel/types": "^7.8.3" + "@babel/types": "^7.12.13" + } + }, + "@babel/helper-split-export-declaration": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.12.13.tgz", + "integrity": "sha512-tCJDltF83htUtXx5NLcaDqRmknv652ZWCHyoTETf1CXYJdPC7nohZohjUgieXhv0hTJdRf2FjDueFehdNucpzg==", + "dev": true, + "requires": { + "@babel/types": "^7.12.13" + } + }, + "@babel/helper-validator-identifier": { + "version": "7.12.11", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz", + "integrity": "sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==", + "dev": true + }, + "@babel/helper-validator-option": { + "version": "7.12.17", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.12.17.tgz", + "integrity": "sha512-TopkMDmLzq8ngChwRlyjR6raKD6gMSae4JdYDB8bByKreQgG0RBTuKe9LRxW3wFtUnjxOPRKBDwEH6Mg5KeDfw==", + "dev": true + }, + "@babel/helpers": { + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.13.0.tgz", + "integrity": "sha512-aan1MeFPxFacZeSz6Ld7YZo5aPuqnKlD7+HZY75xQsueczFccP9A7V05+oe0XpLwHK3oLorPe9eaAUljL7WEaQ==", + "dev": true, + "requires": { + "@babel/template": "^7.12.13", + "@babel/traverse": "^7.13.0", + "@babel/types": "^7.13.0" } }, "@babel/highlight": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.8.3.tgz", - "integrity": "sha512-PX4y5xQUvy0fnEVHrYOarRPXVWafSjTW9T0Hab8gVIawpl2Sj0ORyrygANq+KjcNlSSTw0YCLSNA8OyZ1I4yEg==", + "version": "7.13.8", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.13.8.tgz", + "integrity": "sha512-4vrIhfJyfNf+lCtXC2ck1rKSzDwciqF7IWFhXXrSOUC2O5DrVp+w4c6ed4AllTxhTkUP5x2tYj41VaxdVMMRDw==", "dev": true, "requires": { + "@babel/helper-validator-identifier": "^7.12.11", "chalk": "^2.0.0", - "esutils": "^2.0.2", "js-tokens": "^4.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", + "dev": true + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "dev": true + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } } }, "@babel/parser": { - "version": "7.8.4", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.8.4.tgz", - "integrity": "sha512-0fKu/QqildpXmPVaRBoXOlyBb3MC+J0A66x97qEfLOMkn3u6nfY5esWogQwi/K0BjASYy4DbnsEWnpNL6qT5Mw==", + "version": "7.13.9", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.13.9.tgz", + "integrity": "sha512-nEUfRiARCcaVo3ny3ZQjURjHQZUo/JkEw7rLlSZy/psWGnvwXFtPcr6jb7Yb41DVW5LTe6KRq9LGleRNsg1Frw==", "dev": true }, + "@babel/plugin-syntax-async-generators": { + "version": "7.8.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", + "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-bigint": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz", + "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-class-properties": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz", + "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.12.13" + } + }, + "@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", + "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-json-strings": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", + "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-logical-assignment-operators": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", + "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-nullish-coalescing-operator": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", + "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-numeric-separator": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", + "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, "@babel/plugin-syntax-object-rest-spread": { "version": "7.8.3", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", @@ -196,312 +415,353 @@ "@babel/helper-plugin-utils": "^7.8.0" } }, - "@babel/template": { + "@babel/plugin-syntax-optional-catch-binding": { "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.8.3.tgz", - "integrity": "sha512-04m87AcQgAFdvuoyiQ2kgELr2tV8B4fP/xJAVUL3Yb3bkNdMedD3d0rlSQr3PegP0cms3eHjl1F7PWlvWbU8FQ==", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", + "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", "dev": true, "requires": { - "@babel/code-frame": "^7.8.3", - "@babel/parser": "^7.8.3", - "@babel/types": "^7.8.3" + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-optional-chaining": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", + "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-top-level-await": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.12.13.tgz", + "integrity": "sha512-A81F9pDwyS7yM//KwbCSDqy3Uj4NMIurtplxphWxoYtNPov7cJsDkAFNNyVlIZ3jwGycVsurZ+LtOA8gZ376iQ==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.12.13" + } + }, + "@babel/template": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.12.13.tgz", + "integrity": "sha512-/7xxiGA57xMo/P2GVvdEumr8ONhFOhfgq2ihK3h1e6THqzTAkHbkXgB0xI9yeTfIUoH3+oAeHhqm/I43OTbbjA==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.12.13", + "@babel/parser": "^7.12.13", + "@babel/types": "^7.12.13" } }, "@babel/traverse": { - "version": "7.8.4", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.8.4.tgz", - "integrity": "sha512-NGLJPZwnVEyBPLI+bl9y9aSnxMhsKz42so7ApAv9D+b4vAFPpY013FTS9LdKxcABoIYFU52HcYga1pPlx454mg==", + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.13.0.tgz", + "integrity": "sha512-xys5xi5JEhzC3RzEmSGrs/b3pJW/o87SypZ+G/PhaE7uqVQNv/jlmVIBXuoh5atqQ434LfXV+sf23Oxj0bchJQ==", "dev": true, "requires": { - "@babel/code-frame": "^7.8.3", - "@babel/generator": "^7.8.4", - "@babel/helper-function-name": "^7.8.3", - "@babel/helper-split-export-declaration": "^7.8.3", - "@babel/parser": "^7.8.4", - "@babel/types": "^7.8.3", + "@babel/code-frame": "^7.12.13", + "@babel/generator": "^7.13.0", + "@babel/helper-function-name": "^7.12.13", + "@babel/helper-split-export-declaration": "^7.12.13", + "@babel/parser": "^7.13.0", + "@babel/types": "^7.13.0", "debug": "^4.1.0", "globals": "^11.1.0", - "lodash": "^4.17.13" - }, - "dependencies": { - "debug": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", - "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", - "dev": true, - "requires": { - "ms": "^2.1.1" - } - }, - "ms": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", - "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", - "dev": true - } + "lodash": "^4.17.19" } }, "@babel/types": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.8.3.tgz", - "integrity": "sha512-jBD+G8+LWpMBBWvVcdr4QysjUE4mU/syrhN17o1u3gx0/WzJB1kwiVZAXRtWbsIPOwW8pF/YJV5+nmetPzepXg==", + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.13.0.tgz", + "integrity": "sha512-hE+HE8rnG1Z6Wzo+MhaKE5lM5eMx71T4EHJgku2E3xIfaULhDcxiiRxUYgwX8qwP1BBSlag+TdGOt6JAidIZTA==", "dev": true, "requires": { - "esutils": "^2.0.2", - "lodash": "^4.17.13", + "@babel/helper-validator-identifier": "^7.12.11", + "lodash": "^4.17.19", "to-fast-properties": "^2.0.0" } }, + "@bcoe/v8-coverage": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", + "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", + "dev": true + }, "@cnakazawa/watch": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/@cnakazawa/watch/-/watch-1.0.3.tgz", - "integrity": "sha512-r5160ogAvGyHsal38Kux7YYtodEKOj89RGb28ht1jh3SJb08VwRwAKKJL0bGb04Zd/3r9FL3BFIc3bBidYffCA==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@cnakazawa/watch/-/watch-1.0.4.tgz", + "integrity": "sha512-v9kIhKwjeZThiWrLmj0y17CWoyddASLj9O2yvbZkbvw/N3rWOYy9zkV66ursAoVr0mV15bL8g0c4QZUE6cdDoQ==", "dev": true, "requires": { "exec-sh": "^0.3.2", "minimist": "^1.2.0" } }, - "@jest/console": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/@jest/console/-/console-24.9.0.tgz", - "integrity": "sha512-Zuj6b8TnKXi3q4ymac8EQfc3ea/uhLeCGThFqXeC8H9/raaH8ARPUTdId+XyGd03Z4In0/VjD2OYFcBF09fNLQ==", + "@istanbuljs/load-nyc-config": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", + "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==", "dev": true, "requires": { - "@jest/source-map": "^24.9.0", - "chalk": "^2.0.1", - "slash": "^2.0.0" + "camelcase": "^5.3.1", + "find-up": "^4.1.0", + "get-package-type": "^0.1.0", + "js-yaml": "^3.13.1", + "resolve-from": "^5.0.0" + } + }, + "@istanbuljs/schema": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", + "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", + "dev": true + }, + "@jest/console": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/console/-/console-26.6.2.tgz", + "integrity": "sha512-IY1R2i2aLsLr7Id3S6p2BA82GNWryt4oSvEXLAKc+L2zdi89dSkE8xC1C+0kpATG4JhBJREnQOH7/zmccM2B0g==", + "dev": true, + "requires": { + "@jest/types": "^26.6.2", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^26.6.2", + "jest-util": "^26.6.2", + "slash": "^3.0.0" } }, "@jest/core": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/@jest/core/-/core-24.9.0.tgz", - "integrity": "sha512-Fogg3s4wlAr1VX7q+rhV9RVnUv5tD7VuWfYy1+whMiWUrvl7U3QJSJyWcDio9Lq2prqYsZaeTv2Rz24pWGkJ2A==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/@jest/core/-/core-26.6.3.tgz", + "integrity": "sha512-xvV1kKbhfUqFVuZ8Cyo+JPpipAHHAV3kcDBftiduK8EICXmTFddryy3P7NfZt8Pv37rA9nEJBKCCkglCPt/Xjw==", "dev": true, "requires": { - "@jest/console": "^24.7.1", - "@jest/reporters": "^24.9.0", - "@jest/test-result": "^24.9.0", - "@jest/transform": "^24.9.0", - "@jest/types": "^24.9.0", - "ansi-escapes": "^3.0.0", - "chalk": "^2.0.1", + "@jest/console": "^26.6.2", + "@jest/reporters": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/transform": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", "exit": "^0.1.2", - "graceful-fs": "^4.1.15", - "jest-changed-files": "^24.9.0", - "jest-config": "^24.9.0", - "jest-haste-map": "^24.9.0", - "jest-message-util": "^24.9.0", - "jest-regex-util": "^24.3.0", - "jest-resolve": "^24.9.0", - "jest-resolve-dependencies": "^24.9.0", - "jest-runner": "^24.9.0", - "jest-runtime": "^24.9.0", - "jest-snapshot": "^24.9.0", - "jest-util": "^24.9.0", - "jest-validate": "^24.9.0", - "jest-watcher": "^24.9.0", - "micromatch": "^3.1.10", - "p-each-series": "^1.0.0", - "realpath-native": "^1.1.0", - "rimraf": "^2.5.4", - "slash": "^2.0.0", - "strip-ansi": "^5.0.0" + "graceful-fs": "^4.2.4", + "jest-changed-files": "^26.6.2", + "jest-config": "^26.6.3", + "jest-haste-map": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-regex-util": "^26.0.0", + "jest-resolve": "^26.6.2", + "jest-resolve-dependencies": "^26.6.3", + "jest-runner": "^26.6.3", + "jest-runtime": "^26.6.3", + "jest-snapshot": "^26.6.2", + "jest-util": "^26.6.2", + "jest-validate": "^26.6.2", + "jest-watcher": "^26.6.2", + "micromatch": "^4.0.2", + "p-each-series": "^2.1.0", + "rimraf": "^3.0.0", + "slash": "^3.0.0", + "strip-ansi": "^6.0.0" } }, "@jest/environment": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-24.9.0.tgz", - "integrity": "sha512-5A1QluTPhvdIPFYnO3sZC3smkNeXPVELz7ikPbhUj0bQjB07EoE9qtLrem14ZUYWdVayYbsjVwIiL4WBIMV4aQ==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-26.6.2.tgz", + "integrity": "sha512-nFy+fHl28zUrRsCeMB61VDThV1pVTtlEokBRgqPrcT1JNq4yRNIyTHfyht6PqtUvY9IsuLGTrbG8kPXjSZIZwA==", "dev": true, "requires": { - "@jest/fake-timers": "^24.9.0", - "@jest/transform": "^24.9.0", - "@jest/types": "^24.9.0", - "jest-mock": "^24.9.0" + "@jest/fake-timers": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "jest-mock": "^26.6.2" } }, "@jest/fake-timers": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-24.9.0.tgz", - "integrity": "sha512-eWQcNa2YSwzXWIMC5KufBh3oWRIijrQFROsIqt6v/NS9Io/gknw1jsAC9c+ih/RQX4A3O7SeWAhQeN0goKhT9A==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-26.6.2.tgz", + "integrity": "sha512-14Uleatt7jdzefLPYM3KLcnUl1ZNikaKq34enpb5XG9i81JpppDb5muZvonvKyrl7ftEHkKS5L5/eB/kxJ+bvA==", "dev": true, "requires": { - "@jest/types": "^24.9.0", - "jest-message-util": "^24.9.0", - "jest-mock": "^24.9.0" + "@jest/types": "^26.6.2", + "@sinonjs/fake-timers": "^6.0.1", + "@types/node": "*", + "jest-message-util": "^26.6.2", + "jest-mock": "^26.6.2", + "jest-util": "^26.6.2" + } + }, + "@jest/globals": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-26.6.2.tgz", + "integrity": "sha512-85Ltnm7HlB/KesBUuALwQ68YTU72w9H2xW9FjZ1eL1U3lhtefjjl5c2MiUbpXt/i6LaPRvoOFJ22yCBSfQ0JIA==", + "dev": true, + "requires": { + "@jest/environment": "^26.6.2", + "@jest/types": "^26.6.2", + "expect": "^26.6.2" } }, "@jest/reporters": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-24.9.0.tgz", - "integrity": "sha512-mu4X0yjaHrffOsWmVLzitKmmmWSQ3GGuefgNscUSWNiUNcEOSEQk9k3pERKEQVBb0Cnn88+UESIsZEMH3o88Gw==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-26.6.2.tgz", + "integrity": "sha512-h2bW53APG4HvkOnVMo8q3QXa6pcaNt1HkwVsOPMBV6LD/q9oSpxNSYZQYkAnjdMjrJ86UuYeLo+aEZClV6opnw==", "dev": true, "requires": { - "@jest/environment": "^24.9.0", - "@jest/test-result": "^24.9.0", - "@jest/transform": "^24.9.0", - "@jest/types": "^24.9.0", - "chalk": "^2.0.1", + "@bcoe/v8-coverage": "^0.2.3", + "@jest/console": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/transform": "^26.6.2", + "@jest/types": "^26.6.2", + "chalk": "^4.0.0", + "collect-v8-coverage": "^1.0.0", "exit": "^0.1.2", "glob": "^7.1.2", - "istanbul-lib-coverage": "^2.0.2", - "istanbul-lib-instrument": "^3.0.1", - "istanbul-lib-report": "^2.0.4", - "istanbul-lib-source-maps": "^3.0.1", - "istanbul-reports": "^2.2.6", - "jest-haste-map": "^24.9.0", - "jest-resolve": "^24.9.0", - "jest-runtime": "^24.9.0", - "jest-util": "^24.9.0", - "jest-worker": "^24.6.0", - "node-notifier": "^5.4.2", - "slash": "^2.0.0", + "graceful-fs": "^4.2.4", + "istanbul-lib-coverage": "^3.0.0", + "istanbul-lib-instrument": "^4.0.3", + "istanbul-lib-report": "^3.0.0", + "istanbul-lib-source-maps": "^4.0.0", + "istanbul-reports": "^3.0.2", + "jest-haste-map": "^26.6.2", + "jest-resolve": "^26.6.2", + "jest-util": "^26.6.2", + "jest-worker": "^26.6.2", + "node-notifier": "^8.0.0", + "slash": "^3.0.0", "source-map": "^0.6.0", - "string-length": "^2.0.0" + "string-length": "^4.0.1", + "terminal-link": "^2.0.0", + "v8-to-istanbul": "^7.0.0" } }, "@jest/source-map": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-24.9.0.tgz", - "integrity": "sha512-/Xw7xGlsZb4MJzNDgB7PW5crou5JqWiBQaz6xyPd3ArOg2nfn/PunV8+olXbbEZzNl591o5rWKE9BRDaFAuIBg==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-26.6.2.tgz", + "integrity": "sha512-YwYcCwAnNmOVsZ8mr3GfnzdXDAl4LaenZP5z+G0c8bzC9/dugL8zRmxZzdoTl4IaS3CryS1uWnROLPFmb6lVvA==", "dev": true, "requires": { "callsites": "^3.0.0", - "graceful-fs": "^4.1.15", + "graceful-fs": "^4.2.4", "source-map": "^0.6.0" } }, "@jest/test-result": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-24.9.0.tgz", - "integrity": "sha512-XEFrHbBonBJ8dGp2JmF8kP/nQI/ImPpygKHwQ/SY+es59Z3L5PI4Qb9TQQMAEeYsThG1xF0k6tmG0tIKATNiiA==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-26.6.2.tgz", + "integrity": "sha512-5O7H5c/7YlojphYNrK02LlDIV2GNPYisKwHm2QTKjNZeEzezCbwYs9swJySv2UfPMyZ0VdsmMv7jIlD/IKYQpQ==", "dev": true, "requires": { - "@jest/console": "^24.9.0", - "@jest/types": "^24.9.0", - "@types/istanbul-lib-coverage": "^2.0.0" + "@jest/console": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" } }, "@jest/test-sequencer": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-24.9.0.tgz", - "integrity": "sha512-6qqsU4o0kW1dvA95qfNog8v8gkRN9ph6Lz7r96IvZpHdNipP2cBcb07J1Z45mz/VIS01OHJ3pY8T5fUY38tg4A==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-26.6.3.tgz", + "integrity": "sha512-YHlVIjP5nfEyjlrSr8t/YdNfU/1XEt7c5b4OxcXCjyRhjzLYu/rO69/WHPuYcbCWkz8kAeZVZp2N2+IOLLEPGw==", "dev": true, "requires": { - "@jest/test-result": "^24.9.0", - "jest-haste-map": "^24.9.0", - "jest-runner": "^24.9.0", - "jest-runtime": "^24.9.0" + "@jest/test-result": "^26.6.2", + "graceful-fs": "^4.2.4", + "jest-haste-map": "^26.6.2", + "jest-runner": "^26.6.3", + "jest-runtime": "^26.6.3" } }, "@jest/transform": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-24.9.0.tgz", - "integrity": "sha512-TcQUmyNRxV94S0QpMOnZl0++6RMiqpbH/ZMccFB/amku6Uwvyb1cjYX7xkp5nGNkbX4QPH/FcB6q1HBTHynLmQ==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-26.6.2.tgz", + "integrity": "sha512-E9JjhUgNzvuQ+vVAL21vlyfy12gP0GhazGgJC4h6qUt1jSdUXGWJ1wfu/X7Sd8etSgxV4ovT1pb9v5D6QW4XgA==", "dev": true, "requires": { "@babel/core": "^7.1.0", - "@jest/types": "^24.9.0", - "babel-plugin-istanbul": "^5.1.0", - "chalk": "^2.0.1", + "@jest/types": "^26.6.2", + "babel-plugin-istanbul": "^6.0.0", + "chalk": "^4.0.0", "convert-source-map": "^1.4.0", "fast-json-stable-stringify": "^2.0.0", - "graceful-fs": "^4.1.15", - "jest-haste-map": "^24.9.0", - "jest-regex-util": "^24.9.0", - "jest-util": "^24.9.0", - "micromatch": "^3.1.10", + "graceful-fs": "^4.2.4", + "jest-haste-map": "^26.6.2", + "jest-regex-util": "^26.0.0", + "jest-util": "^26.6.2", + "micromatch": "^4.0.2", "pirates": "^4.0.1", - "realpath-native": "^1.1.0", - "slash": "^2.0.0", + "slash": "^3.0.0", "source-map": "^0.6.1", - "write-file-atomic": "2.4.1" + "write-file-atomic": "^3.0.0" } }, "@jest/types": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/@jest/types/-/types-24.9.0.tgz", - "integrity": "sha512-XKK7ze1apu5JWQ5eZjHITP66AX+QsLlbaJRBGYr8pNzwcAE2JVkwnf0yqjHTsDRcjR0mujy/NmZMXw5kl+kGBw==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-26.6.2.tgz", + "integrity": "sha512-fC6QCp7Sc5sX6g8Tvbmj4XUTbyrik0akgRy03yjXbQaBWWNWGE7SGtJk98m0N8nzegD/7SggrUlivxo5ax4KWQ==", "dev": true, "requires": { "@types/istanbul-lib-coverage": "^2.0.0", - "@types/istanbul-reports": "^1.1.1", - "@types/yargs": "^13.0.0" + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^15.0.0", + "chalk": "^4.0.0" } }, "@oozcitak/dom": { - "version": "1.15.5", - "resolved": "https://registry.npmjs.org/@oozcitak/dom/-/dom-1.15.5.tgz", - "integrity": "sha512-L6v3Mwb0TaYBYgeYlIeBaHnc+2ZEaDSbFiRm5KmqZQSoBlbPlf+l6aIH/sD5GUf2MYwULw00LT7+dOnEuAEC0A==", + "version": "1.15.8", + "resolved": "https://registry.npmjs.org/@oozcitak/dom/-/dom-1.15.8.tgz", + "integrity": "sha512-MoOnLBNsF+ok0HjpAvxYxR4piUhRDCEWK0ot3upwOOHYudJd30j6M+LNcE8RKpwfnclAX9T66nXXzkytd29XSw==", "requires": { - "@oozcitak/infra": "1.0.5", - "@oozcitak/url": "1.0.0", - "@oozcitak/util": "8.0.0" - }, - "dependencies": { - "@oozcitak/util": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/@oozcitak/util/-/util-8.0.0.tgz", - "integrity": "sha512-+9Hq6yuoq/3TRV/n/xcpydGBq2qN2/DEDMqNTG7rm95K6ZE2/YY/sPyx62+1n8QsE9O26e5M1URlXsk+AnN9Jw==" - } + "@oozcitak/infra": "1.0.8", + "@oozcitak/url": "1.0.4", + "@oozcitak/util": "8.3.8" } }, "@oozcitak/infra": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/@oozcitak/infra/-/infra-1.0.5.tgz", - "integrity": "sha512-o+zZH7M6l5e3FaAWy3ojaPIVN5eusaYPrKm6MZQt0DKNdgXa2wDYExjpP0t/zx+GoQgQKzLu7cfD8rHCLt8JrQ==", + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@oozcitak/infra/-/infra-1.0.8.tgz", + "integrity": "sha512-JRAUc9VR6IGHOL7OGF+yrvs0LO8SlqGnPAMqyzOuFZPSZSXI7Xf2O9+awQPSMXgIWGtgUf/dA6Hs6X6ySEaWTg==", "requires": { - "@oozcitak/util": "8.0.0" - }, - "dependencies": { - "@oozcitak/util": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/@oozcitak/util/-/util-8.0.0.tgz", - "integrity": "sha512-+9Hq6yuoq/3TRV/n/xcpydGBq2qN2/DEDMqNTG7rm95K6ZE2/YY/sPyx62+1n8QsE9O26e5M1URlXsk+AnN9Jw==" - } + "@oozcitak/util": "8.3.8" } }, "@oozcitak/url": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/@oozcitak/url/-/url-1.0.0.tgz", - "integrity": "sha512-LGrMeSxeLzsdaitxq3ZmBRVOrlRRQIgNNci6L0VRnOKlJFuRIkNm4B+BObXPCJA6JT5bEJtrrwjn30jueHJYZQ==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@oozcitak/url/-/url-1.0.4.tgz", + "integrity": "sha512-kDcD8y+y3FCSOvnBI6HJgl00viO/nGbQoCINmQ0h98OhnGITrWR3bOGfwYCthgcrV8AnTJz8MzslTQbC3SOAmw==", "requires": { - "@oozcitak/infra": "1.0.3", - "@oozcitak/util": "1.0.2" - }, - "dependencies": { - "@oozcitak/infra": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/@oozcitak/infra/-/infra-1.0.3.tgz", - "integrity": "sha512-9O2wxXGnRzy76O1XUxESxDGsXT5kzETJPvYbreO4mv6bqe1+YSuux2cZTagjJ/T4UfEwFJz5ixanOqB0QgYAag==", - "requires": { - "@oozcitak/util": "1.0.1" - }, - "dependencies": { - "@oozcitak/util": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/@oozcitak/util/-/util-1.0.1.tgz", - "integrity": "sha512-dFwFqcKrQnJ2SapOmRD1nQWEZUtbtIy9Y6TyJquzsalWNJsKIPxmTI0KG6Ypyl8j7v89L2wixH9fQDNrF78hKg==" - } - } - }, - "@oozcitak/util": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@oozcitak/util/-/util-1.0.2.tgz", - "integrity": "sha512-4n8B1cWlJleSOSba5gxsMcN4tO8KkkcvXhNWW+ADqvq9Xj+Lrl9uCa90GRpjekqQJyt84aUX015DG81LFpZYXA==" - } + "@oozcitak/infra": "1.0.8", + "@oozcitak/util": "8.3.8" } }, "@oozcitak/util": { - "version": "8.3.3", - "resolved": "https://registry.npmjs.org/@oozcitak/util/-/util-8.3.3.tgz", - "integrity": "sha512-Ufpab7G5PfnEhQyy5kDg9C8ltWJjsVT1P/IYqacjstaqydG4Q21HAT2HUZQYBrC/a1ZLKCz87pfydlDvv8y97w==" + "version": "8.3.8", + "resolved": "https://registry.npmjs.org/@oozcitak/util/-/util-8.3.8.tgz", + "integrity": "sha512-T8TbSnGsxo6TDBJx/Sgv/BlVJL3tshxZP7Aq5R1mSnM5OcHY2dQaxLMu2+E8u3gN0MLOzdjurqN4ZRVuzQycOQ==" + }, + "@sinonjs/commons": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.2.tgz", + "integrity": "sha512-sruwd86RJHdsVf/AtBoijDmUqJp3B6hF/DGC23C+JaegnDHaZyewCjoVGTdg3J0uz3Zs7NnIT05OBOmML72lQw==", + "dev": true, + "requires": { + "type-detect": "4.0.8" + } + }, + "@sinonjs/fake-timers": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-6.0.1.tgz", + "integrity": "sha512-MZPUxrmFubI36XS1DI3qmI0YdN1gks62JtFZvxR67ljjSNCeK6U08Zx4msEWOXuofgqUt6zPHSi1H9fbjR/NRA==", + "dev": true, + "requires": { + "@sinonjs/commons": "^1.7.0" + } }, "@types/babel__core": { - "version": "7.1.3", - "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.1.3.tgz", - "integrity": "sha512-8fBo0UR2CcwWxeX7WIIgJ7lXjasFxoYgRnFHUj+hRvKkpiBJbxhdAPTCY6/ZKM0uxANFVzt4yObSLuTiTnazDA==", + "version": "7.1.12", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.1.12.tgz", + "integrity": "sha512-wMTHiiTiBAAPebqaPiPDLFA4LYPKr6Ph0Xq/6rq1Ur3v66HXyG+clfR9CNETkD7MQS8ZHvpQOtA53DLws5WAEQ==", "dev": true, "requires": { "@babel/parser": "^7.1.0", @@ -512,18 +772,18 @@ } }, "@types/babel__generator": { - "version": "7.6.1", - "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.1.tgz", - "integrity": "sha512-bBKm+2VPJcMRVwNhxKu8W+5/zT7pwNEqeokFOmbvVSqGzFneNxYcEBro9Ac7/N9tlsaPYnZLK8J1LWKkMsLAew==", + "version": "7.6.2", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.2.tgz", + "integrity": "sha512-MdSJnBjl+bdwkLskZ3NGFp9YcXGx5ggLpQQPqtgakVhsWK0hTtNYhjpZLlWQTviGTvF8at+Bvli3jV7faPdgeQ==", "dev": true, "requires": { "@babel/types": "^7.0.0" } }, "@types/babel__template": { - "version": "7.0.2", - "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.0.2.tgz", - "integrity": "sha512-/K6zCpeW7Imzgab2bLkLEbz0+1JlFSrUMdw7KoIIu+IUdu51GWaBZpd3y1VXGVXzynvGa4DaIaxNZHiON3GXUg==", + "version": "7.4.0", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.0.tgz", + "integrity": "sha512-NTPErx4/FiPCGScH7foPyr+/1Dkzkni+rHiYHHoTjvwou7AQzJkNeD60A9CXRy+ZEN2B1bggmkTMCDb+Mv5k+A==", "dev": true, "requires": { "@babel/parser": "^7.1.0", @@ -531,18 +791,27 @@ } }, "@types/babel__traverse": { - "version": "7.0.8", - "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.0.8.tgz", - "integrity": "sha512-yGeB2dHEdvxjP0y4UbRtQaSkXJ9649fYCmIdRoul5kfAoGCwxuCbMhag0k3RPfnuh9kPGm8x89btcfDEXdVWGw==", + "version": "7.11.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.11.0.tgz", + "integrity": "sha512-kSjgDMZONiIfSH1Nxcr5JIRMwUetDki63FSQfpTCz8ogF3Ulqm8+mr5f78dUYs6vMiB6gBusQqfQmBvHZj/lwg==", "dev": true, "requires": { "@babel/types": "^7.3.0" } }, + "@types/graceful-fs": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.5.tgz", + "integrity": "sha512-anKkLmZZ+xm4p8JWBf4hElkM4XR+EZeA2M9BAkkTldmcyDY4mbdIJnRghDJH3Ov5ooY7/UAoENtmdMSkaAd7Cw==", + "dev": true, + "requires": { + "@types/node": "*" + } + }, "@types/istanbul-lib-coverage": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.1.tgz", - "integrity": "sha512-hRJD2ahnnpLgsj6KWMYSrmXkM3rm2Dl1qkx6IOFD5FnuNPXJIG5L0dhgKXCYTRMGzU4n0wImQ/xfmRc4POUFlg==", + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.3.tgz", + "integrity": "sha512-sz7iLqvVUg1gIedBOvlkxPlc8/uVzyS5OwGz1cKjXzkl3FpL3al0crU8YGU1WoHkxn0Wxbw5tyi6hvzJKNzFsw==", "dev": true }, "@types/istanbul-lib-report": { @@ -555,55 +824,67 @@ } }, "@types/istanbul-reports": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-1.1.1.tgz", - "integrity": "sha512-UpYjBi8xefVChsCoBpKShdxTllC9pwISirfoZsUa2AAdQg/Jd2KQGtSbw+ya7GPo7x/wAPlH6JBhKhAsXUEZNA==", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.0.tgz", + "integrity": "sha512-nwKNbvnwJ2/mndE9ItP/zc2TCzw6uuodnF4EHYWD+gCQDVBuRQL5UzbZD0/ezy1iKsFU2ZQiDqg4M9dN4+wZgA==", "dev": true, "requires": { - "@types/istanbul-lib-coverage": "*", "@types/istanbul-lib-report": "*" } }, "@types/jest": { - "version": "24.9.1", - "resolved": "https://registry.npmjs.org/@types/jest/-/jest-24.9.1.tgz", - "integrity": "sha512-Fb38HkXSVA4L8fGKEZ6le5bB8r6MRWlOCZbVuWZcmOMSCd2wCYOwN1ibj8daIoV9naq7aaOZjrLCoCMptKU/4Q==", + "version": "26.0.20", + "resolved": "https://registry.npmjs.org/@types/jest/-/jest-26.0.20.tgz", + "integrity": "sha512-9zi2Y+5USJRxd0FsahERhBwlcvFh6D2GLQnY2FH2BzK8J9s9omvNHIbvABwIluXa0fD8XVKMLTO0aOEuUfACAA==", "dev": true, "requires": { - "jest-diff": "^24.3.0" + "jest-diff": "^26.0.0", + "pretty-format": "^26.0.0" } }, "@types/node": { - "version": "12.12.26", - "resolved": "https://registry.npmjs.org/@types/node/-/node-12.12.26.tgz", - "integrity": "sha512-UmUm94/QZvU5xLcUlNR8hA7Ac+fGpO1EG/a8bcWVz0P0LqtxFmun9Y2bbtuckwGboWJIT70DoWq1r3hb56n3DA==", + "version": "12.20.4", + "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.4.tgz", + "integrity": "sha512-xRCgeE0Q4pT5UZ189TJ3SpYuX/QGl6QIAOAIeDSbAVAd2gX1NxSZup4jNVK7cxIeP8KDSbJgcckun495isP1jQ==", + "dev": true + }, + "@types/normalize-package-data": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.0.tgz", + "integrity": "sha512-f5j5b/Gf71L+dbqxIpQ4Z2WlmI/mPJ0fOkGGmFgtb6sAu97EPczzbS3/tJKxmcYDj55OX6ssqwDAWOHIYDRDGA==", + "dev": true + }, + "@types/prettier": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.2.2.tgz", + "integrity": "sha512-i99hy7Ki19EqVOl77WplDrvgNugHnsSjECVR/wUrzw2TJXz1zlUfT2ngGckR6xN7yFYaijsMAqPkOLx9HgUqHg==", "dev": true }, "@types/semver": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/@types/semver/-/semver-6.2.1.tgz", - "integrity": "sha512-+beqKQOh9PYxuHvijhVl+tIHvT6tuwOrE9m14zd+MT2A38KoKZhh7pYJ0SNleLtwDsiIxHDsIk9bv01oOxvSvA==", + "version": "7.3.4", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.3.4.tgz", + "integrity": "sha512-+nVsLKlcUCeMzD2ufHEYuJ9a2ovstb6Dp52A5VsoKxDXgvE051XgHI/33I1EymwkRGQkwnA0LkhnUzituGs4EQ==", "dev": true }, "@types/stack-utils": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-1.0.1.tgz", - "integrity": "sha512-l42BggppR6zLmpfU6fq9HEa2oGPEI8yrSPL3GITjfRInppYFahObbIQOQK3UGxEnyQpltZLaPe75046NOZQikw==", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.0.tgz", + "integrity": "sha512-RJJrrySY7A8havqpGObOB4W92QXKJo63/jFLLgpvOtsGUqbQZ9Sbgl35KMm1DjC6j7AvmmU2bIno+3IyEaemaw==", "dev": true }, "@types/yargs": { - "version": "13.0.8", - "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-13.0.8.tgz", - "integrity": "sha512-XAvHLwG7UQ+8M4caKIH0ZozIOYay5fQkAgyIXegXT9jPtdIGdhga+sUEdAr1CiG46aB+c64xQEYyEzlwWVTNzA==", + "version": "15.0.13", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-15.0.13.tgz", + "integrity": "sha512-kQ5JNTrbDv3Rp5X2n/iUu37IJBDU2gsZ5R/g1/KHOOEc5IKfUFjXT6DENPGduh08I/pamwtEq4oul7gUqKTQDQ==", "dev": true, "requires": { "@types/yargs-parser": "*" } }, "@types/yargs-parser": { - "version": "15.0.0", - "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-15.0.0.tgz", - "integrity": "sha512-FA/BWv8t8ZWJ+gEOnLLd8ygxH/2UFbAvgEonyfN6yWGLKc7zVjbpl2Y4CTjid9h2RfgPP6SEt6uHwEOply00yw==", + "version": "20.2.0", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-20.2.0.tgz", + "integrity": "sha512-37RSHht+gzzgYeobbG+KWryeAW8J33Nhr69cjTqSYymXVZEN9NbRYWoYlRtDhHKPVT1FyNKwaTPC1NynKZpzRA==", "dev": true }, "@zeit/ncc": { @@ -613,45 +894,37 @@ "dev": true }, "abab": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.3.tgz", - "integrity": "sha512-tsFzPpcttalNjFBCFMqsKYQcWxxen1pgJR56by//QwvJc4/OUS3kPOOttx2tSIfjsylB0pYu7f5D3K1RCxUnUg==", + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.5.tgz", + "integrity": "sha512-9IK9EadsbHo6jLWIpxpR6pL0sazTXV6+SQv25ZB+F7Bj9mJNaOc4nCRabwd5M/JwmUa8idz6Eci6eKfJryPs6Q==", "dev": true }, "acorn": { - "version": "5.7.4", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.7.4.tgz", - "integrity": "sha512-1D++VG7BhrtvQpNbBzovKNc1FLGGEE/oGe7b9xJm/RFHMBeUaUGpluV9RLjZa47YFdPcDAenEYuq9pQPcMdLJg==", + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz", + "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==", "dev": true }, "acorn-globals": { - "version": "4.3.4", - "resolved": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-4.3.4.tgz", - "integrity": "sha512-clfQEh21R+D0leSbUdWf3OcfqyaCSAQ8Ryq00bofSekfr9W8u1jyYZo6ir0xu9Gtcf7BjcHJpnbZH7JOCpP60A==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-6.0.0.tgz", + "integrity": "sha512-ZQl7LOWaF5ePqqcX4hLuv/bLXYQNfNWw2c0/yX/TsPRKamzHcTGQnlCjHT3TsmkOUVEPS3crCxiPfdzE/Trlhg==", "dev": true, "requires": { - "acorn": "^6.0.1", - "acorn-walk": "^6.0.1" - }, - "dependencies": { - "acorn": { - "version": "6.4.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.4.1.tgz", - "integrity": "sha512-ZVA9k326Nwrj3Cj9jlh3wGFutC2ZornPNARZwsNYqQYgN0EsV2d53w5RN/co65Ohn4sUAUtb1rSUAOD6XN9idA==", - "dev": true - } + "acorn": "^7.1.1", + "acorn-walk": "^7.1.1" } }, "acorn-walk": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-6.2.0.tgz", - "integrity": "sha512-7evsyfH1cLOCdAzZAd43Cic04yKydNx0cF+7tiA19p1XnLLPU4dpCQOqpjqwokFe//vS0QqfqqjCS2JkiIs0cA==", + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-7.2.0.tgz", + "integrity": "sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==", "dev": true }, "ajv": { - "version": "6.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.11.0.tgz", - "integrity": "sha512-nCprB/0syFYy9fVYU1ox1l2KN8S9I+tziH8D4zdZuLT3N6RMlGSGt5FSTpAiHB/Whv8Qs1cWHma1aMKZyaHRKA==", + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", "dev": true, "requires": { "fast-deep-equal": "^3.1.1", @@ -661,34 +934,53 @@ } }, "ansi-escapes": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.2.0.tgz", - "integrity": "sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==", - "dev": true + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.1.tgz", + "integrity": "sha512-JWF7ocqNrp8u9oqpgV+wH5ftbt+cfvv+PTjOvKLT3AdYly/LmORARfEVT1iyjwN+4MqE5UmVKoAdIBqeoCHgLA==", + "dev": true, + "requires": { + "type-fest": "^0.11.0" + }, + "dependencies": { + "type-fest": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.11.0.tgz", + "integrity": "sha512-OdjXJxnCN1AvyLSzeKIgXTXxV+99ZuXl3Hpo9XpJAv9MBcHrrJOQ5kV7ypXOuQie+AmWG25hLbiKdwYTifzcfQ==", + "dev": true + } + } }, "ansi-regex": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", - "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", + "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==", "dev": true }, "ansi-styles": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", - "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "^2.0.1" } }, "anymatch": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz", - "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz", + "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==", "dev": true, "requires": { - "micromatch": "^3.1.4", - "normalize-path": "^2.1.1" + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + } + }, + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "requires": { + "sprintf-js": "~1.0.2" } }, "arr-diff": { @@ -709,12 +1001,6 @@ "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=", "dev": true }, - "array-equal": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/array-equal/-/array-equal-1.0.0.tgz", - "integrity": "sha1-jCpe8kcv2ep0KwTHenUJO6J1fJM=", - "dev": true - }, "array-unique": { "version": "0.3.2", "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz", @@ -742,18 +1028,6 @@ "integrity": "sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=", "dev": true }, - "astral-regex": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-1.0.0.tgz", - "integrity": "sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg==", - "dev": true - }, - "async-limiter": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.1.tgz", - "integrity": "sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==", - "dev": true - }, "asynckit": { "version": "0.4.0", "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", @@ -773,55 +1047,80 @@ "dev": true }, "aws4": { - "version": "1.9.1", - "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.9.1.tgz", - "integrity": "sha512-wMHVg2EOHaMRxbzgFJ9gtjOOCrI80OHLG14rxi28XwOW8ux6IiEbRCGGGqCtdAIg4FQCbW20k9RsT4y3gJlFug==", + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.11.0.tgz", + "integrity": "sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA==", "dev": true }, "babel-jest": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-24.9.0.tgz", - "integrity": "sha512-ntuddfyiN+EhMw58PTNL1ph4C9rECiQXjI4nMMBKBaNjXvqLdkXpPRcMSr4iyBrJg/+wz9brFUD6RhOAT6r4Iw==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-26.6.3.tgz", + "integrity": "sha512-pl4Q+GAVOHwvjrck6jKjvmGhnO3jHX/xuB9d27f+EJZ/6k+6nMuPjorrYp7s++bKKdANwzElBWnLWaObvTnaZA==", "dev": true, "requires": { - "@jest/transform": "^24.9.0", - "@jest/types": "^24.9.0", - "@types/babel__core": "^7.1.0", - "babel-plugin-istanbul": "^5.1.0", - "babel-preset-jest": "^24.9.0", - "chalk": "^2.4.2", - "slash": "^2.0.0" + "@jest/transform": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/babel__core": "^7.1.7", + "babel-plugin-istanbul": "^6.0.0", + "babel-preset-jest": "^26.6.2", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.4", + "slash": "^3.0.0" } }, "babel-plugin-istanbul": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-5.2.0.tgz", - "integrity": "sha512-5LphC0USA8t4i1zCtjbbNb6jJj/9+X6P37Qfirc/70EQ34xKlMW+a1RHGwxGI+SwWpNwZ27HqvzAobeqaXwiZw==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.0.0.tgz", + "integrity": "sha512-AF55rZXpe7trmEylbaE1Gv54wn6rwU03aptvRoVIGP8YykoSxqdVLV1TfwflBCE/QtHmqtP8SWlTENqbK8GCSQ==", "dev": true, "requires": { "@babel/helper-plugin-utils": "^7.0.0", - "find-up": "^3.0.0", - "istanbul-lib-instrument": "^3.3.0", - "test-exclude": "^5.2.3" + "@istanbuljs/load-nyc-config": "^1.0.0", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-instrument": "^4.0.0", + "test-exclude": "^6.0.0" } }, "babel-plugin-jest-hoist": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-24.9.0.tgz", - "integrity": "sha512-2EMA2P8Vp7lG0RAzr4HXqtYwacfMErOuv1U3wrvxHX6rD1sV6xS3WXG3r8TRQ2r6w8OhvSdWt+z41hQNwNm3Xw==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-26.6.2.tgz", + "integrity": "sha512-PO9t0697lNTmcEHH69mdtYiOIkkOlj9fySqfO3K1eCcdISevLAE0xY59VLLUj0SoiPiTX/JU2CYFpILydUa5Lw==", "dev": true, "requires": { + "@babel/template": "^7.3.3", + "@babel/types": "^7.3.3", + "@types/babel__core": "^7.0.0", "@types/babel__traverse": "^7.0.6" } }, - "babel-preset-jest": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-24.9.0.tgz", - "integrity": "sha512-izTUuhE4TMfTRPF92fFwD2QfdXaZW08qvWTFCI51V8rW5x00UuPgc3ajRoWofXOuxjfcOM5zzSYsQS3H8KGCAg==", + "babel-preset-current-node-syntax": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz", + "integrity": "sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==", "dev": true, "requires": { - "@babel/plugin-syntax-object-rest-spread": "^7.0.0", - "babel-plugin-jest-hoist": "^24.9.0" + "@babel/plugin-syntax-async-generators": "^7.8.4", + "@babel/plugin-syntax-bigint": "^7.8.3", + "@babel/plugin-syntax-class-properties": "^7.8.3", + "@babel/plugin-syntax-import-meta": "^7.8.3", + "@babel/plugin-syntax-json-strings": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.8.3", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", + "@babel/plugin-syntax-optional-chaining": "^7.8.3", + "@babel/plugin-syntax-top-level-await": "^7.8.3" + } + }, + "babel-preset-jest": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-26.6.2.tgz", + "integrity": "sha512-YvdtlVm9t3k777c5NPQIv6cxFFFapys25HiUmuSgHwIZhfifweR5c5Sf5nwE3MAbfu327CYSvps8Yx6ANLyleQ==", + "dev": true, + "requires": { + "babel-plugin-jest-hoist": "^26.6.2", + "babel-preset-current-node-syntax": "^1.0.0" } }, "balanced-match": { @@ -894,16 +1193,6 @@ "tweetnacl": "^0.14.3" } }, - "bindings": { - "version": "1.5.0", - "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz", - "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==", - "dev": true, - "optional": true, - "requires": { - "file-uri-to-path": "1.0.0" - } - }, "brace-expansion": { "version": "1.1.11", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", @@ -915,55 +1204,31 @@ } }, "braces": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", - "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", "dev": true, "requires": { - "arr-flatten": "^1.1.0", - "array-unique": "^0.3.2", - "extend-shallow": "^2.0.1", - "fill-range": "^4.0.0", - "isobject": "^3.0.1", - "repeat-element": "^1.1.2", - "snapdragon": "^0.8.1", - "snapdragon-node": "^2.0.1", - "split-string": "^3.0.2", - "to-regex": "^3.0.1" - }, - "dependencies": { - "extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - } + "fill-range": "^7.0.1" } }, "browser-process-hrtime": { - "version": "0.1.3", - "resolved": "https://registry.npmjs.org/browser-process-hrtime/-/browser-process-hrtime-0.1.3.tgz", - "integrity": "sha512-bRFnI4NnjO6cnyLmOV/7PVoDEMJChlcfN0z4s1YMBY989/SvlfMI1lgCnkFUs53e9gQF+w7qu7XdllSTiSl8Aw==", + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browser-process-hrtime/-/browser-process-hrtime-1.0.0.tgz", + "integrity": "sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow==", "dev": true }, - "browser-resolve": { - "version": "1.11.3", - "resolved": "https://registry.npmjs.org/browser-resolve/-/browser-resolve-1.11.3.tgz", - "integrity": "sha512-exDi1BYWB/6raKHmDTCicQfTkqwN5fioMFV4j8BsfMU4R2DK/QfZfK7kOVkmWCNANf0snkBzqGqAJBao9gZMdQ==", + "browserslist": { + "version": "4.16.3", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.16.3.tgz", + "integrity": "sha512-vIyhWmIkULaq04Gt93txdh+j02yX/JzlyhLYbV3YQCn/zvES3JnY7TifHHvvr1w5hTDluNKMkV05cs4vy8Q7sw==", "dev": true, "requires": { - "resolve": "1.1.7" - }, - "dependencies": { - "resolve": { - "version": "1.1.7", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz", - "integrity": "sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=", - "dev": true - } + "caniuse-lite": "^1.0.30001181", + "colorette": "^1.2.1", + "electron-to-chromium": "^1.3.649", + "escalade": "^3.1.1", + "node-releases": "^1.1.70" } }, "bs-logger": { @@ -1019,6 +1284,12 @@ "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", "dev": true }, + "caniuse-lite": { + "version": "1.0.30001196", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001196.tgz", + "integrity": "sha512-CPvObjD3ovWrNBaXlAIGWmg2gQQuJ5YhuciUOjPRox6hIQttu8O+b51dx6VIpIY9ESd2d0Vac1RKpICdG4rGUg==", + "dev": true + }, "capture-exit": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/capture-exit/-/capture-exit-2.0.0.tgz", @@ -1035,22 +1306,33 @@ "dev": true }, "chalk": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", - "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.0.tgz", + "integrity": "sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" } }, + "char-regex": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz", + "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", + "dev": true + }, "ci-info": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz", "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==", "dev": true }, + "cjs-module-lexer": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-0.6.0.tgz", + "integrity": "sha512-uc2Vix1frTfnuzxxu1Hp4ktSvM3QaI4oXl4ZUqL1wjTu/BGki9TrCWoqLTg/drR1KwAEarXuRFCG2Svr1GxPFw==", + "dev": true + }, "class-utils": { "version": "0.3.6", "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz", @@ -1075,14 +1357,14 @@ } }, "cliui": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz", - "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz", + "integrity": "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==", "dev": true, "requires": { - "string-width": "^3.1.0", - "strip-ansi": "^5.2.0", - "wrap-ansi": "^5.1.0" + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^6.2.0" } }, "co": { @@ -1091,6 +1373,12 @@ "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=", "dev": true }, + "collect-v8-coverage": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz", + "integrity": "sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg==", + "dev": true + }, "collection-visit": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz", @@ -1102,18 +1390,24 @@ } }, "color-convert": { - "version": "1.9.3", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", - "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "requires": { - "color-name": "1.1.3" + "color-name": "~1.1.4" } }, "color-name": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", - "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", + "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 + }, + "colorette": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-1.2.2.tgz", + "integrity": "sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==", "dev": true }, "combined-stream": { @@ -1180,18 +1474,26 @@ } }, "cssom": { - "version": "0.3.8", - "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.3.8.tgz", - "integrity": "sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==", + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.4.4.tgz", + "integrity": "sha512-p3pvU7r1MyyqbTk+WbNJIgJjG2VmTIaB10rI93LzVPrmDJKkzKYMtxxyAvQXR/NS6otuzveI7+7BBq3SjBS2mw==", "dev": true }, "cssstyle": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-1.4.0.tgz", - "integrity": "sha512-GBrLZYZ4X4x6/QEoBnIrqb8B/f5l4+8me2dkom/j1Gtbxy0kBv6OGzKuAsGM75bkGwGAFkt56Iwg28S3XTZgSA==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-2.3.0.tgz", + "integrity": "sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A==", "dev": true, "requires": { - "cssom": "0.3.x" + "cssom": "~0.3.6" + }, + "dependencies": { + "cssom": { + "version": "0.3.8", + "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.3.8.tgz", + "integrity": "sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==", + "dev": true + } } }, "dashdash": { @@ -1204,36 +1506,23 @@ } }, "data-urls": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-1.1.0.tgz", - "integrity": "sha512-YTWYI9se1P55u58gL5GkQHW4P6VJBJ5iBT+B5a7i2Tjadhv52paJG0qHX4A0OR6/t52odI64KP2YvFpkDOi3eQ==", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-2.0.0.tgz", + "integrity": "sha512-X5eWTSXO/BJmpdIKCRuKUgSCgAN0OwliVK3yPKbwIWU1Tdw5BRajxlzMidvh+gwko9AfQ9zIj52pzF91Q3YAvQ==", "dev": true, "requires": { - "abab": "^2.0.0", - "whatwg-mimetype": "^2.2.0", - "whatwg-url": "^7.0.0" - }, - "dependencies": { - "whatwg-url": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-7.1.0.tgz", - "integrity": "sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==", - "dev": true, - "requires": { - "lodash.sortby": "^4.7.0", - "tr46": "^1.0.1", - "webidl-conversions": "^4.0.2" - } - } + "abab": "^2.0.3", + "whatwg-mimetype": "^2.3.0", + "whatwg-url": "^8.0.0" } }, "debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz", + "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==", "dev": true, "requires": { - "ms": "2.0.0" + "ms": "2.1.2" } }, "decamelize": { @@ -1242,26 +1531,35 @@ "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=", "dev": true }, + "decimal.js": { + "version": "10.2.1", + "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.2.1.tgz", + "integrity": "sha512-KaL7+6Fw6i5A2XSnsbhm/6B+NuEA7TZ4vqxnd5tXz9sbKtrN9Srj8ab4vKVdK8YAqZO9P1kg45Y6YLoduPf+kw==", + "dev": true + }, "decode-uri-component": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz", "integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=", "dev": true }, + "dedent": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/dedent/-/dedent-0.7.0.tgz", + "integrity": "sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=", + "dev": true + }, "deep-is": { "version": "0.1.3", "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=", "dev": true }, - "define-properties": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz", - "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==", - "dev": true, - "requires": { - "object-keys": "^1.0.12" - } + "deepmerge": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.2.2.tgz", + "integrity": "sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==", + "dev": true }, "define-property": { "version": "2.0.2", @@ -1311,24 +1609,32 @@ "dev": true }, "detect-newline": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-2.1.0.tgz", - "integrity": "sha1-9B8cEL5LAOh7XxPaaAdZ8sW/0+I=", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz", + "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", "dev": true }, "diff-sequences": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-24.9.0.tgz", - "integrity": "sha512-Dj6Wk3tWyTE+Fo1rW8v0Xhwk80um6yFYKbuAxc9c3EZxIHFDYwbi34Uk42u1CdnIiVorvt4RmlSDjIPyzGC2ew==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-26.6.2.tgz", + "integrity": "sha512-Mv/TDa3nZ9sbc5soK+OoA74BsS3mL37yixCvUAQkiuA4Wz6YtwP/K47n2rv2ovzHZvoiQeA5FTQOschKkEwB0Q==", "dev": true }, "domexception": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/domexception/-/domexception-1.0.1.tgz", - "integrity": "sha512-raigMkn7CJNNo6Ihro1fzG7wr3fHuYVytzquZKX5n0yizGsTcYgzdIUwj1X9pK0VvjeihV+XiclP+DjwbsSKug==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/domexception/-/domexception-2.0.1.tgz", + "integrity": "sha512-yxJ2mFy/sibVQlu5qHjOkf9J3K6zgmCxgJ94u2EdvDOV09H+32LtRswEcUsmUWN72pVLOEnTSRaIVVzVQgS0dg==", "dev": true, "requires": { - "webidl-conversions": "^4.0.2" + "webidl-conversions": "^5.0.0" + }, + "dependencies": { + "webidl-conversions": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-5.0.0.tgz", + "integrity": "sha512-VlZwKPCkYKxQgeSbH5EyngOmRp7Ww7I9rQLERETtf5ofd9pGeswWiOtogpEO850jziPRarreGxn5QIiTqpb2wA==", + "dev": true + } } }, "ecc-jsbn": { @@ -1341,10 +1647,22 @@ "safer-buffer": "^2.1.0" } }, + "electron-to-chromium": { + "version": "1.3.681", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.681.tgz", + "integrity": "sha512-W6uYvSUTHuyX2DZklIESAqx57jfmGjUkd7Z3RWqLdj9Mmt39ylhBuvFXlskQnvBHj0MYXIeQI+mjiwVddZLSvA==", + "dev": true + }, + "emittery": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.7.2.tgz", + "integrity": "sha512-A8OG5SR/ij3SsJdWDJdkkSYUjQdCUx6APQXem0SaEePBSRg4eymGYwBkKo1Y6DU+af/Jn2dBQqDBvjnr9Vi8nQ==", + "dev": true + }, "emoji-regex": { - "version": "7.0.3", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz", - "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", "dev": true }, "end-of-stream": { @@ -1365,35 +1683,11 @@ "is-arrayish": "^0.2.1" } }, - "es-abstract": { - "version": "1.17.4", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.17.4.tgz", - "integrity": "sha512-Ae3um/gb8F0mui/jPL+QiqmglkUsaQf7FwBEHYIFkztkneosu9imhqHpBzQ3h1vit8t5iQ74t6PEVvphBZiuiQ==", - "dev": true, - "requires": { - "es-to-primitive": "^1.2.1", - "function-bind": "^1.1.1", - "has": "^1.0.3", - "has-symbols": "^1.0.1", - "is-callable": "^1.1.5", - "is-regex": "^1.0.5", - "object-inspect": "^1.7.0", - "object-keys": "^1.1.1", - "object.assign": "^4.1.0", - "string.prototype.trimleft": "^2.1.1", - "string.prototype.trimright": "^2.1.1" - } - }, - "es-to-primitive": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", - "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", - "dev": true, - "requires": { - "is-callable": "^1.1.4", - "is-date-object": "^1.0.1", - "is-symbol": "^1.0.2" - } + "escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true }, "escape-string-regexp": { "version": "1.0.5", @@ -1402,9 +1696,9 @@ "dev": true }, "escodegen": { - "version": "1.14.1", - "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.14.1.tgz", - "integrity": "sha512-Bmt7NcRySdIfNPfU2ZoXDrrXsG9ZjvDxcAlMfDUgRBjLOWTuIACXPBFJH7Z+cLb40JeQco5toikyc9t9P8E9SQ==", + "version": "1.14.3", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.14.3.tgz", + "integrity": "sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==", "dev": true, "requires": { "esprima": "^4.0.1", @@ -1417,8 +1711,7 @@ "esprima": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", - "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", - "dev": true + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==" }, "estraverse": { "version": "4.3.0", @@ -1474,6 +1767,15 @@ "to-regex": "^3.0.1" }, "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, "define-property": { "version": "0.2.5", "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", @@ -1491,21 +1793,27 @@ "requires": { "is-extendable": "^0.1.0" } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true } } }, "expect": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/expect/-/expect-24.9.0.tgz", - "integrity": "sha512-wvVAx8XIol3Z5m9zvZXiyZOQ+sRJqNTIm6sGjdWlaZIeupQGO3WbYI+15D/AmEwZywL6wtJkbAbJtzkOfBuR0Q==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/expect/-/expect-26.6.2.tgz", + "integrity": "sha512-9/hlOBkQl2l/PLHJx6JjoDF6xPKcJEsUlWKb23rKE7KzeDqUZKXKNMW27KIue5JMdBV9HgmoJPcc8HtO85t9IA==", "dev": true, "requires": { - "@jest/types": "^24.9.0", - "ansi-styles": "^3.2.0", - "jest-get-type": "^24.9.0", - "jest-matcher-utils": "^24.9.0", - "jest-message-util": "^24.9.0", - "jest-regex-util": "^24.9.0" + "@jest/types": "^26.6.2", + "ansi-styles": "^4.0.0", + "jest-get-type": "^26.3.0", + "jest-matcher-utils": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-regex-util": "^26.0.0" } }, "extend": { @@ -1607,9 +1915,9 @@ "dev": true }, "fast-deep-equal": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.1.tgz", - "integrity": "sha512-8UEa58QDLauDNfpbrX55Q9jrGHThw2ZMdOky5Gl1CDtVeJDPVrG4Jxx1N8jw2gkWaff5UUuX1KJd+9zGe2B+ZA==", + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", "dev": true }, "fast-json-stable-stringify": { @@ -1633,43 +1941,23 @@ "bser": "2.1.1" } }, - "file-uri-to-path": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", - "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==", - "dev": true, - "optional": true - }, "fill-range": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", - "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", "dev": true, "requires": { - "extend-shallow": "^2.0.1", - "is-number": "^3.0.0", - "repeat-string": "^1.6.1", - "to-regex-range": "^2.1.0" - }, - "dependencies": { - "extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - } + "to-regex-range": "^5.0.1" } }, "find-up": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", - "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", "dev": true, "requires": { - "locate-path": "^3.0.0" + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" } }, "for-in": { @@ -1711,562 +1999,11 @@ "dev": true }, "fsevents": { - "version": "1.2.11", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.11.tgz", - "integrity": "sha512-+ux3lx6peh0BpvY0JebGyZoiR4D+oYzdPZMKJwkZ+sFkNJzpL7tXc/wehS49gUAxg3tmMHPHZkA8JU2rhhgDHw==", + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", "dev": true, - "optional": true, - "requires": { - "bindings": "^1.5.0", - "nan": "^2.12.1", - "node-pre-gyp": "*" - }, - "dependencies": { - "abbrev": { - "version": "1.1.1", - "bundled": true, - "dev": true, - "optional": true - }, - "ansi-regex": { - "version": "2.1.1", - "bundled": true, - "dev": true, - "optional": true - }, - "aproba": { - "version": "1.2.0", - "bundled": true, - "dev": true, - "optional": true - }, - "are-we-there-yet": { - "version": "1.1.5", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "delegates": "^1.0.0", - "readable-stream": "^2.0.6" - } - }, - "balanced-match": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "brace-expansion": { - "version": "1.1.11", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "balanced-match": "^1.0.0", - "concat-map": "0.0.1" - } - }, - "chownr": { - "version": "1.1.3", - "bundled": true, - "dev": true, - "optional": true - }, - "code-point-at": { - "version": "1.1.0", - "bundled": true, - "dev": true, - "optional": true - }, - "concat-map": { - "version": "0.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "console-control-strings": { - "version": "1.1.0", - "bundled": true, - "dev": true, - "optional": true - }, - "core-util-is": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "debug": { - "version": "3.2.6", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "ms": "^2.1.1" - } - }, - "deep-extend": { - "version": "0.6.0", - "bundled": true, - "dev": true, - "optional": true - }, - "delegates": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "detect-libc": { - "version": "1.0.3", - "bundled": true, - "dev": true, - "optional": true - }, - "fs-minipass": { - "version": "1.2.7", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "minipass": "^2.6.0" - } - }, - "fs.realpath": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "gauge": { - "version": "2.7.4", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "aproba": "^1.0.3", - "console-control-strings": "^1.0.0", - "has-unicode": "^2.0.0", - "object-assign": "^4.1.0", - "signal-exit": "^3.0.0", - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1", - "wide-align": "^1.1.0" - } - }, - "glob": { - "version": "7.1.6", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - } - }, - "has-unicode": { - "version": "2.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "iconv-lite": { - "version": "0.4.24", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "safer-buffer": ">= 2.1.2 < 3" - } - }, - "ignore-walk": { - "version": "3.0.3", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "minimatch": "^3.0.4" - } - }, - "inflight": { - "version": "1.0.6", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "once": "^1.3.0", - "wrappy": "1" - } - }, - "inherits": { - "version": "2.0.4", - "bundled": true, - "dev": true, - "optional": true - }, - "ini": { - "version": "1.3.5", - "bundled": true, - "dev": true, - "optional": true - }, - "is-fullwidth-code-point": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "number-is-nan": "^1.0.0" - } - }, - "isarray": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "minimatch": { - "version": "3.0.4", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "brace-expansion": "^1.1.7" - } - }, - "minimist": { - "version": "0.0.8", - "bundled": true, - "dev": true, - "optional": true - }, - "minipass": { - "version": "2.9.0", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "safe-buffer": "^5.1.2", - "yallist": "^3.0.0" - } - }, - "minizlib": { - "version": "1.3.3", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "minipass": "^2.9.0" - } - }, - "mkdirp": { - "version": "0.5.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "minimist": "0.0.8" - } - }, - "ms": { - "version": "2.1.2", - "bundled": true, - "dev": true, - "optional": true - }, - "needle": { - "version": "2.4.0", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "debug": "^3.2.6", - "iconv-lite": "^0.4.4", - "sax": "^1.2.4" - } - }, - "node-pre-gyp": { - "version": "0.14.0", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "detect-libc": "^1.0.2", - "mkdirp": "^0.5.1", - "needle": "^2.2.1", - "nopt": "^4.0.1", - "npm-packlist": "^1.1.6", - "npmlog": "^4.0.2", - "rc": "^1.2.7", - "rimraf": "^2.6.1", - "semver": "^5.3.0", - "tar": "^4.4.2" - } - }, - "nopt": { - "version": "4.0.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "abbrev": "1", - "osenv": "^0.1.4" - } - }, - "npm-bundled": { - "version": "1.1.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "npm-normalize-package-bin": "^1.0.1" - } - }, - "npm-normalize-package-bin": { - "version": "1.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "npm-packlist": { - "version": "1.4.7", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "ignore-walk": "^3.0.1", - "npm-bundled": "^1.0.1" - } - }, - "npmlog": { - "version": "4.1.2", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "are-we-there-yet": "~1.1.2", - "console-control-strings": "~1.1.0", - "gauge": "~2.7.3", - "set-blocking": "~2.0.0" - } - }, - "number-is-nan": { - "version": "1.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "object-assign": { - "version": "4.1.1", - "bundled": true, - "dev": true, - "optional": true - }, - "once": { - "version": "1.4.0", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "wrappy": "1" - } - }, - "os-homedir": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "os-tmpdir": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "osenv": { - "version": "0.1.5", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "os-homedir": "^1.0.0", - "os-tmpdir": "^1.0.0" - } - }, - "path-is-absolute": { - "version": "1.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "process-nextick-args": { - "version": "2.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "rc": { - "version": "1.2.8", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "deep-extend": "^0.6.0", - "ini": "~1.3.0", - "minimist": "^1.2.0", - "strip-json-comments": "~2.0.1" - }, - "dependencies": { - "minimist": { - "version": "1.2.0", - "bundled": true, - "dev": true, - "optional": true - } - } - }, - "readable-stream": { - "version": "2.3.6", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" - } - }, - "rimraf": { - "version": "2.7.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "glob": "^7.1.3" - } - }, - "safe-buffer": { - "version": "5.1.2", - "bundled": true, - "dev": true, - "optional": true - }, - "safer-buffer": { - "version": "2.1.2", - "bundled": true, - "dev": true, - "optional": true - }, - "sax": { - "version": "1.2.4", - "bundled": true, - "dev": true, - "optional": true - }, - "semver": { - "version": "5.7.1", - "bundled": true, - "dev": true, - "optional": true - }, - "set-blocking": { - "version": "2.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "signal-exit": { - "version": "3.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "string-width": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "code-point-at": "^1.0.0", - "is-fullwidth-code-point": "^1.0.0", - "strip-ansi": "^3.0.0" - } - }, - "string_decoder": { - "version": "1.1.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "safe-buffer": "~5.1.0" - } - }, - "strip-ansi": { - "version": "3.0.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "ansi-regex": "^2.0.0" - } - }, - "strip-json-comments": { - "version": "2.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "tar": { - "version": "4.4.13", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "chownr": "^1.1.1", - "fs-minipass": "^1.2.5", - "minipass": "^2.8.6", - "minizlib": "^1.2.1", - "mkdirp": "^0.5.0", - "safe-buffer": "^5.1.2", - "yallist": "^3.0.3" - } - }, - "util-deprecate": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "wide-align": { - "version": "1.1.3", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "string-width": "^1.0.2 || 2" - } - }, - "wrappy": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "yallist": { - "version": "3.1.1", - "bundled": true, - "dev": true, - "optional": true - } - } + "optional": true }, "function-bind": { "version": "1.1.1", @@ -2275,9 +2012,9 @@ "dev": true }, "gensync": { - "version": "1.0.0-beta.1", - "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.1.tgz", - "integrity": "sha512-r8EC6NO1sngH/zdD9fiRDLdcgnbayXah+mLgManTaIZJqEC1MZstmnox8KpnI2/fxQwrp5OpCOYWLp4rBl4Jcg==", + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", "dev": true }, "get-caller-file": { @@ -2286,6 +2023,12 @@ "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", "dev": true }, + "get-package-type": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", + "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", + "dev": true + }, "get-stream": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz", @@ -2331,16 +2074,17 @@ "dev": true }, "graceful-fs": { - "version": "4.2.3", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.3.tgz", - "integrity": "sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==", + "version": "4.2.6", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.6.tgz", + "integrity": "sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==", "dev": true }, "growly": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/growly/-/growly-1.3.0.tgz", "integrity": "sha1-8QdIy+dq+WS3yWyTxrzCivEgwIE=", - "dev": true + "dev": true, + "optional": true }, "har-schema": { "version": "2.0.0", @@ -2349,12 +2093,12 @@ "dev": true }, "har-validator": { - "version": "5.1.3", - "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.3.tgz", - "integrity": "sha512-sNvOCzEQNr/qrvJgc3UG/kD4QtlHycrzwS+6mfTrrSq97BvaYcPZZI1ZSqGSPR73Cxn4LKTD4PttRwfU7jWq5g==", + "version": "5.1.5", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz", + "integrity": "sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==", "dev": true, "requires": { - "ajv": "^6.5.5", + "ajv": "^6.12.3", "har-schema": "^2.0.0" } }, @@ -2368,15 +2112,9 @@ } }, "has-flag": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", - "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", - "dev": true - }, - "has-symbols": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.1.tgz", - "integrity": "sha512-PLcsoqu++dmEIZB+6totNFKq/7Do+Z0u4oT0zKOJNl3lYK6vGwwu2hjHs+68OEZbTjiUE9bgOABXbP/GvrS0Kg==", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true }, "has-value": { @@ -2400,6 +2138,26 @@ "kind-of": "^4.0.0" }, "dependencies": { + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, "kind-of": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", @@ -2412,24 +2170,24 @@ } }, "hosted-git-info": { - "version": "2.8.5", - "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.5.tgz", - "integrity": "sha512-kssjab8CvdXfcXMXVcvsXum4Hwdq9XGtRD3TteMEvEbq0LXyiNQr6AprqKqfeaDXze7SxWvRxdpwE6ku7ikLkg==", + "version": "2.8.8", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.8.tgz", + "integrity": "sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg==", "dev": true }, "html-encoding-sniffer": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-1.0.2.tgz", - "integrity": "sha512-71lZziiDnsuabfdYiUeWdCVyKuqwWi23L8YeIgV9jSSZHCtb6wB1BKWooH7L3tn4/FuZJMVWyNaIDr4RGmaSYw==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-2.0.1.tgz", + "integrity": "sha512-D5JbOMBIR/TVZkubHT+OyT2705QvogUW4IBn6nHd756OwieSF9aDYFj4dv6HHEVGYbHaLETa3WggZYWWMyy3ZQ==", "dev": true, "requires": { - "whatwg-encoding": "^1.0.1" + "whatwg-encoding": "^1.0.5" } }, "html-escaper": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.0.tgz", - "integrity": "sha512-a4u9BeERWGu/S8JiWEAQcdrg9v4QArtP9keViQjGMdff20fBdd8waotXaNmODqBe6uZ3Nafi7K/ho4gCQHV3Ig==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", "dev": true }, "http-signature": { @@ -2443,6 +2201,12 @@ "sshpk": "^1.7.0" } }, + "human-signals": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-1.1.1.tgz", + "integrity": "sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==", + "dev": true + }, "iconv-lite": { "version": "0.4.24", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", @@ -2453,13 +2217,13 @@ } }, "import-local": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/import-local/-/import-local-2.0.0.tgz", - "integrity": "sha512-b6s04m3O+s3CGSbqDIyP4R6aAwAeYlVq9+WUWep6iHa8ETRf9yei1U48C5MmfJmV9AiLYYBKPMq/W+/WRpQmCQ==", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.0.2.tgz", + "integrity": "sha512-vjL3+w0oulAVZ0hBHnxa/Nm5TAurf9YLQJDhqRZyqb+VKGOB6LU8t9H1Nr5CIo16vh9XfJTOoHwU0B71S557gA==", "dev": true, "requires": { - "pkg-dir": "^3.0.0", - "resolve-cwd": "^2.0.0" + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" } }, "imurmurhash": { @@ -2484,14 +2248,11 @@ "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", "dev": true }, - "invariant": { - "version": "2.2.4", - "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz", - "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==", - "dev": true, - "requires": { - "loose-envify": "^1.0.0" - } + "ip-regex": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/ip-regex/-/ip-regex-2.1.0.tgz", + "integrity": "sha1-+ni/XS5pE8kRzp+BnuUUa7bYROk=", + "dev": true }, "is-accessor-descriptor": { "version": "0.1.6", @@ -2525,12 +2286,6 @@ "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", "dev": true }, - "is-callable": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.5.tgz", - "integrity": "sha512-ESKv5sMCJB2jnHTWZ3O5itG+O128Hsus4K4Qh1h2/cgn2vbgnLSVqfV46AeJA9D5EeeLa9w81KUXMtn34zhX+Q==", - "dev": true - }, "is-ci": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-2.0.0.tgz", @@ -2540,6 +2295,15 @@ "ci-info": "^2.0.0" } }, + "is-core-module": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz", + "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==", + "dev": true, + "requires": { + "has": "^1.0.3" + } + }, "is-data-descriptor": { "version": "0.1.4", "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", @@ -2560,12 +2324,6 @@ } } }, - "is-date-object": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.2.tgz", - "integrity": "sha512-USlDT524woQ08aoZFzh3/Z6ch9Y/EWXEHQ/AaRN0SkKq4t2Jw2R2339tSXmwuVoY7LLlBCbOIlx2myP/L5zk0g==", - "dev": true - }, "is-descriptor": { "version": "0.1.6", "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", @@ -2585,6 +2343,13 @@ } } }, + "is-docker": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.1.1.tgz", + "integrity": "sha512-ZOoqiXfEwtGknTiuDEy8pN2CfE3TxMHprvNer1mXiqwkOT77Rw3YVrUQ52EqAOU3QAWDQ+bQdx7HJzrv7LS2Hw==", + "dev": true, + "optional": true + }, "is-extendable": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", @@ -2592,9 +2357,9 @@ "dev": true }, "is-fullwidth-code-point": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", - "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "dev": true }, "is-generator-fn": { @@ -2604,24 +2369,10 @@ "dev": true }, "is-number": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", - "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true }, "is-plain-object": { "version": "2.0.4", @@ -2632,14 +2383,11 @@ "isobject": "^3.0.1" } }, - "is-regex": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.5.tgz", - "integrity": "sha512-vlKW17SNq44owv5AQR3Cq0bQPEb8+kF3UKZ2fiZNOWtztYE5i0CzCZxFDwO58qAOWtxdBRVO/V5Qin1wjCqFYQ==", - "dev": true, - "requires": { - "has": "^1.0.3" - } + "is-potential-custom-element-name": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.0.tgz", + "integrity": "sha1-DFLlS8yjkbssSUsh6GJtczbG45c=", + "dev": true }, "is-stream": { "version": "1.1.0", @@ -2647,15 +2395,6 @@ "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=", "dev": true }, - "is-symbol": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.3.tgz", - "integrity": "sha512-OwijhaRSgqvhm/0ZdAcXNZt9lYdKFpcRDT5ULUuYXPoT794UNOdU+gpT6Rzo7b4V2HUl/op6GqY894AZwv9faQ==", - "dev": true, - "requires": { - "has-symbols": "^1.0.1" - } - }, "is-typedarray": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", @@ -2669,10 +2408,14 @@ "dev": true }, "is-wsl": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-1.1.0.tgz", - "integrity": "sha1-HxbkqiKwTRM2tmGIpmrzxgDDpm0=", - "dev": true + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz", + "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==", + "dev": true, + "optional": true, + "requires": { + "is-docker": "^2.0.0" + } }, "isarray": { "version": "1.0.0", @@ -2699,527 +2442,609 @@ "dev": true }, "istanbul-lib-coverage": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.5.tgz", - "integrity": "sha512-8aXznuEPCJvGnMSRft4udDRDtb1V3pkQkMMI5LI+6HuQz5oQ4J2UFn1H82raA3qJtyOLkkwVqICBQkjnGtn5mA==", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.0.0.tgz", + "integrity": "sha512-UiUIqxMgRDET6eR+o5HbfRYP1l0hqkWOs7vNxC/mggutCMUIhWMm8gAHb8tHlyfD3/l6rlgNA5cKdDzEAf6hEg==", "dev": true }, "istanbul-lib-instrument": { - "version": "3.3.0", - "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-3.3.0.tgz", - "integrity": "sha512-5nnIN4vo5xQZHdXno/YDXJ0G+I3dAm4XgzfSVTPLQpj/zAV2dV6Juy0yaf10/zrJOJeHoN3fraFe+XRq2bFVZA==", + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-4.0.3.tgz", + "integrity": "sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==", "dev": true, "requires": { - "@babel/generator": "^7.4.0", - "@babel/parser": "^7.4.3", - "@babel/template": "^7.4.0", - "@babel/traverse": "^7.4.3", - "@babel/types": "^7.4.0", - "istanbul-lib-coverage": "^2.0.5", - "semver": "^6.0.0" - } - }, - "istanbul-lib-report": { - "version": "2.0.8", - "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-2.0.8.tgz", - "integrity": "sha512-fHBeG573EIihhAblwgxrSenp0Dby6tJMFR/HvlerBsrCTD5bkUuoNtn3gVh29ZCS824cGGBPn7Sg7cNk+2xUsQ==", - "dev": true, - "requires": { - "istanbul-lib-coverage": "^2.0.5", - "make-dir": "^2.1.0", - "supports-color": "^6.1.0" + "@babel/core": "^7.7.5", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-coverage": "^3.0.0", + "semver": "^6.3.0" }, "dependencies": { - "supports-color": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.1.0.tgz", - "integrity": "sha512-qe1jfm1Mg7Nq/NSh6XE24gPXROEVsWHxC1LIx//XNlD9iw7YZQGjZNjYN7xGaEG6iKdA8EtNFW6R0gjnVXp+wQ==", - "dev": true, - "requires": { - "has-flag": "^3.0.0" - } - } - } - }, - "istanbul-lib-source-maps": { - "version": "3.0.6", - "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-3.0.6.tgz", - "integrity": "sha512-R47KzMtDJH6X4/YW9XTx+jrLnZnscW4VpNN+1PViSYTejLVPWv7oov+Duf8YQSPyVRUvueQqz1TcsC6mooZTXw==", - "dev": true, - "requires": { - "debug": "^4.1.1", - "istanbul-lib-coverage": "^2.0.5", - "make-dir": "^2.1.0", - "rimraf": "^2.6.3", - "source-map": "^0.6.1" - }, - "dependencies": { - "debug": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", - "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", - "dev": true, - "requires": { - "ms": "^2.1.1" - } - }, - "ms": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", - "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", "dev": true } } }, - "istanbul-reports": { - "version": "2.2.7", - "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-2.2.7.tgz", - "integrity": "sha512-uu1F/L1o5Y6LzPVSVZXNOoD/KXpJue9aeLRd0sM9uMXfZvzomB0WxVamWb5ue8kA2vVWEmW7EG+A5n3f1kqHKg==", + "istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==", "dev": true, "requires": { - "html-escaper": "^2.0.0" + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^3.0.0", + "supports-color": "^7.1.0" + } + }, + "istanbul-lib-source-maps": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.0.tgz", + "integrity": "sha512-c16LpFRkR8vQXyHZ5nLpY35JZtzj1PQY1iZmesUbf1FZHbIupcWfjgOXBY9YHkLEQ6puz1u4Dgj6qmU/DisrZg==", + "dev": true, + "requires": { + "debug": "^4.1.1", + "istanbul-lib-coverage": "^3.0.0", + "source-map": "^0.6.1" + } + }, + "istanbul-reports": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.0.2.tgz", + "integrity": "sha512-9tZvz7AiR3PEDNGiV9vIouQ/EAcqMXFmkcA1CDFTwOB98OZVDL0PH9glHotf5Ugp6GCOTypfzGWI/OqjWNCRUw==", + "dev": true, + "requires": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" } }, "jest": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest/-/jest-24.9.0.tgz", - "integrity": "sha512-YvkBL1Zm7d2B1+h5fHEOdyjCG+sGMz4f8D86/0HiqJ6MB4MnDc8FgP5vdWsGnemOQro7lnYo8UakZ3+5A0jxGw==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest/-/jest-26.6.3.tgz", + "integrity": "sha512-lGS5PXGAzR4RF7V5+XObhqz2KZIDUA1yD0DG6pBVmy10eh0ZIXQImRuzocsI/N2XZ1GrLFwTS27In2i2jlpq1Q==", "dev": true, "requires": { - "import-local": "^2.0.0", - "jest-cli": "^24.9.0" + "@jest/core": "^26.6.3", + "import-local": "^3.0.2", + "jest-cli": "^26.6.3" }, "dependencies": { "jest-cli": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-24.9.0.tgz", - "integrity": "sha512-+VLRKyitT3BWoMeSUIHRxV/2g8y9gw91Jh5z2UmXZzkZKpbC08CSehVxgHUwTpy+HwGcns/tqafQDJW7imYvGg==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-26.6.3.tgz", + "integrity": "sha512-GF9noBSa9t08pSyl3CY4frMrqp+aQXFGFkf5hEPbh/pIUFYWMK6ZLTfbmadxJVcJrdRoChlWQsA2VkJcDFK8hg==", "dev": true, "requires": { - "@jest/core": "^24.9.0", - "@jest/test-result": "^24.9.0", - "@jest/types": "^24.9.0", - "chalk": "^2.0.1", + "@jest/core": "^26.6.3", + "@jest/test-result": "^26.6.2", + "@jest/types": "^26.6.2", + "chalk": "^4.0.0", "exit": "^0.1.2", - "import-local": "^2.0.0", + "graceful-fs": "^4.2.4", + "import-local": "^3.0.2", "is-ci": "^2.0.0", - "jest-config": "^24.9.0", - "jest-util": "^24.9.0", - "jest-validate": "^24.9.0", + "jest-config": "^26.6.3", + "jest-util": "^26.6.2", + "jest-validate": "^26.6.2", "prompts": "^2.0.1", - "realpath-native": "^1.1.0", - "yargs": "^13.3.0" + "yargs": "^15.4.1" } } } }, "jest-changed-files": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-24.9.0.tgz", - "integrity": "sha512-6aTWpe2mHF0DhL28WjdkO8LyGjs3zItPET4bMSeXU6T3ub4FPMw+mcOcbdGXQOAfmLcxofD23/5Bl9Z4AkFwqg==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-26.6.2.tgz", + "integrity": "sha512-fDS7szLcY9sCtIip8Fjry9oGf3I2ht/QT21bAHm5Dmf0mD4X3ReNUf17y+bO6fR8WgbIZTlbyG1ak/53cbRzKQ==", "dev": true, "requires": { - "@jest/types": "^24.9.0", - "execa": "^1.0.0", - "throat": "^4.0.0" + "@jest/types": "^26.6.2", + "execa": "^4.0.0", + "throat": "^5.0.0" + }, + "dependencies": { + "cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dev": true, + "requires": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + } + }, + "execa": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-4.1.0.tgz", + "integrity": "sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==", + "dev": true, + "requires": { + "cross-spawn": "^7.0.0", + "get-stream": "^5.0.0", + "human-signals": "^1.1.1", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.0", + "onetime": "^5.1.0", + "signal-exit": "^3.0.2", + "strip-final-newline": "^2.0.0" + } + }, + "get-stream": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", + "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "dev": true, + "requires": { + "pump": "^3.0.0" + } + }, + "is-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.0.tgz", + "integrity": "sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==", + "dev": true + }, + "npm-run-path": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", + "dev": true, + "requires": { + "path-key": "^3.0.0" + } + }, + "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 + }, + "shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "requires": { + "shebang-regex": "^3.0.0" + } + }, + "shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true + }, + "which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "requires": { + "isexe": "^2.0.0" + } + } } }, "jest-circus": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-24.9.0.tgz", - "integrity": "sha512-dwkvwFtRc9Anmk1XTc+bonVL8rVMZ3CeGMoFWmv1oaQThdAgvfI9bwaFlZp+gLVphNVz6ZLfCWo3ERhS5CeVvA==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-26.6.3.tgz", + "integrity": "sha512-ACrpWZGcQMpbv13XbzRzpytEJlilP/Su0JtNCi5r/xLpOUhnaIJr8leYYpLEMgPFURZISEHrnnpmB54Q/UziPw==", "dev": true, "requires": { "@babel/traverse": "^7.1.0", - "@jest/environment": "^24.9.0", - "@jest/test-result": "^24.9.0", - "@jest/types": "^24.9.0", - "chalk": "^2.0.1", + "@jest/environment": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/babel__traverse": "^7.0.4", + "@types/node": "*", + "chalk": "^4.0.0", "co": "^4.6.0", - "expect": "^24.9.0", + "dedent": "^0.7.0", + "expect": "^26.6.2", "is-generator-fn": "^2.0.0", - "jest-each": "^24.9.0", - "jest-matcher-utils": "^24.9.0", - "jest-message-util": "^24.9.0", - "jest-snapshot": "^24.9.0", - "jest-util": "^24.9.0", - "pretty-format": "^24.9.0", - "stack-utils": "^1.0.1", - "throat": "^4.0.0" + "jest-each": "^26.6.2", + "jest-matcher-utils": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-runner": "^26.6.3", + "jest-runtime": "^26.6.3", + "jest-snapshot": "^26.6.2", + "jest-util": "^26.6.2", + "pretty-format": "^26.6.2", + "stack-utils": "^2.0.2", + "throat": "^5.0.0" } }, "jest-config": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-24.9.0.tgz", - "integrity": "sha512-RATtQJtVYQrp7fvWg6f5y3pEFj9I+H8sWw4aKxnDZ96mob5i5SD6ZEGWgMLXQ4LE8UurrjbdlLWdUeo+28QpfQ==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-26.6.3.tgz", + "integrity": "sha512-t5qdIj/bCj2j7NFVHb2nFB4aUdfucDn3JRKgrZnplb8nieAirAzRSHP8uDEd+qV6ygzg9Pz4YG7UTJf94LPSyg==", "dev": true, "requires": { "@babel/core": "^7.1.0", - "@jest/test-sequencer": "^24.9.0", - "@jest/types": "^24.9.0", - "babel-jest": "^24.9.0", - "chalk": "^2.0.1", + "@jest/test-sequencer": "^26.6.3", + "@jest/types": "^26.6.2", + "babel-jest": "^26.6.3", + "chalk": "^4.0.0", + "deepmerge": "^4.2.2", "glob": "^7.1.1", - "jest-environment-jsdom": "^24.9.0", - "jest-environment-node": "^24.9.0", - "jest-get-type": "^24.9.0", - "jest-jasmine2": "^24.9.0", - "jest-regex-util": "^24.3.0", - "jest-resolve": "^24.9.0", - "jest-util": "^24.9.0", - "jest-validate": "^24.9.0", - "micromatch": "^3.1.10", - "pretty-format": "^24.9.0", - "realpath-native": "^1.1.0" + "graceful-fs": "^4.2.4", + "jest-environment-jsdom": "^26.6.2", + "jest-environment-node": "^26.6.2", + "jest-get-type": "^26.3.0", + "jest-jasmine2": "^26.6.3", + "jest-regex-util": "^26.0.0", + "jest-resolve": "^26.6.2", + "jest-util": "^26.6.2", + "jest-validate": "^26.6.2", + "micromatch": "^4.0.2", + "pretty-format": "^26.6.2" } }, "jest-diff": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-24.9.0.tgz", - "integrity": "sha512-qMfrTs8AdJE2iqrTp0hzh7kTd2PQWrsFyj9tORoKmu32xjPjeE4NyjVRDz8ybYwqS2ik8N4hsIpiVTyFeo2lBQ==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-26.6.2.tgz", + "integrity": "sha512-6m+9Z3Gv9wN0WFVasqjCL/06+EFCMTqDEUl/b87HYK2rAPTyfz4ZIuSlPhY51PIQRWx5TaxeF1qmXKe9gfN3sA==", "dev": true, "requires": { - "chalk": "^2.0.1", - "diff-sequences": "^24.9.0", - "jest-get-type": "^24.9.0", - "pretty-format": "^24.9.0" + "chalk": "^4.0.0", + "diff-sequences": "^26.6.2", + "jest-get-type": "^26.3.0", + "pretty-format": "^26.6.2" } }, "jest-docblock": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-24.9.0.tgz", - "integrity": "sha512-F1DjdpDMJMA1cN6He0FNYNZlo3yYmOtRUnktrT9Q37njYzC5WEaDdmbynIgy0L/IvXvvgsG8OsqhLPXTpfmZAA==", + "version": "26.0.0", + "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-26.0.0.tgz", + "integrity": "sha512-RDZ4Iz3QbtRWycd8bUEPxQsTlYazfYn/h5R65Fc6gOfwozFhoImx+affzky/FFBuqISPTqjXomoIGJVKBWoo0w==", "dev": true, "requires": { - "detect-newline": "^2.1.0" + "detect-newline": "^3.0.0" } }, "jest-each": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-24.9.0.tgz", - "integrity": "sha512-ONi0R4BvW45cw8s2Lrx8YgbeXL1oCQ/wIDwmsM3CqM/nlblNCPmnC3IPQlMbRFZu3wKdQ2U8BqM6lh3LJ5Bsog==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-26.6.2.tgz", + "integrity": "sha512-Mer/f0KaATbjl8MCJ+0GEpNdqmnVmDYqCTJYTvoo7rqmRiDllmp2AYN+06F93nXcY3ur9ShIjS+CO/uD+BbH4A==", "dev": true, "requires": { - "@jest/types": "^24.9.0", - "chalk": "^2.0.1", - "jest-get-type": "^24.9.0", - "jest-util": "^24.9.0", - "pretty-format": "^24.9.0" + "@jest/types": "^26.6.2", + "chalk": "^4.0.0", + "jest-get-type": "^26.3.0", + "jest-util": "^26.6.2", + "pretty-format": "^26.6.2" } }, "jest-environment-jsdom": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-environment-jsdom/-/jest-environment-jsdom-24.9.0.tgz", - "integrity": "sha512-Zv9FV9NBRzLuALXjvRijO2351DRQeLYXtpD4xNvfoVFw21IOKNhZAEUKcbiEtjTkm2GsJ3boMVgkaR7rN8qetA==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-environment-jsdom/-/jest-environment-jsdom-26.6.2.tgz", + "integrity": "sha512-jgPqCruTlt3Kwqg5/WVFyHIOJHsiAvhcp2qiR2QQstuG9yWox5+iHpU3ZrcBxW14T4fe5Z68jAfLRh7joCSP2Q==", "dev": true, "requires": { - "@jest/environment": "^24.9.0", - "@jest/fake-timers": "^24.9.0", - "@jest/types": "^24.9.0", - "jest-mock": "^24.9.0", - "jest-util": "^24.9.0", - "jsdom": "^11.5.1" + "@jest/environment": "^26.6.2", + "@jest/fake-timers": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "jest-mock": "^26.6.2", + "jest-util": "^26.6.2", + "jsdom": "^16.4.0" } }, "jest-environment-node": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-24.9.0.tgz", - "integrity": "sha512-6d4V2f4nxzIzwendo27Tr0aFm+IXWa0XEUnaH6nU0FMaozxovt+sfRvh4J47wL1OvF83I3SSTu0XK+i4Bqe7uA==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-26.6.2.tgz", + "integrity": "sha512-zhtMio3Exty18dy8ee8eJ9kjnRyZC1N4C1Nt/VShN1apyXc8rWGtJ9lI7vqiWcyyXS4BVSEn9lxAM2D+07/Tag==", "dev": true, "requires": { - "@jest/environment": "^24.9.0", - "@jest/fake-timers": "^24.9.0", - "@jest/types": "^24.9.0", - "jest-mock": "^24.9.0", - "jest-util": "^24.9.0" + "@jest/environment": "^26.6.2", + "@jest/fake-timers": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "jest-mock": "^26.6.2", + "jest-util": "^26.6.2" } }, "jest-get-type": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-24.9.0.tgz", - "integrity": "sha512-lUseMzAley4LhIcpSP9Jf+fTrQ4a1yHQwLNeeVa2cEmbCGeoZAtYPOIv8JaxLD/sUpKxetKGP+gsHl8f8TSj8Q==", + "version": "26.3.0", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-26.3.0.tgz", + "integrity": "sha512-TpfaviN1R2pQWkIihlfEanwOXK0zcxrKEE4MlU6Tn7keoXdN6/3gK/xl0yEh8DOunn5pOVGKf8hB4R9gVh04ig==", "dev": true }, "jest-haste-map": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-24.9.0.tgz", - "integrity": "sha512-kfVFmsuWui2Sj1Rp1AJ4D9HqJwE4uwTlS/vO+eRUaMmd54BFpli2XhMQnPC2k4cHFVbB2Q2C+jtI1AGLgEnCjQ==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-26.6.2.tgz", + "integrity": "sha512-easWIJXIw71B2RdR8kgqpjQrbMRWQBgiBwXYEhtGUTaX+doCjBheluShdDMeR8IMfJiTqH4+zfhtg29apJf/8w==", "dev": true, "requires": { - "@jest/types": "^24.9.0", - "anymatch": "^2.0.0", + "@jest/types": "^26.6.2", + "@types/graceful-fs": "^4.1.2", + "@types/node": "*", + "anymatch": "^3.0.3", "fb-watchman": "^2.0.0", - "fsevents": "^1.2.7", - "graceful-fs": "^4.1.15", - "invariant": "^2.2.4", - "jest-serializer": "^24.9.0", - "jest-util": "^24.9.0", - "jest-worker": "^24.9.0", - "micromatch": "^3.1.10", + "fsevents": "^2.1.2", + "graceful-fs": "^4.2.4", + "jest-regex-util": "^26.0.0", + "jest-serializer": "^26.6.2", + "jest-util": "^26.6.2", + "jest-worker": "^26.6.2", + "micromatch": "^4.0.2", "sane": "^4.0.3", "walker": "^1.0.7" } }, "jest-jasmine2": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-jasmine2/-/jest-jasmine2-24.9.0.tgz", - "integrity": "sha512-Cq7vkAgaYKp+PsX+2/JbTarrk0DmNhsEtqBXNwUHkdlbrTBLtMJINADf2mf5FkowNsq8evbPc07/qFO0AdKTzw==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-jasmine2/-/jest-jasmine2-26.6.3.tgz", + "integrity": "sha512-kPKUrQtc8aYwBV7CqBg5pu+tmYXlvFlSFYn18ev4gPFtrRzB15N2gW/Roew3187q2w2eHuu0MU9TJz6w0/nPEg==", "dev": true, "requires": { "@babel/traverse": "^7.1.0", - "@jest/environment": "^24.9.0", - "@jest/test-result": "^24.9.0", - "@jest/types": "^24.9.0", - "chalk": "^2.0.1", + "@jest/environment": "^26.6.2", + "@jest/source-map": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "chalk": "^4.0.0", "co": "^4.6.0", - "expect": "^24.9.0", + "expect": "^26.6.2", "is-generator-fn": "^2.0.0", - "jest-each": "^24.9.0", - "jest-matcher-utils": "^24.9.0", - "jest-message-util": "^24.9.0", - "jest-runtime": "^24.9.0", - "jest-snapshot": "^24.9.0", - "jest-util": "^24.9.0", - "pretty-format": "^24.9.0", - "throat": "^4.0.0" + "jest-each": "^26.6.2", + "jest-matcher-utils": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-runtime": "^26.6.3", + "jest-snapshot": "^26.6.2", + "jest-util": "^26.6.2", + "pretty-format": "^26.6.2", + "throat": "^5.0.0" } }, "jest-leak-detector": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-24.9.0.tgz", - "integrity": "sha512-tYkFIDsiKTGwb2FG1w8hX9V0aUb2ot8zY/2nFg087dUageonw1zrLMP4W6zsRO59dPkTSKie+D4rhMuP9nRmrA==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-26.6.2.tgz", + "integrity": "sha512-i4xlXpsVSMeKvg2cEKdfhh0H39qlJlP5Ex1yQxwF9ubahboQYMgTtz5oML35AVA3B4Eu+YsmwaiKVev9KCvLxg==", "dev": true, "requires": { - "jest-get-type": "^24.9.0", - "pretty-format": "^24.9.0" + "jest-get-type": "^26.3.0", + "pretty-format": "^26.6.2" } }, "jest-matcher-utils": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-24.9.0.tgz", - "integrity": "sha512-OZz2IXsu6eaiMAwe67c1T+5tUAtQyQx27/EMEkbFAGiw52tB9em+uGbzpcgYVpA8wl0hlxKPZxrly4CXU/GjHA==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-26.6.2.tgz", + "integrity": "sha512-llnc8vQgYcNqDrqRDXWwMr9i7rS5XFiCwvh6DTP7Jqa2mqpcCBBlpCbn+trkG0KNhPu/h8rzyBkriOtBstvWhw==", "dev": true, "requires": { - "chalk": "^2.0.1", - "jest-diff": "^24.9.0", - "jest-get-type": "^24.9.0", - "pretty-format": "^24.9.0" + "chalk": "^4.0.0", + "jest-diff": "^26.6.2", + "jest-get-type": "^26.3.0", + "pretty-format": "^26.6.2" } }, "jest-message-util": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-24.9.0.tgz", - "integrity": "sha512-oCj8FiZ3U0hTP4aSui87P4L4jC37BtQwUMqk+zk/b11FR19BJDeZsZAvIHutWnmtw7r85UmR3CEWZ0HWU2mAlw==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-26.6.2.tgz", + "integrity": "sha512-rGiLePzQ3AzwUshu2+Rn+UMFk0pHN58sOG+IaJbk5Jxuqo3NYO1U2/MIR4S1sKgsoYSXSzdtSa0TgrmtUwEbmA==", "dev": true, "requires": { "@babel/code-frame": "^7.0.0", - "@jest/test-result": "^24.9.0", - "@jest/types": "^24.9.0", - "@types/stack-utils": "^1.0.1", - "chalk": "^2.0.1", - "micromatch": "^3.1.10", - "slash": "^2.0.0", - "stack-utils": "^1.0.1" + "@jest/types": "^26.6.2", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.4", + "micromatch": "^4.0.2", + "pretty-format": "^26.6.2", + "slash": "^3.0.0", + "stack-utils": "^2.0.2" } }, "jest-mock": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-24.9.0.tgz", - "integrity": "sha512-3BEYN5WbSq9wd+SyLDES7AHnjH9A/ROBwmz7l2y+ol+NtSFO8DYiEBzoO1CeFc9a8DYy10EO4dDFVv/wN3zl1w==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-26.6.2.tgz", + "integrity": "sha512-YyFjePHHp1LzpzYcmgqkJ0nm0gg/lJx2aZFzFy1S6eUqNjXsOqTK10zNRff2dNfssgokjkG65OlWNcIlgd3zew==", "dev": true, "requires": { - "@jest/types": "^24.9.0" + "@jest/types": "^26.6.2", + "@types/node": "*" } }, "jest-pnp-resolver": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.1.tgz", - "integrity": "sha512-pgFw2tm54fzgYvc/OHrnysABEObZCUNFnhjoRjaVOCN8NYc032/gVjPaHD4Aq6ApkSieWtfKAFQtmDKAmhupnQ==", + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.2.tgz", + "integrity": "sha512-olV41bKSMm8BdnuMsewT4jqlZ8+3TCARAXjZGT9jcoSnrfUnRCqnMoF9XEeoWjbzObpqF9dRhHQj0Xb9QdF6/w==", "dev": true }, "jest-regex-util": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-24.9.0.tgz", - "integrity": "sha512-05Cmb6CuxaA+Ys6fjr3PhvV3bGQmO+2p2La4hFbU+W5uOc479f7FdLXUWXw4pYMAhhSZIuKHwSXSu6CsSBAXQA==", + "version": "26.0.0", + "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-26.0.0.tgz", + "integrity": "sha512-Gv3ZIs/nA48/Zvjrl34bf+oD76JHiGDUxNOVgUjh3j890sblXryjY4rss71fPtD/njchl6PSE2hIhvyWa1eT0A==", "dev": true }, "jest-resolve": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-24.9.0.tgz", - "integrity": "sha512-TaLeLVL1l08YFZAt3zaPtjiVvyy4oSA6CRe+0AFPPVX3Q/VI0giIWWoAvoS5L96vj9Dqxj4fB5p2qrHCmTU/MQ==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-26.6.2.tgz", + "integrity": "sha512-sOxsZOq25mT1wRsfHcbtkInS+Ek7Q8jCHUB0ZUTP0tc/c41QHriU/NunqMfCUWsL4H3MHpvQD4QR9kSYhS7UvQ==", "dev": true, "requires": { - "@jest/types": "^24.9.0", - "browser-resolve": "^1.11.3", - "chalk": "^2.0.1", - "jest-pnp-resolver": "^1.2.1", - "realpath-native": "^1.1.0" + "@jest/types": "^26.6.2", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.4", + "jest-pnp-resolver": "^1.2.2", + "jest-util": "^26.6.2", + "read-pkg-up": "^7.0.1", + "resolve": "^1.18.1", + "slash": "^3.0.0" } }, "jest-resolve-dependencies": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-24.9.0.tgz", - "integrity": "sha512-Fm7b6AlWnYhT0BXy4hXpactHIqER7erNgIsIozDXWl5dVm+k8XdGVe1oTg1JyaFnOxarMEbax3wyRJqGP2Pq+g==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-26.6.3.tgz", + "integrity": "sha512-pVwUjJkxbhe4RY8QEWzN3vns2kqyuldKpxlxJlzEYfKSvY6/bMvxoFrYYzUO1Gx28yKWN37qyV7rIoIp2h8fTg==", "dev": true, "requires": { - "@jest/types": "^24.9.0", - "jest-regex-util": "^24.3.0", - "jest-snapshot": "^24.9.0" + "@jest/types": "^26.6.2", + "jest-regex-util": "^26.0.0", + "jest-snapshot": "^26.6.2" } }, "jest-runner": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-24.9.0.tgz", - "integrity": "sha512-KksJQyI3/0mhcfspnxxEOBueGrd5E4vV7ADQLT9ESaCzz02WnbdbKWIf5Mkaucoaj7obQckYPVX6JJhgUcoWWg==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-26.6.3.tgz", + "integrity": "sha512-atgKpRHnaA2OvByG/HpGA4g6CSPS/1LK0jK3gATJAoptC1ojltpmVlYC3TYgdmGp+GLuhzpH30Gvs36szSL2JQ==", "dev": true, "requires": { - "@jest/console": "^24.7.1", - "@jest/environment": "^24.9.0", - "@jest/test-result": "^24.9.0", - "@jest/types": "^24.9.0", - "chalk": "^2.4.2", + "@jest/console": "^26.6.2", + "@jest/environment": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "chalk": "^4.0.0", + "emittery": "^0.7.1", "exit": "^0.1.2", - "graceful-fs": "^4.1.15", - "jest-config": "^24.9.0", - "jest-docblock": "^24.3.0", - "jest-haste-map": "^24.9.0", - "jest-jasmine2": "^24.9.0", - "jest-leak-detector": "^24.9.0", - "jest-message-util": "^24.9.0", - "jest-resolve": "^24.9.0", - "jest-runtime": "^24.9.0", - "jest-util": "^24.9.0", - "jest-worker": "^24.6.0", + "graceful-fs": "^4.2.4", + "jest-config": "^26.6.3", + "jest-docblock": "^26.0.0", + "jest-haste-map": "^26.6.2", + "jest-leak-detector": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-resolve": "^26.6.2", + "jest-runtime": "^26.6.3", + "jest-util": "^26.6.2", + "jest-worker": "^26.6.2", "source-map-support": "^0.5.6", - "throat": "^4.0.0" + "throat": "^5.0.0" } }, "jest-runtime": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-24.9.0.tgz", - "integrity": "sha512-8oNqgnmF3v2J6PVRM2Jfuj8oX3syKmaynlDMMKQ4iyzbQzIG6th5ub/lM2bCMTmoTKM3ykcUYI2Pw9xwNtjMnw==", + "version": "26.6.3", + "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-26.6.3.tgz", + "integrity": "sha512-lrzyR3N8sacTAMeonbqpnSka1dHNux2uk0qqDXVkMv2c/A3wYnvQ4EXuI013Y6+gSKSCxdaczvf4HF0mVXHRdw==", "dev": true, "requires": { - "@jest/console": "^24.7.1", - "@jest/environment": "^24.9.0", - "@jest/source-map": "^24.3.0", - "@jest/transform": "^24.9.0", - "@jest/types": "^24.9.0", - "@types/yargs": "^13.0.0", - "chalk": "^2.0.1", + "@jest/console": "^26.6.2", + "@jest/environment": "^26.6.2", + "@jest/fake-timers": "^26.6.2", + "@jest/globals": "^26.6.2", + "@jest/source-map": "^26.6.2", + "@jest/test-result": "^26.6.2", + "@jest/transform": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/yargs": "^15.0.0", + "chalk": "^4.0.0", + "cjs-module-lexer": "^0.6.0", + "collect-v8-coverage": "^1.0.0", "exit": "^0.1.2", "glob": "^7.1.3", - "graceful-fs": "^4.1.15", - "jest-config": "^24.9.0", - "jest-haste-map": "^24.9.0", - "jest-message-util": "^24.9.0", - "jest-mock": "^24.9.0", - "jest-regex-util": "^24.3.0", - "jest-resolve": "^24.9.0", - "jest-snapshot": "^24.9.0", - "jest-util": "^24.9.0", - "jest-validate": "^24.9.0", - "realpath-native": "^1.1.0", - "slash": "^2.0.0", - "strip-bom": "^3.0.0", - "yargs": "^13.3.0" + "graceful-fs": "^4.2.4", + "jest-config": "^26.6.3", + "jest-haste-map": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-mock": "^26.6.2", + "jest-regex-util": "^26.0.0", + "jest-resolve": "^26.6.2", + "jest-snapshot": "^26.6.2", + "jest-util": "^26.6.2", + "jest-validate": "^26.6.2", + "slash": "^3.0.0", + "strip-bom": "^4.0.0", + "yargs": "^15.4.1" } }, "jest-serializer": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-serializer/-/jest-serializer-24.9.0.tgz", - "integrity": "sha512-DxYipDr8OvfrKH3Kel6NdED3OXxjvxXZ1uIY2I9OFbGg+vUkkg7AGvi65qbhbWNPvDckXmzMPbK3u3HaDO49bQ==", - "dev": true + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-serializer/-/jest-serializer-26.6.2.tgz", + "integrity": "sha512-S5wqyz0DXnNJPd/xfIzZ5Xnp1HrJWBczg8mMfMpN78OJ5eDxXyf+Ygld9wX1DnUWbIbhM1YDY95NjR4CBXkb2g==", + "dev": true, + "requires": { + "@types/node": "*", + "graceful-fs": "^4.2.4" + } }, "jest-snapshot": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-24.9.0.tgz", - "integrity": "sha512-uI/rszGSs73xCM0l+up7O7a40o90cnrk429LOiK3aeTvfC0HHmldbd81/B7Ix81KSFe1lwkbl7GnBGG4UfuDew==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-26.6.2.tgz", + "integrity": "sha512-OLhxz05EzUtsAmOMzuupt1lHYXCNib0ECyuZ/PZOx9TrZcC8vL0x+DUG3TL+GLX3yHG45e6YGjIm0XwDc3q3og==", "dev": true, "requires": { "@babel/types": "^7.0.0", - "@jest/types": "^24.9.0", - "chalk": "^2.0.1", - "expect": "^24.9.0", - "jest-diff": "^24.9.0", - "jest-get-type": "^24.9.0", - "jest-matcher-utils": "^24.9.0", - "jest-message-util": "^24.9.0", - "jest-resolve": "^24.9.0", - "mkdirp": "^0.5.1", + "@jest/types": "^26.6.2", + "@types/babel__traverse": "^7.0.4", + "@types/prettier": "^2.0.0", + "chalk": "^4.0.0", + "expect": "^26.6.2", + "graceful-fs": "^4.2.4", + "jest-diff": "^26.6.2", + "jest-get-type": "^26.3.0", + "jest-haste-map": "^26.6.2", + "jest-matcher-utils": "^26.6.2", + "jest-message-util": "^26.6.2", + "jest-resolve": "^26.6.2", "natural-compare": "^1.4.0", - "pretty-format": "^24.9.0", - "semver": "^6.2.0" + "pretty-format": "^26.6.2", + "semver": "^7.3.2" } }, "jest-util": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-24.9.0.tgz", - "integrity": "sha512-x+cZU8VRmOJxbA1K5oDBdxQmdq0OIdADarLxk0Mq+3XS4jgvhG/oKGWcIDCtPG0HgjxOYvF+ilPJQsAyXfbNOg==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-26.6.2.tgz", + "integrity": "sha512-MDW0fKfsn0OI7MS7Euz6h8HNDXVQ0gaM9uW6RjfDmd1DAFcaxX9OqIakHIqhbnmF08Cf2DLDG+ulq8YQQ0Lp0Q==", "dev": true, "requires": { - "@jest/console": "^24.9.0", - "@jest/fake-timers": "^24.9.0", - "@jest/source-map": "^24.9.0", - "@jest/test-result": "^24.9.0", - "@jest/types": "^24.9.0", - "callsites": "^3.0.0", - "chalk": "^2.0.1", - "graceful-fs": "^4.1.15", + "@jest/types": "^26.6.2", + "@types/node": "*", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.4", "is-ci": "^2.0.0", - "mkdirp": "^0.5.1", - "slash": "^2.0.0", - "source-map": "^0.6.0" + "micromatch": "^4.0.2" } }, "jest-validate": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-24.9.0.tgz", - "integrity": "sha512-HPIt6C5ACwiqSiwi+OfSSHbK8sG7akG8eATl+IPKaeIjtPOeBUd/g3J7DghugzxrGjI93qS/+RPKe1H6PqvhRQ==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-26.6.2.tgz", + "integrity": "sha512-NEYZ9Aeyj0i5rQqbq+tpIOom0YS1u2MVu6+euBsvpgIme+FOfRmoC4R5p0JiAUpaFvFy24xgrpMknarR/93XjQ==", "dev": true, "requires": { - "@jest/types": "^24.9.0", - "camelcase": "^5.3.1", - "chalk": "^2.0.1", - "jest-get-type": "^24.9.0", + "@jest/types": "^26.6.2", + "camelcase": "^6.0.0", + "chalk": "^4.0.0", + "jest-get-type": "^26.3.0", "leven": "^3.1.0", - "pretty-format": "^24.9.0" + "pretty-format": "^26.6.2" + }, + "dependencies": { + "camelcase": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz", + "integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==", + "dev": true + } } }, "jest-watcher": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-24.9.0.tgz", - "integrity": "sha512-+/fLOfKPXXYJDYlks62/4R4GoT+GU1tYZed99JSCOsmzkkF7727RqKrjNAxtfO4YpGv11wybgRvCjR73lK2GZw==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-26.6.2.tgz", + "integrity": "sha512-WKJob0P/Em2csiVthsI68p6aGKTIcsfjH9Gsx1f0A3Italz43e3ho0geSAVsmj09RWOELP1AZ/DXyJgOgDKxXQ==", "dev": true, "requires": { - "@jest/test-result": "^24.9.0", - "@jest/types": "^24.9.0", - "@types/yargs": "^13.0.0", - "ansi-escapes": "^3.0.0", - "chalk": "^2.0.1", - "jest-util": "^24.9.0", - "string-length": "^2.0.0" + "@jest/test-result": "^26.6.2", + "@jest/types": "^26.6.2", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "jest-util": "^26.6.2", + "string-length": "^4.0.1" } }, "jest-worker": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-24.9.0.tgz", - "integrity": "sha512-51PE4haMSXcHohnSMdM42anbvZANYTqMrr52tVKPqqsPJMzoP6FYYDVqahX/HrAoKEKz3uUPzSvKs9A3qR4iVw==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz", + "integrity": "sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==", "dev": true, "requires": { + "@types/node": "*", "merge-stream": "^2.0.0", - "supports-color": "^6.1.0" - }, - "dependencies": { - "supports-color": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.1.0.tgz", - "integrity": "sha512-qe1jfm1Mg7Nq/NSh6XE24gPXROEVsWHxC1LIx//XNlD9iw7YZQGjZNjYN7xGaEG6iKdA8EtNFW6R0gjnVXp+wQ==", - "dev": true, - "requires": { - "has-flag": "^3.0.0" - } - } + "supports-color": "^7.0.0" } }, "js-tokens": { @@ -3228,6 +3053,15 @@ "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", "dev": true }, + "js-yaml": { + "version": "3.14.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.0.tgz", + "integrity": "sha512-/4IbIeHcD9VMHFqDR/gQ7EdZdLimOvW2DdcxFjdyyZ9NsbS+ccrXqVWDtab/lRl5AlUqmpBx8EhPaWR+OtY17A==", + "requires": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + } + }, "jsbn": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", @@ -3235,36 +3069,36 @@ "dev": true }, "jsdom": { - "version": "11.12.0", - "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-11.12.0.tgz", - "integrity": "sha512-y8Px43oyiBM13Zc1z780FrfNLJCXTL40EWlty/LXUtcjykRBNgLlCjWXpfSPBl2iv+N7koQN+dvqszHZgT/Fjw==", + "version": "16.4.0", + "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-16.4.0.tgz", + "integrity": "sha512-lYMm3wYdgPhrl7pDcRmvzPhhrGVBeVhPIqeHjzeiHN3DFmD1RBpbExbi8vU7BJdH8VAZYovR8DMt0PNNDM7k8w==", "dev": true, "requires": { - "abab": "^2.0.0", - "acorn": "^5.5.3", - "acorn-globals": "^4.1.0", - "array-equal": "^1.0.0", - "cssom": ">= 0.3.2 < 0.4.0", - "cssstyle": "^1.0.0", - "data-urls": "^1.0.0", - "domexception": "^1.0.1", - "escodegen": "^1.9.1", - "html-encoding-sniffer": "^1.0.2", - "left-pad": "^1.3.0", - "nwsapi": "^2.0.7", - "parse5": "4.0.0", - "pn": "^1.1.0", - "request": "^2.87.0", - "request-promise-native": "^1.0.5", - "sax": "^1.2.4", - "symbol-tree": "^3.2.2", - "tough-cookie": "^2.3.4", - "w3c-hr-time": "^1.0.1", - "webidl-conversions": "^4.0.2", - "whatwg-encoding": "^1.0.3", - "whatwg-mimetype": "^2.1.0", - "whatwg-url": "^6.4.1", - "ws": "^5.2.0", + "abab": "^2.0.3", + "acorn": "^7.1.1", + "acorn-globals": "^6.0.0", + "cssom": "^0.4.4", + "cssstyle": "^2.2.0", + "data-urls": "^2.0.0", + "decimal.js": "^10.2.0", + "domexception": "^2.0.1", + "escodegen": "^1.14.1", + "html-encoding-sniffer": "^2.0.1", + "is-potential-custom-element-name": "^1.0.0", + "nwsapi": "^2.2.0", + "parse5": "5.1.1", + "request": "^2.88.2", + "request-promise-native": "^1.0.8", + "saxes": "^5.0.0", + "symbol-tree": "^3.2.4", + "tough-cookie": "^3.0.1", + "w3c-hr-time": "^1.0.2", + "w3c-xmlserializer": "^2.0.0", + "webidl-conversions": "^6.1.0", + "whatwg-encoding": "^1.0.5", + "whatwg-mimetype": "^2.3.0", + "whatwg-url": "^8.0.0", + "ws": "^7.2.3", "xml-name-validator": "^3.0.0" } }, @@ -3274,10 +3108,10 @@ "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", "dev": true }, - "json-parse-better-errors": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz", - "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==", + "json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", "dev": true }, "json-schema": { @@ -3299,12 +3133,12 @@ "dev": true }, "json5": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/json5/-/json5-2.1.1.tgz", - "integrity": "sha512-l+3HXD0GEI3huGq1njuqtzYK8OYJyXMkOLtQ53pjWh89tvWS2h6l+1zMkYWqlb57+SiQodKZyvMEFb2X+KrFhQ==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz", + "integrity": "sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==", "dev": true, "requires": { - "minimist": "^1.2.0" + "minimist": "^1.2.5" } }, "jsprim": { @@ -3331,12 +3165,6 @@ "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==", "dev": true }, - "left-pad": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/left-pad/-/left-pad-1.3.0.tgz", - "integrity": "sha512-XI5MPzVNApjAyhQzphX8BkmKsKUxD4LdyK24iZeQGinBN9yTQT3bFlCBy/aVx2HrNcqQGsdot8ghrjyrvMCoEA==", - "dev": true - }, "leven": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", @@ -3353,38 +3181,25 @@ "type-check": "~0.3.2" } }, - "load-json-file": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-4.0.0.tgz", - "integrity": "sha1-L19Fq5HjMhYjT9U62rZo607AmTs=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "parse-json": "^4.0.0", - "pify": "^3.0.0", - "strip-bom": "^3.0.0" - } + "lines-and-columns": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.1.6.tgz", + "integrity": "sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA=", + "dev": true }, "locate-path": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", - "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", "dev": true, "requires": { - "p-locate": "^3.0.0", - "path-exists": "^3.0.0" + "p-locate": "^4.1.0" } }, "lodash": { - "version": "4.17.19", - "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.19.tgz", - "integrity": "sha512-JNvd8XER9GQX0v2qJgsaN/mzFCNA5BRe/j8JN9d+tWyGLSodKQHKFicdwNYzWwI3wjRnaKPsGj1XkBjx/F96DQ==", - "dev": true - }, - "lodash.memoize": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz", - "integrity": "sha1-vMbEmkKihA7Zl/Mj6tpezRguC/4=", + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", "dev": true }, "lodash.sortby": { @@ -3393,43 +3208,35 @@ "integrity": "sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=", "dev": true }, - "loose-envify": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", - "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", - "dev": true, + "lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", "requires": { - "js-tokens": "^3.0.0 || ^4.0.0" + "yallist": "^4.0.0" } }, "make-dir": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz", - "integrity": "sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz", + "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==", "dev": true, "requires": { - "pify": "^4.0.1", - "semver": "^5.6.0" + "semver": "^6.0.0" }, "dependencies": { - "pify": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", - "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", - "dev": true - }, "semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", "dev": true } } }, "make-error": { - "version": "1.3.5", - "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.5.tgz", - "integrity": "sha512-c3sIjNUow0+8swNwVpqoH4YCShKNFkMaw6oH1mNS2haDZQqkeZFlHS3dhoeEbKKmJB4vXpJucU6oH75aDYeE9g==", + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", "dev": true }, "makeerror": { @@ -3463,41 +3270,36 @@ "dev": true }, "micromatch": { - "version": "3.1.10", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", - "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.2.tgz", + "integrity": "sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==", "dev": true, "requires": { - "arr-diff": "^4.0.0", - "array-unique": "^0.3.2", - "braces": "^2.3.1", - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "extglob": "^2.0.4", - "fragment-cache": "^0.2.1", - "kind-of": "^6.0.2", - "nanomatch": "^1.2.9", - "object.pick": "^1.3.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.2" + "braces": "^3.0.1", + "picomatch": "^2.0.5" } }, "mime-db": { - "version": "1.43.0", - "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.43.0.tgz", - "integrity": "sha512-+5dsGEEovYbT8UY9yD7eE4XTc4UwJ1jBYlgaQQF38ENsKR3wj/8q8RFZrF9WIZpB2V1ArTVFUva8sAul1NzRzQ==", + "version": "1.46.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.46.0.tgz", + "integrity": "sha512-svXaP8UQRZ5K7or+ZmfNhg2xX3yKDMUzqadsSqi4NCH/KomcH75MAMYAGVlvXn4+b/xOPhS3I2uHKRUzvjY7BQ==", "dev": true }, "mime-types": { - "version": "2.1.26", - "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.26.tgz", - "integrity": "sha512-01paPWYgLrkqAyrlDorC1uDwl2p3qZT7yl806vW7DvDoxwXi46jsjFbg+WdwotBIk6/MbEhO/dh5aZ5sNj/dWQ==", + "version": "2.1.29", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.29.tgz", + "integrity": "sha512-Y/jMt/S5sR9OaqteJtslsFZKWOIIqMACsJSiHghlCAyhf7jfVYjKBmLiX8OgpWeW+fjJ2b+Az69aPFPkUOY6xQ==", "dev": true, "requires": { - "mime-db": "1.43.0" + "mime-db": "1.46.0" } }, + "mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true + }, "minimatch": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", @@ -3508,9 +3310,9 @@ } }, "minimist": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", - "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", + "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==", "dev": true }, "mixin-deep": { @@ -3535,34 +3337,16 @@ } }, "mkdirp": { - "version": "0.5.1", - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", - "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", - "dev": true, - "requires": { - "minimist": "0.0.8" - }, - "dependencies": { - "minimist": { - "version": "0.0.8", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", - "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=", - "dev": true - } - } - }, - "ms": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", "dev": true }, - "nan": { - "version": "2.14.0", - "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.0.tgz", - "integrity": "sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg==", - "dev": true, - "optional": true + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "dev": true }, "nanomatch": { "version": "1.2.13", @@ -3608,26 +3392,45 @@ "dev": true }, "node-notifier": { - "version": "5.4.3", - "resolved": "https://registry.npmjs.org/node-notifier/-/node-notifier-5.4.3.tgz", - "integrity": "sha512-M4UBGcs4jeOK9CjTsYwkvH6/MzuUmGCyTW+kCY7uO+1ZVr0+FHGdPdIf5CCLqAaxnRrWidyoQlNkMIIVwbKB8Q==", + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/node-notifier/-/node-notifier-8.0.1.tgz", + "integrity": "sha512-BvEXF+UmsnAfYfoapKM9nGxnP+Wn7P91YfXmrKnfcYCx6VBeoN5Ez5Ogck6I8Bi5k4RlpqRYaw75pAwzX9OphA==", "dev": true, + "optional": true, "requires": { "growly": "^1.3.0", - "is-wsl": "^1.1.0", - "semver": "^5.5.0", + "is-wsl": "^2.2.0", + "semver": "^7.3.2", "shellwords": "^0.1.1", - "which": "^1.3.0" + "uuid": "^8.3.0", + "which": "^2.0.2" }, "dependencies": { - "semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", - "dev": true + "uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "dev": true, + "optional": true + }, + "which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "optional": true, + "requires": { + "isexe": "^2.0.0" + } } } }, + "node-releases": { + "version": "1.1.71", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-1.1.71.tgz", + "integrity": "sha512-zR6HoT6LrLCRBwukmrVbHv0EpEQjksO6GmFcZQQuCAy139BEsoVKPYnf3jongYW83fAa1torLGYwxxky/p28sg==", + "dev": true + }, "normalize-package-data": { "version": "2.5.0", "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", @@ -3649,13 +3452,10 @@ } }, "normalize-path": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", - "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", - "dev": true, - "requires": { - "remove-trailing-separator": "^1.0.1" - } + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true }, "npm-run-path": { "version": "2.0.2", @@ -3709,18 +3509,6 @@ } } }, - "object-inspect": { - "version": "1.7.0", - "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.7.0.tgz", - "integrity": "sha512-a7pEHdh1xKIAgTySUGgLMx/xwDZskN1Ud6egYYN3EdRW4ZMPNEDUTF+hwy2LUC+Bl+SyLXANnwz/jyh/qutKUw==", - "dev": true - }, - "object-keys": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", - "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", - "dev": true - }, "object-visit": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz", @@ -3730,28 +3518,6 @@ "isobject": "^3.0.0" } }, - "object.assign": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz", - "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==", - "dev": true, - "requires": { - "define-properties": "^1.1.2", - "function-bind": "^1.1.1", - "has-symbols": "^1.0.0", - "object-keys": "^1.0.11" - } - }, - "object.getownpropertydescriptors": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.0.tgz", - "integrity": "sha512-Z53Oah9A3TdLoblT7VKJaTDdXdT+lQO+cNpKVnya5JDe9uLvzu1YyY1yFDFrcxrlRgWrEFH0jJtD/IbuwjcEVg==", - "dev": true, - "requires": { - "define-properties": "^1.1.3", - "es-abstract": "^1.17.0-next.1" - } - }, "object.pick": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz", @@ -3770,6 +3536,15 @@ "wrappy": "1" } }, + "onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "requires": { + "mimic-fn": "^2.1.0" + } + }, "optionator": { "version": "0.8.3", "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz", @@ -3785,13 +3560,10 @@ } }, "p-each-series": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/p-each-series/-/p-each-series-1.0.0.tgz", - "integrity": "sha1-kw89Et0fUOdDRFeiLNbwSsatf3E=", - "dev": true, - "requires": { - "p-reduce": "^1.0.0" - } + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-each-series/-/p-each-series-2.2.0.tgz", + "integrity": "sha512-ycIL2+1V32th+8scbpTvyHNaHe02z0sjgh91XXjAk+ZeXoPN4Z46DVUnzdso0aX4KckKw0FNNFHdjZ2UsZvxiA==", + "dev": true }, "p-finally": { "version": "1.0.0", @@ -3800,29 +3572,23 @@ "dev": true }, "p-limit": { - "version": "2.2.2", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.2.2.tgz", - "integrity": "sha512-WGR+xHecKTr7EbUEhyLSh5Dube9JtdiG78ufaeLxTgpudf/20KqyMioIUZJAezlTIi6evxuoUs9YXc11cU+yzQ==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", "dev": true, "requires": { "p-try": "^2.0.0" } }, "p-locate": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", - "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", "dev": true, "requires": { - "p-limit": "^2.0.0" + "p-limit": "^2.2.0" } }, - "p-reduce": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/p-reduce/-/p-reduce-1.0.0.tgz", - "integrity": "sha1-GMKw3ZNqRpClKfgjH1ig/bakffo=", - "dev": true - }, "p-try": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", @@ -3830,19 +3596,21 @@ "dev": true }, "parse-json": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz", - "integrity": "sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=", + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", + "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", "dev": true, "requires": { + "@babel/code-frame": "^7.0.0", "error-ex": "^1.3.1", - "json-parse-better-errors": "^1.0.1" + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" } }, "parse5": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/parse5/-/parse5-4.0.0.tgz", - "integrity": "sha512-VrZ7eOd3T1Fk4XWNXMgiGBK/z0MG48BWG2uQNU4I72fkQuKUTZpl+u9k+CxEG0twMVzSmXEEz12z5Fnw1jIQFA==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-5.1.1.tgz", + "integrity": "sha512-ugq4DFI0Ptb+WWjAdOK16+u/nHfiIrcE+sh8kZMaM0WllQKLI9rOUq6c2b7cwPkXdzfQESqvoqK6ug7U/Yyzug==", "dev": true }, "pascalcase": { @@ -3852,9 +3620,9 @@ "dev": true }, "path-exists": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", - "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", "dev": true }, "path-is-absolute": { @@ -3875,25 +3643,16 @@ "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", "dev": true }, - "path-type": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz", - "integrity": "sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==", - "dev": true, - "requires": { - "pify": "^3.0.0" - } - }, "performance-now": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=", "dev": true }, - "pify": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", - "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=", + "picomatch": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz", + "integrity": "sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==", "dev": true }, "pirates": { @@ -3906,20 +3665,14 @@ } }, "pkg-dir": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-3.0.0.tgz", - "integrity": "sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==", + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", "dev": true, "requires": { - "find-up": "^3.0.0" + "find-up": "^4.0.0" } }, - "pn": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/pn/-/pn-1.1.0.tgz", - "integrity": "sha512-2qHaIQr2VLRFoxe2nASzsV6ef4yOOH+Fi9FBOVH6cqeSgUnoyySPZkxzLuzd+RYOQTRpROA0ztTMqxROKSb/nA==", - "dev": true - }, "posix-character-classes": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz", @@ -3939,31 +3692,31 @@ "dev": true }, "pretty-format": { - "version": "24.9.0", - "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-24.9.0.tgz", - "integrity": "sha512-00ZMZUiHaJrNfk33guavqgvfJS30sLYf0f8+Srklv0AMPodGGHcoHgksZ3OThYnIvOd+8yMCn0YiEOogjlgsnA==", + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-26.6.2.tgz", + "integrity": "sha512-7AeGuCYNGmycyQbCqd/3PWH4eOoX/OiCa0uphp57NVTeAGdJGaAliecxwBDHYQCIvrW7aDBZCYeNTP/WX69mkg==", "dev": true, "requires": { - "@jest/types": "^24.9.0", - "ansi-regex": "^4.0.0", - "ansi-styles": "^3.2.0", - "react-is": "^16.8.4" + "@jest/types": "^26.6.2", + "ansi-regex": "^5.0.0", + "ansi-styles": "^4.0.0", + "react-is": "^17.0.1" } }, "prompts": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.3.0.tgz", - "integrity": "sha512-NfbbPPg/74fT7wk2XYQ7hAIp9zJyZp5Fu19iRbORqqy1BhtrkZ0fPafBU+7bmn8ie69DpT0R6QpJIN2oisYjJg==", + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.0.tgz", + "integrity": "sha512-awZAKrk3vN6CroQukBL+R9051a4R3zCZBlJm/HBfrSZ8iTpYix3VX1vU4mveiLpiwmOJT4wokTF9m6HUk4KqWQ==", "dev": true, "requires": { "kleur": "^3.0.3", - "sisteransi": "^1.0.3" + "sisteransi": "^1.0.5" } }, "psl": { - "version": "1.7.0", - "resolved": "https://registry.npmjs.org/psl/-/psl-1.7.0.tgz", - "integrity": "sha512-5NsSEDv8zY70ScRnOTn7bK7eanl2MvFrOrS/R6x+dBt5g1ghnj9Zv90kO8GwT8gxcu2ANyFprnFYB85IogIJOQ==", + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz", + "integrity": "sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==", "dev": true }, "pump": { @@ -3989,39 +3742,40 @@ "dev": true }, "react-is": { - "version": "16.12.0", - "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.12.0.tgz", - "integrity": "sha512-rPCkf/mWBtKc97aLL9/txD8DZdemK0vkA3JMLShjlJB3Pj3s+lpf1KaBzMfQrAmhMQB0n1cU/SUGgKKBCe837Q==", + "version": "17.0.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.1.tgz", + "integrity": "sha512-NAnt2iGDXohE5LI7uBnLnqvLQMtzhkiAOLXTmv+qnF9Ky7xAPcX8Up/xWIhxvLVGJvuLiNc4xQLtuqDRzb4fSA==", "dev": true }, "read-pkg": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz", - "integrity": "sha1-nLxoaXj+5l0WwA4rGcI3/Pbjg4k=", + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz", + "integrity": "sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==", "dev": true, "requires": { - "load-json-file": "^4.0.0", - "normalize-package-data": "^2.3.2", - "path-type": "^3.0.0" + "@types/normalize-package-data": "^2.4.0", + "normalize-package-data": "^2.5.0", + "parse-json": "^5.0.0", + "type-fest": "^0.6.0" + }, + "dependencies": { + "type-fest": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.6.0.tgz", + "integrity": "sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==", + "dev": true + } } }, "read-pkg-up": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-4.0.0.tgz", - "integrity": "sha512-6etQSH7nJGsK0RbG/2TeDzZFa8shjQ1um+SwQQ5cwKy0dhSXdOncEhb1CPpvQG4h7FyOV6EB6YlV0yJvZQNAkA==", + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-7.0.1.tgz", + "integrity": "sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==", "dev": true, "requires": { - "find-up": "^3.0.0", - "read-pkg": "^3.0.0" - } - }, - "realpath-native": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/realpath-native/-/realpath-native-1.1.0.tgz", - "integrity": "sha512-wlgPA6cCIIg9gKz0fgAPjnzh4yR/LnXovwuo9hvyGvx3h8nX4+/iLZplfUWasXpqD8BdnGnP5njOFjkUwPzvjA==", - "dev": true, - "requires": { - "util.promisify": "^1.0.0" + "find-up": "^4.1.0", + "read-pkg": "^5.2.0", + "type-fest": "^0.8.1" } }, "regex-not": { @@ -4053,9 +3807,9 @@ "dev": true }, "request": { - "version": "2.88.0", - "resolved": "https://registry.npmjs.org/request/-/request-2.88.0.tgz", - "integrity": "sha512-NAqBSrijGLZdM0WZNsInLJpkJokL72XYjUpnB0iwsRgxh7dB6COrHnTBNwN0E+lHDAJzu7kLAkDeY08z2/A0hg==", + "version": "2.88.2", + "resolved": "https://registry.npmjs.org/request/-/request-2.88.2.tgz", + "integrity": "sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==", "dev": true, "requires": { "aws-sign2": "~0.7.0", @@ -4065,7 +3819,7 @@ "extend": "~3.0.2", "forever-agent": "~0.6.1", "form-data": "~2.3.2", - "har-validator": "~5.1.0", + "har-validator": "~5.1.3", "http-signature": "~1.2.0", "is-typedarray": "~1.0.0", "isstream": "~0.1.2", @@ -4075,47 +3829,53 @@ "performance-now": "^2.1.0", "qs": "~6.5.2", "safe-buffer": "^5.1.2", - "tough-cookie": "~2.4.3", + "tough-cookie": "~2.5.0", "tunnel-agent": "^0.6.0", "uuid": "^3.3.2" }, "dependencies": { - "punycode": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", - "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=", - "dev": true - }, "tough-cookie": { - "version": "2.4.3", - "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz", - "integrity": "sha512-Q5srk/4vDM54WJsJio3XNn6K2sCG+CQ8G5Wz6bZhRZoAe/+TxjWB/GlFAnYEbkYVlON9FMk/fE3h2RLpPXo4lQ==", + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz", + "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==", "dev": true, "requires": { - "psl": "^1.1.24", - "punycode": "^1.4.1" + "psl": "^1.1.28", + "punycode": "^2.1.1" } } } }, "request-promise-core": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/request-promise-core/-/request-promise-core-1.1.3.tgz", - "integrity": "sha512-QIs2+ArIGQVp5ZYbWD5ZLCY29D5CfWizP8eWnm8FoGD1TX61veauETVQbrV60662V0oFBkrDOuaBI8XgtuyYAQ==", + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/request-promise-core/-/request-promise-core-1.1.4.tgz", + "integrity": "sha512-TTbAfBBRdWD7aNNOoVOBH4pN/KigV6LyapYNNlAPA8JwbovRti1E88m3sYAwsLi5ryhPKsE9APwnjFTgdUjTpw==", "dev": true, "requires": { - "lodash": "^4.17.15" + "lodash": "^4.17.19" } }, "request-promise-native": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/request-promise-native/-/request-promise-native-1.0.8.tgz", - "integrity": "sha512-dapwLGqkHtwL5AEbfenuzjTYg35Jd6KPytsC2/TLkVMz8rm+tNt72MGUWT1RP/aYawMpN6HqbNGBQaRcBtjQMQ==", + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/request-promise-native/-/request-promise-native-1.0.9.tgz", + "integrity": "sha512-wcW+sIUiWnKgNY0dqCpOZkUbF/I+YPi+f09JZIDa39Ec+q82CpSYniDp+ISgTTbKmnpJWASeJBPZmoxH84wt3g==", "dev": true, "requires": { - "request-promise-core": "1.1.3", + "request-promise-core": "1.1.4", "stealthy-require": "^1.1.1", "tough-cookie": "^2.3.3" + }, + "dependencies": { + "tough-cookie": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz", + "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==", + "dev": true, + "requires": { + "psl": "^1.1.28", + "punycode": "^2.1.1" + } + } } }, "require-directory": { @@ -4131,27 +3891,28 @@ "dev": true }, "resolve": { - "version": "1.15.1", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.15.1.tgz", - "integrity": "sha512-84oo6ZTtoTUpjgNEr5SJyzQhzL72gaRodsSfyxC/AXRvwu0Yse9H8eF9IpGo7b8YetZhlI6v7ZQ6bKBFV/6S7w==", + "version": "1.20.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.20.0.tgz", + "integrity": "sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==", "dev": true, "requires": { + "is-core-module": "^2.2.0", "path-parse": "^1.0.6" } }, "resolve-cwd": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-2.0.0.tgz", - "integrity": "sha1-AKn3OHVW4nA46uIyyqNypqWbZlo=", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", "dev": true, "requires": { - "resolve-from": "^3.0.0" + "resolve-from": "^5.0.0" } }, "resolve-from": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-3.0.0.tgz", - "integrity": "sha1-six699nWiBvItuZTM17rywoYh0g=", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", "dev": true }, "resolve-url": { @@ -4167,9 +3928,9 @@ "dev": true }, "rimraf": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz", - "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", "dev": true, "requires": { "glob": "^7.1.3" @@ -4217,18 +3978,148 @@ "micromatch": "^3.1.4", "minimist": "^1.1.1", "walker": "~1.0.5" + }, + "dependencies": { + "anymatch": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz", + "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", + "dev": true, + "requires": { + "micromatch": "^3.1.4", + "normalize-path": "^2.1.1" + } + }, + "braces": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", + "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", + "dev": true, + "requires": { + "arr-flatten": "^1.1.0", + "array-unique": "^0.3.2", + "extend-shallow": "^2.0.1", + "fill-range": "^4.0.0", + "isobject": "^3.0.1", + "repeat-element": "^1.1.2", + "snapdragon": "^0.8.1", + "snapdragon-node": "^2.0.1", + "split-string": "^3.0.2", + "to-regex": "^3.0.1" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + } + } + }, + "fill-range": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", + "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", + "dev": true, + "requires": { + "extend-shallow": "^2.0.1", + "is-number": "^3.0.0", + "repeat-string": "^1.6.1", + "to-regex-range": "^2.1.0" + }, + "dependencies": { + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "dev": true, + "requires": { + "is-extendable": "^0.1.0" + } + } + } + }, + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "^3.0.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, + "micromatch": { + "version": "3.1.10", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", + "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", + "dev": true, + "requires": { + "arr-diff": "^4.0.0", + "array-unique": "^0.3.2", + "braces": "^2.3.1", + "define-property": "^2.0.2", + "extend-shallow": "^3.0.2", + "extglob": "^2.0.4", + "fragment-cache": "^0.2.1", + "kind-of": "^6.0.2", + "nanomatch": "^1.2.9", + "object.pick": "^1.3.0", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.2" + } + }, + "normalize-path": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", + "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", + "dev": true, + "requires": { + "remove-trailing-separator": "^1.0.1" + } + }, + "to-regex-range": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", + "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", + "dev": true, + "requires": { + "is-number": "^3.0.0", + "repeat-string": "^1.6.1" + } + } } }, - "sax": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", - "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==", - "dev": true + "saxes": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/saxes/-/saxes-5.0.1.tgz", + "integrity": "sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw==", + "dev": true, + "requires": { + "xmlchars": "^2.2.0" + } }, "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + "version": "7.3.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.4.tgz", + "integrity": "sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==", + "requires": { + "lru-cache": "^6.0.0" + } }, "set-blocking": { "version": "2.0.0", @@ -4278,24 +4169,25 @@ "version": "0.1.1", "resolved": "https://registry.npmjs.org/shellwords/-/shellwords-0.1.1.tgz", "integrity": "sha512-vFwSUfQvqybiICwZY5+DAWIPLKsWO31Q91JSKl3UYv+K5c2QRPzn0qzec6QPu1Qc9eHYItiP3NdJqNVqetYAww==", - "dev": true + "dev": true, + "optional": true }, "signal-exit": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", - "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.3.tgz", + "integrity": "sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==", "dev": true }, "sisteransi": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.4.tgz", - "integrity": "sha512-/ekMoM4NJ59ivGSfKapeG+FWtrmWvA1p6FBZwXrqojw90vJu8lBmrTxCMuBCydKtkaUe2zt4PlxeTKpjwMbyig==", + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==", "dev": true }, "slash": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/slash/-/slash-2.0.0.tgz", - "integrity": "sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", "dev": true }, "snapdragon": { @@ -4314,6 +4206,15 @@ "use": "^3.1.0" }, "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, "define-property": { "version": "0.2.5", "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", @@ -4332,6 +4233,12 @@ "is-extendable": "^0.1.0" } }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + }, "source-map": { "version": "0.5.7", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", @@ -4431,9 +4338,9 @@ } }, "source-map-support": { - "version": "0.5.16", - "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.16.tgz", - "integrity": "sha512-efyLRJDr68D9hBBNIPWFjhpFzURh+KJykQwvMyW5UiZzYwoF6l4YMMDIJJEyFWxWCqfyxLzz6tSfUFR+kXXsVQ==", + "version": "0.5.19", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz", + "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==", "dev": true, "requires": { "buffer-from": "^1.0.0", @@ -4441,15 +4348,15 @@ } }, "source-map-url": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.0.tgz", - "integrity": "sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=", + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.1.tgz", + "integrity": "sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==", "dev": true }, "spdx-correct": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.0.tgz", - "integrity": "sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==", + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz", + "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==", "dev": true, "requires": { "spdx-expression-parse": "^3.0.0", @@ -4457,15 +4364,15 @@ } }, "spdx-exceptions": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.2.0.tgz", - "integrity": "sha512-2XQACfElKi9SlVb1CYadKDXvoajPgBVPn/gOQLrTvHdElaVhr7ZEbqJaRnJLVNeaI4cMEAgVCeBMKF6MWRDCRA==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz", + "integrity": "sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==", "dev": true }, "spdx-expression-parse": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz", - "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==", + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", + "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", "dev": true, "requires": { "spdx-exceptions": "^2.1.0", @@ -4473,9 +4380,9 @@ } }, "spdx-license-ids": { - "version": "3.0.5", - "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.5.tgz", - "integrity": "sha512-J+FWzZoynJEXGphVIS+XEh3kFSjZX/1i9gFBaWQcB+/tmpe2qUsSBABpcxqxnAxFdiUFEgAX1bjYGQvIZmoz9Q==", + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.7.tgz", + "integrity": "sha512-U+MTEOO0AiDzxwFvoa4JVnMV6mZlJKk2sBLt90s7G0Gd0Mlknc7kxEn3nuDPNZRta7O2uy8oLcZLVT+4sqNZHQ==", "dev": true }, "split-string": { @@ -4487,6 +4394,11 @@ "extend-shallow": "^3.0.0" } }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=" + }, "sshpk": { "version": "1.16.1", "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.16.1.tgz", @@ -4505,10 +4417,21 @@ } }, "stack-utils": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-1.0.2.tgz", - "integrity": "sha512-MTX+MeG5U994cazkjd/9KNAapsHnibjMLnfXodlkXw76JEea0UiNzrqidzo1emMwk7w5Qhc9jd4Bn9TBb1MFwA==", - "dev": true + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.3.tgz", + "integrity": "sha512-gL//fkxfWUsIlFL2Tl42Cl6+HFALEaB1FU76I/Fy+oZjRreP7OPMXFlGbxM7NQsI0ZpUfw76sHnv0WNYuTb7Iw==", + "dev": true, + "requires": { + "escape-string-regexp": "^2.0.0" + }, + "dependencies": { + "escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "dev": true + } + } }, "static-extend": { "version": "0.1.2", @@ -4538,76 +4461,39 @@ "dev": true }, "string-length": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/string-length/-/string-length-2.0.0.tgz", - "integrity": "sha1-1A27aGo6zpYMHP/KVivyxF+DY+0=", + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.1.tgz", + "integrity": "sha512-PKyXUd0LK0ePjSOnWn34V2uD6acUWev9uy0Ft05k0E8xRW+SKcA0F7eMr7h5xlzfn+4O3N+55rduYyet3Jk+jw==", "dev": true, "requires": { - "astral-regex": "^1.0.0", - "strip-ansi": "^4.0.0" - }, - "dependencies": { - "ansi-regex": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", - "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", - "dev": true - }, - "strip-ansi": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", - "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", - "dev": true, - "requires": { - "ansi-regex": "^3.0.0" - } - } + "char-regex": "^1.0.2", + "strip-ansi": "^6.0.0" } }, "string-width": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", - "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz", + "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==", "dev": true, "requires": { - "emoji-regex": "^7.0.1", - "is-fullwidth-code-point": "^2.0.0", - "strip-ansi": "^5.1.0" - } - }, - "string.prototype.trimleft": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/string.prototype.trimleft/-/string.prototype.trimleft-2.1.1.tgz", - "integrity": "sha512-iu2AGd3PuP5Rp7x2kEZCrB2Nf41ehzh+goo8TV7z8/XDBbsvc6HQIlUl9RjkZ4oyrW1XM5UwlGl1oVEaDjg6Ag==", - "dev": true, - "requires": { - "define-properties": "^1.1.3", - "function-bind": "^1.1.1" - } - }, - "string.prototype.trimright": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/string.prototype.trimright/-/string.prototype.trimright-2.1.1.tgz", - "integrity": "sha512-qFvWL3/+QIgZXVmJBfpHmxLB7xsUXz6HsUmP8+5dRaC3Q7oKUv9Vo6aMCRZC1smrtyECFsIT30PqBJ1gTjAs+g==", - "dev": true, - "requires": { - "define-properties": "^1.1.3", - "function-bind": "^1.1.1" + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" } }, "strip-ansi": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", - "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz", + "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==", "dev": true, "requires": { - "ansi-regex": "^4.1.0" + "ansi-regex": "^5.0.0" } }, "strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz", + "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==", "dev": true }, "strip-eof": { @@ -4616,13 +4502,29 @@ "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=", "dev": true }, + "strip-final-newline": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", + "dev": true + }, "supports-color": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", - "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "^4.0.0" + } + }, + "supports-hyperlinks": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-2.1.0.tgz", + "integrity": "sha512-zoE5/e+dnEijk6ASB6/qrK+oYdm2do1hjoLWrqUC/8WEIW1gbxFcKuBof7sW8ArN6e+AYvsE8HBGiVRWL/F5CA==", + "dev": true, + "requires": { + "has-flag": "^4.0.0", + "supports-color": "^7.0.0" } }, "symbol-tree": { @@ -4631,22 +4533,31 @@ "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==", "dev": true }, - "test-exclude": { - "version": "5.2.3", - "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-5.2.3.tgz", - "integrity": "sha512-M+oxtseCFO3EDtAaGH7iiej3CBkzXqFMbzqYAACdzKui4eZA+pq3tZEwChvOdNfa7xxy8BfbmgJSIr43cC/+2g==", + "terminal-link": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/terminal-link/-/terminal-link-2.1.1.tgz", + "integrity": "sha512-un0FmiRUQNr5PJqy9kP7c40F5BOfpGlYTrxonDChEZB7pzZxRNp/bt+ymiy9/npwXya9KH99nJ/GXFIiUkYGFQ==", "dev": true, "requires": { - "glob": "^7.1.3", - "minimatch": "^3.0.4", - "read-pkg-up": "^4.0.0", - "require-main-filename": "^2.0.0" + "ansi-escapes": "^4.2.1", + "supports-hyperlinks": "^2.0.0" + } + }, + "test-exclude": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", + "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==", + "dev": true, + "requires": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^7.1.4", + "minimatch": "^3.0.4" } }, "throat": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/throat/-/throat-4.1.0.tgz", - "integrity": "sha1-iQN8vJLFarGJJua6TLsgDhVnKmo=", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/throat/-/throat-5.0.0.tgz", + "integrity": "sha512-fcwX4mndzpLQKBS1DVYhGAcYaYt7vsHNIvQV+WXMvnow5cgjPphq5CaayLaGsjRdSCKZFNGt7/GYAuXaNOiYCA==", "dev": true }, "tmpl": { @@ -4694,72 +4605,57 @@ } }, "to-regex-range": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", - "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "dev": true, "requires": { - "is-number": "^3.0.0", - "repeat-string": "^1.6.1" + "is-number": "^7.0.0" } }, "tough-cookie": { - "version": "2.5.0", - "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz", - "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==", + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-3.0.1.tgz", + "integrity": "sha512-yQyJ0u4pZsv9D4clxO69OEjLWYw+jbgspjTue4lTQZLfV0c5l1VmK2y1JK8E9ahdpltPOaAThPcp5nKPUgSnsg==", "dev": true, "requires": { + "ip-regex": "^2.1.0", "psl": "^1.1.28", "punycode": "^2.1.1" } }, "tr46": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/tr46/-/tr46-1.0.1.tgz", - "integrity": "sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk=", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-2.0.2.tgz", + "integrity": "sha512-3n1qG+/5kg+jrbTzwAykB5yRYtQCTqOGKq5U5PE3b0a1/mzo6snDhjGS0zJVJunO0NrT3Dg1MLy5TjWP/UJppg==", "dev": true, "requires": { - "punycode": "^2.1.0" + "punycode": "^2.1.1" } }, "ts-jest": { - "version": "24.3.0", - "resolved": "https://registry.npmjs.org/ts-jest/-/ts-jest-24.3.0.tgz", - "integrity": "sha512-Hb94C/+QRIgjVZlJyiWwouYUF+siNJHJHknyspaOcZ+OQAIdFG/UrdQVXw/0B8Z3No34xkUXZJpOTy9alOWdVQ==", + "version": "26.5.3", + "resolved": "https://registry.npmjs.org/ts-jest/-/ts-jest-26.5.3.tgz", + "integrity": "sha512-nBiiFGNvtujdLryU7MiMQh1iPmnZ/QvOskBbD2kURiI1MwqvxlxNnaAB/z9TbslMqCsSbu5BXvSSQPc5tvHGeA==", "dev": true, "requires": { "bs-logger": "0.x", "buffer-from": "1.x", "fast-json-stable-stringify": "2.x", + "jest-util": "^26.1.0", "json5": "2.x", - "lodash.memoize": "4.x", + "lodash": "4.x", "make-error": "1.x", - "mkdirp": "0.x", - "resolve": "1.x", - "semver": "^5.5", - "yargs-parser": "10.x" + "mkdirp": "1.x", + "semver": "7.x", + "yargs-parser": "20.x" }, "dependencies": { - "camelcase": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-4.1.0.tgz", - "integrity": "sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=", - "dev": true - }, - "semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", - "dev": true - }, "yargs-parser": { - "version": "10.1.0", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-10.1.0.tgz", - "integrity": "sha512-VCIyR1wJoEBZUqk5PA+oOBF6ypbwh5aNB3I50guxAL/quggdfs4TtNHQrSazFA3fYZ+tEqfs0zIGlv0c/rgjbQ==", - "dev": true, - "requires": { - "camelcase": "^4.1.0" - } + "version": "20.2.6", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.6.tgz", + "integrity": "sha512-AP1+fQIWSM/sMiET8fyayjx/J+JmTPt2Mr0FkrgqB4todtfa53sOsrSAcIrJRD5XS20bKUwaDIuMkWKCEiQLKA==", + "dev": true } } }, @@ -4792,10 +4688,31 @@ "prelude-ls": "~1.1.2" } }, + "type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "dev": true + }, + "type-fest": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz", + "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==", + "dev": true + }, + "typedarray-to-buffer": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz", + "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==", + "dev": true, + "requires": { + "is-typedarray": "^1.0.0" + } + }, "typescript": { - "version": "3.7.5", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.5.tgz", - "integrity": "sha512-/P5lkRXkWHNAbcJIiHPfRoKqyd7bsyCma1hZNUGfn20qm64T6ZBlrzprymeu918H+mB/0rIg2gGK/BXkhhYgBw==", + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.2.3.tgz", + "integrity": "sha512-qOcYwxaByStAWrBf4x0fibwZvMRG+r4cQoTjbPtUlrWjBHbmCAww1i448U0GJ+3cNNEtebDteo/cHOR3xJ4wEw==", "dev": true }, "union-value": { @@ -4851,9 +4768,9 @@ } }, "uri-js": { - "version": "4.2.2", - "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz", - "integrity": "sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ==", + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", "dev": true, "requires": { "punycode": "^2.1.0" @@ -4871,23 +4788,30 @@ "integrity": "sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==", "dev": true }, - "util.promisify": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/util.promisify/-/util.promisify-1.0.1.tgz", - "integrity": "sha512-g9JpC/3He3bm38zsLupWryXHoEcS22YHthuPQSJdMy6KNrzIRzWqcsHzD/WUnqe45whVou4VIsPew37DoXWNrA==", - "dev": true, - "requires": { - "define-properties": "^1.1.3", - "es-abstract": "^1.17.2", - "has-symbols": "^1.0.1", - "object.getownpropertydescriptors": "^2.1.0" - } - }, "uuid": { "version": "3.4.0", "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz", "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==" }, + "v8-to-istanbul": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-7.1.0.tgz", + "integrity": "sha512-uXUVqNUCLa0AH1vuVxzi+MI4RfxEOKt9pBgKwHbgH7st8Kv2P1m+jvWNnektzBh5QShF3ODgKmUFCf38LnVz1g==", + "dev": true, + "requires": { + "@types/istanbul-lib-coverage": "^2.0.1", + "convert-source-map": "^1.6.0", + "source-map": "^0.7.3" + }, + "dependencies": { + "source-map": { + "version": "0.7.3", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz", + "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==", + "dev": true + } + } + }, "validate-npm-package-license": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", @@ -4910,12 +4834,21 @@ } }, "w3c-hr-time": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/w3c-hr-time/-/w3c-hr-time-1.0.1.tgz", - "integrity": "sha1-gqwr/2PZUOqeMYmlimViX+3xkEU=", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/w3c-hr-time/-/w3c-hr-time-1.0.2.tgz", + "integrity": "sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==", "dev": true, "requires": { - "browser-process-hrtime": "^0.1.2" + "browser-process-hrtime": "^1.0.0" + } + }, + "w3c-xmlserializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-2.0.0.tgz", + "integrity": "sha512-4tzD0mF8iSiMiNs30BiLO3EpfGLZUT2MSX/G+o7ZywDzliWQ3OPtTZ0PTC3B3ca1UAf4cJMHB+2Bf56EriJuRA==", + "dev": true, + "requires": { + "xml-name-validator": "^3.0.0" } }, "walker": { @@ -4928,9 +4861,9 @@ } }, "webidl-conversions": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-4.0.2.tgz", - "integrity": "sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-6.1.0.tgz", + "integrity": "sha512-qBIvFLGiBpLjfwmYAaHPXsn+ho5xZnGvyGvsarywGNc8VyQJUMHJ8OBKGGrPER0okBeMDaan4mNBlgBROxuI8w==", "dev": true }, "whatwg-encoding": { @@ -4949,14 +4882,14 @@ "dev": true }, "whatwg-url": { - "version": "6.5.0", - "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-6.5.0.tgz", - "integrity": "sha512-rhRZRqx/TLJQWUpQ6bmrt2UV4f0HCQ463yQuONJqC6fO2VoEb1pTYddbe59SkYq87aoM5A3bdhMZiUiVws+fzQ==", + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-8.4.0.tgz", + "integrity": "sha512-vwTUFf6V4zhcPkWp/4CQPr1TW9Ml6SF4lVyaIMBdJw5i6qUUJ1QWM4Z6YYVkfka0OUIzVo/0aNtGVGk256IKWw==", "dev": true, "requires": { "lodash.sortby": "^4.7.0", - "tr46": "^1.0.1", - "webidl-conversions": "^4.0.2" + "tr46": "^2.0.2", + "webidl-conversions": "^6.1.0" } }, "which": { @@ -4981,14 +4914,14 @@ "dev": true }, "wrap-ansi": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz", - "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==", + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz", + "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==", "dev": true, "requires": { - "ansi-styles": "^3.2.0", - "string-width": "^3.0.0", - "strip-ansi": "^5.0.0" + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" } }, "wrappy": { @@ -4998,24 +4931,22 @@ "dev": true }, "write-file-atomic": { - "version": "2.4.1", - "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-2.4.1.tgz", - "integrity": "sha512-TGHFeZEZMnv+gBFRfjAcxL5bPHrsGKtnb4qsFAws7/vlh+QfwAaySIw4AXP9ZskTTh5GWu3FLuJhsWVdiJPGvg==", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz", + "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==", "dev": true, "requires": { - "graceful-fs": "^4.1.11", "imurmurhash": "^0.1.4", - "signal-exit": "^3.0.2" + "is-typedarray": "^1.0.0", + "signal-exit": "^3.0.2", + "typedarray-to-buffer": "^3.1.5" } }, "ws": { - "version": "5.2.2", - "resolved": "https://registry.npmjs.org/ws/-/ws-5.2.2.tgz", - "integrity": "sha512-jaHFD6PFv6UgoIVda6qZllptQsMlDEJkTQcybzzXDYM1XO9Y8em691FGMPmM46WGyLU4z9KMgQN+qrux/nhlHA==", - "dev": true, - "requires": { - "async-limiter": "~1.0.0" - } + "version": "7.4.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.3.tgz", + "integrity": "sha512-hr6vCR76GsossIRsr8OLR9acVVm1jyfEWvhbNjtgPOrfvAlKzvyeg/P6r8RuDjRyrcQoPQT7K0DGEPc7Ae6jzA==", + "dev": true }, "xml-name-validator": { "version": "3.0.0", @@ -5024,43 +4955,64 @@ "dev": true }, "xmlbuilder2": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/xmlbuilder2/-/xmlbuilder2-2.1.2.tgz", - "integrity": "sha512-PI710tmtVlQ5VmwzbRTuhmVhKnj9pM8Si+iOZCV2g2SNo3gCrpzR2Ka9wNzZtqfD+mnP+xkrqoNy0sjKZqP4Dg==", + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/xmlbuilder2/-/xmlbuilder2-2.4.0.tgz", + "integrity": "sha512-KrOVUGD65xTQ7ZA+GMQGdBSpe1Ufu5ylCQSYVk6QostySDkxPmAQ0WWIu7dR3JjLfVbF22RFQX7KyrZ6VTLcQg==", "requires": { - "@oozcitak/dom": "1.15.5", - "@oozcitak/infra": "1.0.5", - "@oozcitak/util": "8.3.3" + "@oozcitak/dom": "1.15.8", + "@oozcitak/infra": "1.0.8", + "@oozcitak/util": "8.3.8", + "@types/node": "14.6.2", + "js-yaml": "3.14.0" + }, + "dependencies": { + "@types/node": { + "version": "14.6.2", + "resolved": "https://registry.npmjs.org/@types/node/-/node-14.6.2.tgz", + "integrity": "sha512-onlIwbaeqvZyniGPfdw/TEhKIh79pz66L1q06WUQqJLnAb6wbjvOtepLYTGHTqzdXgBYIE3ZdmqHDGsRsbBz7A==" + } } }, - "y18n": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.0.tgz", - "integrity": "sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==", + "xmlchars": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz", + "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==", "dev": true }, + "y18n": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.1.tgz", + "integrity": "sha512-wNcy4NvjMYL8gogWWYAO7ZFWFfHcbdbE57tZO8e4cbpj8tfUcwrwqSl3ad8HxpYWCdXcJUCeKKZS62Av1affwQ==", + "dev": true + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, "yargs": { - "version": "13.3.0", - "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.0.tgz", - "integrity": "sha512-2eehun/8ALW8TLoIl7MVaRUrg+yCnenu8B4kBlRxj3GJGDKU1Og7sMXPNm1BYyM1DOJmTZ4YeN/Nwxv+8XJsUA==", + "version": "15.4.1", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-15.4.1.tgz", + "integrity": "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==", "dev": true, "requires": { - "cliui": "^5.0.0", - "find-up": "^3.0.0", + "cliui": "^6.0.0", + "decamelize": "^1.2.0", + "find-up": "^4.1.0", "get-caller-file": "^2.0.1", "require-directory": "^2.1.1", "require-main-filename": "^2.0.0", "set-blocking": "^2.0.0", - "string-width": "^3.0.0", + "string-width": "^4.2.0", "which-module": "^2.0.0", "y18n": "^4.0.0", - "yargs-parser": "^13.1.1" + "yargs-parser": "^18.1.2" } }, "yargs-parser": { - "version": "13.1.1", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.1.tgz", - "integrity": "sha512-oVAVsHz6uFrg3XQheFII8ESO2ssAf9luWuAd6Wexsu4F3OtIW0o8IribPXYrD4WC24LWtPrJlGy87y5udK+dxQ==", + "version": "18.1.3", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.3.tgz", + "integrity": "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==", "dev": true, "requires": { "camelcase": "^5.0.0", diff --git a/package.json b/package.json index a082cd2..00ddd55 100644 --- a/package.json +++ b/package.json @@ -1,13 +1,13 @@ { "name": "setup-java", - "version": "1.0.0", + "version": "2.0.0", "private": true, "description": "setup java action", "main": "dist/setup/index.js", "scripts": { "build": "ncc build -o dist/setup src/setup-java.ts && ncc build -o dist/cleanup src/cleanup-java.ts", - "format": "prettier --write **/*.ts", - "format-check": "prettier --check **/*.ts", + "format": "prettier --write \"{,!(node_modules)/**/}*.ts\"", + "format-check": "prettier --check \"{,!(node_modules)/**/}*.ts\"", "prerelease": "npm run-script build", "release": "git add -f dist/setup/index.js dist/cleanup/index.js", "test": "jest" @@ -18,30 +18,30 @@ }, "keywords": [ "actions", - "node", + "java", "setup" ], "author": "GitHub", "license": "MIT", "dependencies": { - "@actions/core": "^1.0.0", - "@actions/exec": "^1.0.0", - "@actions/http-client": "^1.0.8", - "@actions/io": "^1.0.0", - "@actions/tool-cache": "^1.3.1", - "semver": "^6.1.1", - "xmlbuilder2": "^2.1.2" + "@actions/core": "^1.2.6", + "@actions/exec": "^1.0.4", + "@actions/http-client": "^1.0.9", + "@actions/io": "^1.0.2", + "@actions/tool-cache": "^1.6.1", + "semver": "^7.3.4", + "xmlbuilder2": "^2.4.0" }, "devDependencies": { - "@types/jest": "^24.0.13", - "@types/node": "^12.0.4", - "@types/semver": "^6.0.0", + "@types/jest": "^26.0.20", + "@types/node": "^12.19.13", + "@types/semver": "^7.3.4", "@zeit/ncc": "^0.20.5", - "jest": "^24.8.0", - "jest-circus": "^24.7.1", + "jest": "^26.6.3", + "jest-circus": "^26.6.3", "prettier": "^1.19.1", - "ts-jest": "^24.0.2", - "typescript": "^3.5.1" + "ts-jest": "^26.5.3", + "typescript": "^4.2.3" }, "husky": { "skipCI": true, diff --git a/src/auth.ts b/src/auth.ts index 9681049..30810bb 100644 --- a/src/auth.ts +++ b/src/auth.ts @@ -1,27 +1,47 @@ -import * as fs from 'fs'; -import * as os from 'os'; import * as path from 'path'; import * as core from '@actions/core'; import * as io from '@actions/io'; -import {create as xmlCreate} from 'xmlbuilder2'; + +import * as fs from 'fs'; +import * as os from 'os'; + +import { create as xmlCreate } from 'xmlbuilder2'; import * as constants from './constants'; +import * as gpg from './gpg'; export const M2_DIR = '.m2'; export const SETTINGS_FILE = 'settings.xml'; -export async function configAuthentication( +export async function configureAuthentication() { + const id = core.getInput(constants.INPUT_SERVER_ID); + const username = core.getInput(constants.INPUT_SERVER_USERNAME); + const password = core.getInput(constants.INPUT_SERVER_PASSWORD); + const gpgPrivateKey = + core.getInput(constants.INPUT_GPG_PRIVATE_KEY) || constants.INPUT_DEFAULT_GPG_PRIVATE_KEY; + const gpgPassphrase = + core.getInput(constants.INPUT_GPG_PASSPHRASE) || + (gpgPrivateKey ? constants.INPUT_DEFAULT_GPG_PASSPHRASE : undefined); + + if (gpgPrivateKey) { + core.setSecret(gpgPrivateKey); + } + + await createAuthenticationSettings(id, username, password, gpgPassphrase); + + if (gpgPrivateKey) { + core.info('Importing private gpg key'); + const keyFingerprint = (await gpg.importKey(gpgPrivateKey)) || ''; + core.saveState(constants.STATE_GPG_PRIVATE_KEY_FINGERPRINT, keyFingerprint); + } +} + +export async function createAuthenticationSettings( id: string, username: string, password: string, gpgPassphrase: string | undefined = undefined ) { - console.log( - `creating ${SETTINGS_FILE} with server-id: ${id};`, - 'environment variables:', - `username=\$${username},`, - `password=\$${password},`, - `and gpg-passphrase=${gpgPassphrase ? '$' + gpgPassphrase : null}` - ); + core.info(`Creating ${SETTINGS_FILE} with server-id: ${id}`); // when an alternate m2 location is specified use only that location (no .m2 directory) // otherwise use the home/.m2/ path const settingsDirectory: string = path.join( @@ -29,11 +49,7 @@ export async function configAuthentication( core.getInput(constants.INPUT_SETTINGS_PATH) ? '' : M2_DIR ); await io.mkdirP(settingsDirectory); - core.debug(`created directory ${settingsDirectory}`); - await write( - settingsDirectory, - generate(id, username, password, gpgPassphrase) - ); + await write(settingsDirectory, generate(id, username, password, gpgPassphrase)); } // only exported for testing purposes @@ -41,9 +57,9 @@ export function generate( id: string, username: string, password: string, - gpgPassphrase: string | undefined = undefined + gpgPassphrase?: string | undefined ) { - const xmlObj: {[key: string]: any} = { + const xmlObj: { [key: string]: any } = { settings: { '@xmlns': 'http://maven.apache.org/SETTINGS/1.0.0', '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance', @@ -69,15 +85,19 @@ export function generate( xmlObj.settings.servers.server.push(gpgServer); } - return xmlCreate(xmlObj).end({headless: true, prettyPrint: true, width: 80}); + return xmlCreate(xmlObj).end({ + headless: true, + prettyPrint: true, + width: 80 + }); } async function write(directory: string, settings: string) { const location = path.join(directory, SETTINGS_FILE); if (fs.existsSync(location)) { - console.warn(`overwriting existing file ${location}`); + core.info(`Overwriting existing file ${location}`); } else { - console.log(`writing ${location}`); + core.info(`Writing ${location}`); } return fs.writeFileSync(location, settings, { diff --git a/src/cleanup-java.ts b/src/cleanup-java.ts index 1660f5f..bde02bc 100644 --- a/src/cleanup-java.ts +++ b/src/cleanup-java.ts @@ -3,15 +3,13 @@ import * as gpg from './gpg'; import * as constants from './constants'; async function run() { - if (core.getInput(constants.INPUT_GPG_PRIVATE_KEY, {required: false})) { - core.info('removing private key from keychain'); + if (core.getInput(constants.INPUT_GPG_PRIVATE_KEY, { required: false })) { + core.info('Removing private key from keychain'); try { - const keyFingerprint = core.getState( - constants.STATE_GPG_PRIVATE_KEY_FINGERPRINT - ); + const keyFingerprint = core.getState(constants.STATE_GPG_PRIVATE_KEY_FINGERPRINT); await gpg.deleteKey(keyFingerprint); } catch (error) { - core.setFailed('failed to remove private key'); + core.setFailed('Failed to remove private key'); } } } diff --git a/src/constants.ts b/src/constants.ts index 2e885cf..41fd1d4 100644 --- a/src/constants.ts +++ b/src/constants.ts @@ -1,7 +1,8 @@ -export const INPUT_VERSION = 'version'; +export const MACOS_JAVA_CONTENT_POSTFIX = 'Contents/Home'; export const INPUT_JAVA_VERSION = 'java-version'; export const INPUT_ARCHITECTURE = 'architecture'; export const INPUT_JAVA_PACKAGE = 'java-package'; +export const INPUT_DISTRIBUTION = 'distribution'; export const INPUT_JDK_FILE = 'jdkFile'; export const INPUT_SERVER_ID = 'server-id'; export const INPUT_SERVER_USERNAME = 'server-username'; diff --git a/src/distributions/adopt/installer.ts b/src/distributions/adopt/installer.ts new file mode 100644 index 0000000..5b316e5 --- /dev/null +++ b/src/distributions/adopt/installer.ts @@ -0,0 +1,145 @@ +import * as core from '@actions/core'; +import * as tc from '@actions/tool-cache'; + +import fs from 'fs'; +import path from 'path'; +import semver from 'semver'; + +import { JavaBase } from '../base-installer'; +import { IAdoptAvailableVersions } from './models'; +import { JavaInstallerOptions, JavaDownloadRelease, JavaInstallerResults } from '../base-models'; +import { MACOS_JAVA_CONTENT_POSTFIX } from '../../constants'; +import { extractJdkFile, getDownloadArchiveExtension, isVersionSatisfies } from '../../util'; + +export class AdoptDistribution extends JavaBase { + constructor(installerOptions: JavaInstallerOptions) { + super('Adopt', installerOptions); + } + + protected async findPackageForDownload(version: string): Promise { + const availableVersionsRaw = await this.getAvailableVersions(); + const availableVersionsWithBinaries = availableVersionsRaw + .filter(item => item.binaries.length > 0) + .map(item => { + return { + version: item.version_data.semver, + url: item.binaries[0].package.link + } as JavaDownloadRelease; + }); + + const satisfiedVersions = availableVersionsWithBinaries + .filter(item => isVersionSatisfies(version, item.version)) + .sort((a, b) => { + return -semver.compareBuild(a.version, b.version); + }); + + const resolvedFullVersion = satisfiedVersions.length > 0 ? satisfiedVersions[0] : null; + if (!resolvedFullVersion) { + const availableOptions = availableVersionsWithBinaries.map(item => item.version).join(', '); + const availableOptionsMessage = availableOptions + ? `\nAvailable versions: ${availableOptions}` + : ''; + throw new Error( + `Could not find satisfied version for SemVer '${version}'. ${availableOptionsMessage}` + ); + } + + return resolvedFullVersion; + } + + protected async downloadTool(javaRelease: JavaDownloadRelease): Promise { + let javaPath: string; + let extractedJavaPath: string; + + core.info( + `Downloading Java ${javaRelease.version} (${this.distribution}) from ${javaRelease.url} ...` + ); + const javaArchivePath = await tc.downloadTool(javaRelease.url); + + core.info(`Extracting Java archive...`); + let extension = getDownloadArchiveExtension(); + + extractedJavaPath = await extractJdkFile(javaArchivePath, extension); + + const archiveName = fs.readdirSync(extractedJavaPath)[0]; + const archivePath = path.join(extractedJavaPath, archiveName); + const version = this.getToolcacheVersionName(javaRelease.version); + + javaPath = await tc.cacheDir(archivePath, this.toolcacheFolderName, version, this.architecture); + + if (process.platform === 'darwin') { + javaPath = path.join(javaPath, MACOS_JAVA_CONTENT_POSTFIX); + } + + return { version: javaRelease.version, path: javaPath }; + } + + private async getAvailableVersions(): Promise { + const platform = this.getPlatformOption(); + const arch = this.architecture; + const imageType = this.packageType; + const versionRange = encodeURI('[1.0,100.0]'); // retrieve all available versions + const releaseType = this.stable ? 'ga' : 'ea'; + + console.time('adopt-retrieve-available-versions'); + + const baseRequestArguments = [ + `project=jdk`, + 'vendor=adoptopenjdk', + `heap_size=normal`, + `jvm_impl=hotspot`, + 'sort_method=DEFAULT', + 'sort_order=DESC', + `os=${platform}`, + `architecture=${arch}`, + `image_type=${imageType}`, + `release_type=${releaseType}` + ].join('&'); + + // need to iterate through all pages to retrieve the list of all versions + // Adopt API doesn't provide way to retrieve the count of pages to iterate so infinity loop + let page_index = 0; + const availableVersions: IAdoptAvailableVersions[] = []; + while (true) { + const requestArguments = `${baseRequestArguments}&page_size=20&page=${page_index}`; + const availableVersionsUrl = `https://api.adoptopenjdk.net/v3/assets/version/${versionRange}?${requestArguments}`; + if (core.isDebug() && page_index === 0) { + // url is identical except page_index so print it once for debug + core.debug(`Gathering available versions from '${availableVersionsUrl}'`); + } + + const paginationPage = ( + await this.http.getJson(availableVersionsUrl) + ).result; + if (paginationPage === null || paginationPage.length === 0) { + // break infinity loop because we have reached end of pagination + break; + } + + availableVersions.push(...paginationPage); + page_index++; + } + + if (core.isDebug()) { + core.startGroup('Print information about available versions'); + console.timeEnd('adopt-retrieve-available-versions'); + console.log(`Available versions: [${availableVersions.length}]`); + console.log(availableVersions.map(item => item.version_data.semver).join(', ')); + core.endGroup(); + } + + return availableVersions; + } + + private getPlatformOption(): string { + // Adopt has own platform names so need to map them + switch (process.platform) { + case 'darwin': + return 'mac'; + case 'win32': + return 'windows'; + default: + return process.platform; + } + } +} diff --git a/src/distributions/adopt/models.ts b/src/distributions/adopt/models.ts new file mode 100644 index 0000000..cc329a2 --- /dev/null +++ b/src/distributions/adopt/models.ts @@ -0,0 +1,38 @@ +// Models from https://api.adoptopenjdk.net/swagger-ui/#/Assets/get_v3_assets_version__version + +export interface IAdoptAvailableVersions { + binaries: [ + { + architecture: string; + heap_size: string; + image_type: string; + jvm_impl: string; + os: string; + package: { + checksum: string; + checksum_link: string; + download_count: number; + link: string; + metadata_link: string; + name: string; + size: string; + }; + project: string; + scm_ref: string; + updated_at: string; + } + ]; + id: string; + release_link: string; + release_name: string; + release_type: string; + vendor: string; + version_data: { + build: number; + major: number; + minor: number; + openjdk_version: string; + security: string; + semver: string; + }; +} diff --git a/src/distributions/base-installer.ts b/src/distributions/base-installer.ts new file mode 100644 index 0000000..8c4698c --- /dev/null +++ b/src/distributions/base-installer.ts @@ -0,0 +1,121 @@ +import * as tc from '@actions/tool-cache'; +import * as core from '@actions/core'; +import semver from 'semver'; +import path from 'path'; +import * as httpm from '@actions/http-client'; +import { getToolcachePath, getVersionFromToolcachePath, isVersionSatisfies } from '../util'; +import { JavaDownloadRelease, JavaInstallerOptions, JavaInstallerResults } from './base-models'; + +export abstract class JavaBase { + protected http: httpm.HttpClient; + protected version: string; + protected architecture: string; + protected packageType: string; + protected stable: boolean; + + constructor(protected distribution: string, installerOptions: JavaInstallerOptions) { + this.http = new httpm.HttpClient('actions/setup-java', undefined, { + allowRetries: true, + maxRetries: 3 + }); + + ({ version: this.version, stable: this.stable } = this.normalizeVersion( + installerOptions.version + )); + this.architecture = installerOptions.architecture; + this.packageType = installerOptions.packageType; + } + + protected abstract downloadTool(javaRelease: JavaDownloadRelease): Promise; + protected abstract findPackageForDownload(range: string): Promise; + + public async setupJava(): Promise { + let foundJava = this.findInToolcache(); + if (foundJava) { + core.info(`Resolved Java ${foundJava.version} from tool-cache`); + } else { + core.info(`Java ${this.version} was not found in tool-cache. Trying to download...`); + const javaRelease = await this.findPackageForDownload(this.version); + foundJava = await this.downloadTool(javaRelease); + core.info(`Java ${foundJava.version} was downloaded`); + } + + core.info(`Setting Java ${foundJava.version} as the default`); + this.setJavaDefault(foundJava.version, foundJava.path); + + return foundJava; + } + + protected get toolcacheFolderName(): string { + return `Java_${this.distribution}_${this.packageType}`; + } + + protected getToolcacheVersionName(version: string): string { + if (!this.stable) { + const cleanVersion = semver.clean(version); + return `${cleanVersion}-ea`; + } + return version; + } + + protected findInToolcache(): JavaInstallerResults | null { + // we can't use tc.find directly because firstly, we need to filter versions by stability flag + // if *-ea is provided, take only ea versions from toolcache, otherwise - only stable versions + const availableVersions = tc + .findAllVersions(this.toolcacheFolderName, this.architecture) + .filter(item => item.endsWith('-ea') === !this.stable); + + const satisfiedVersions = availableVersions + .filter(item => isVersionSatisfies(this.version, item.replace(/-ea$/, ''))) + .sort(semver.rcompare); + if (!satisfiedVersions || satisfiedVersions.length === 0) { + return null; + } + + const javaPath = getToolcachePath( + this.toolcacheFolderName, + satisfiedVersions[0], + this.architecture + ); + if (!javaPath) { + return null; + } + + return { + version: getVersionFromToolcachePath(javaPath), + path: javaPath + }; + } + + protected normalizeVersion(version: string) { + let stable = true; + + if (version.endsWith('-ea')) { + version = version.replace(/-ea$/, ''); + stable = false; + } else if (version.includes('-ea.')) { + // transform '11.0.3-ea.2' -> '11.0.3+2' + version = version.replace('-ea.', '+'); + stable = false; + } + + if (!semver.validRange(version)) { + throw new Error( + `The string '${version}' is not valid SemVer notation for a Java version. Please check README file for code snippets and more detailed information` + ); + } + + return { + version, + stable + }; + } + + protected setJavaDefault(version: string, toolPath: string) { + core.exportVariable('JAVA_HOME', toolPath); + core.addPath(path.join(toolPath, 'bin')); + core.setOutput('distribution', this.distribution); + core.setOutput('path', toolPath); + core.setOutput('version', version); + } +} diff --git a/src/distributions/base-models.ts b/src/distributions/base-models.ts new file mode 100644 index 0000000..d7a7af7 --- /dev/null +++ b/src/distributions/base-models.ts @@ -0,0 +1,15 @@ +export interface JavaInstallerOptions { + version: string; + architecture: string; + packageType: string; +} + +export interface JavaInstallerResults { + version: string; + path: string; +} + +export interface JavaDownloadRelease { + version: string; + url: string; +} diff --git a/src/distributions/distribution-factory.ts b/src/distributions/distribution-factory.ts new file mode 100644 index 0000000..9589d3d --- /dev/null +++ b/src/distributions/distribution-factory.ts @@ -0,0 +1,28 @@ +import { AdoptDistribution } from './adopt/installer'; +import { JavaBase } from './base-installer'; +import { JavaInstallerOptions } from './base-models'; +import { LocalDistribution } from './local/installer'; +import { ZuluDistribution } from './zulu/installer'; + +enum JavaDistribution { + Adopt = 'adopt', + Zulu = 'zulu', + JdkFile = 'jdkfile' +} + +export function getJavaDistribution( + distributionName: string, + installerOptions: JavaInstallerOptions, + jdkFile?: string +): JavaBase | null { + switch (distributionName) { + case JavaDistribution.JdkFile: + return new LocalDistribution(installerOptions, jdkFile); + case JavaDistribution.Adopt: + return new AdoptDistribution(installerOptions); + case JavaDistribution.Zulu: + return new ZuluDistribution(installerOptions); + default: + return null; + } +} diff --git a/src/distributions/local/installer.ts b/src/distributions/local/installer.ts new file mode 100644 index 0000000..1402bc8 --- /dev/null +++ b/src/distributions/local/installer.ts @@ -0,0 +1,76 @@ +import * as tc from '@actions/tool-cache'; +import * as core from '@actions/core'; + +import fs from 'fs'; +import path from 'path'; +import semver from 'semver'; + +import { JavaBase } from '../base-installer'; +import { JavaInstallerOptions, JavaDownloadRelease, JavaInstallerResults } from '../base-models'; +import { extractJdkFile } from '../../util'; +import { MACOS_JAVA_CONTENT_POSTFIX } from '../../constants'; + +export class LocalDistribution extends JavaBase { + constructor(installerOptions: JavaInstallerOptions, private jdkFile?: string) { + super('jdkfile', installerOptions); + } + + public async setupJava(): Promise { + let foundJava = this.findInToolcache(); + + if (foundJava) { + core.info(`Resolved Java ${foundJava.version} from tool-cache`); + } else { + core.info(`Java ${this.version} was not found in tool-cache. Trying to unpack JDK file...`); + if (!this.jdkFile) { + throw new Error("'jdkFile' is not specified"); + } + const jdkFilePath = path.resolve(this.jdkFile); + const stats = fs.statSync(jdkFilePath); + + if (!stats.isFile()) { + throw new Error(`JDK file was not found in path '${jdkFilePath}'`); + } + + core.info(`Extracting Java from '${jdkFilePath}'`); + + const extractedJavaPath = await extractJdkFile(jdkFilePath); + const archiveName = fs.readdirSync(extractedJavaPath)[0]; + const archivePath = path.join(extractedJavaPath, archiveName); + const javaVersion = this.version; + + let javaPath = await tc.cacheDir( + archivePath, + this.toolcacheFolderName, + this.getToolcacheVersionName(javaVersion), + this.architecture + ); + + // for different Java distributions, postfix can exist or not so need to check both cases + if ( + process.platform === 'darwin' && + fs.existsSync(path.join(javaPath, MACOS_JAVA_CONTENT_POSTFIX)) + ) { + javaPath = path.join(javaPath, MACOS_JAVA_CONTENT_POSTFIX); + } + + foundJava = { + version: javaVersion, + path: javaPath + }; + } + + core.info(`Setting Java ${foundJava.version} as default`); + + this.setJavaDefault(foundJava.version, foundJava.path); + return foundJava; + } + + protected async findPackageForDownload(version: string): Promise { + throw new Error('This method should not be implemented in local file provider'); + } + + protected async downloadTool(javaRelease: JavaDownloadRelease): Promise { + throw new Error('This method should not be implemented in local file provider'); + } +} diff --git a/src/distributions/zulu/installer.ts b/src/distributions/zulu/installer.ts new file mode 100644 index 0000000..7cb3270 --- /dev/null +++ b/src/distributions/zulu/installer.ts @@ -0,0 +1,163 @@ +import * as core from '@actions/core'; +import * as tc from '@actions/tool-cache'; + +import path from 'path'; +import fs from 'fs'; +import semver from 'semver'; + +import { JavaBase } from '../base-installer'; +import { IZuluVersions } from './models'; +import { extractJdkFile, getDownloadArchiveExtension, isVersionSatisfies } from '../../util'; +import { JavaDownloadRelease, JavaInstallerOptions, JavaInstallerResults } from '../base-models'; + +export class ZuluDistribution extends JavaBase { + constructor(installerOptions: JavaInstallerOptions) { + super('Zulu', installerOptions); + } + + protected async findPackageForDownload(version: string): Promise { + const availableVersionsRaw = await this.getAvailableVersions(); + const availableVersions = availableVersionsRaw.map(item => { + return { + version: this.convertVersionToSemver(item.jdk_version), + url: item.url, + zuluVersion: this.convertVersionToSemver(item.zulu_version) + }; + }); + + const satisfiedVersions = availableVersions + .filter(item => isVersionSatisfies(version, item.version)) + .sort((a, b) => { + // Azul provides two versions: jdk_version and azul_version + // we should sort by both fields by descending + return ( + -semver.compareBuild(a.version, b.version) || + -semver.compareBuild(a.zuluVersion, b.zuluVersion) + ); + }) + .map(item => { + return { + version: item.version, + url: item.url + } as JavaDownloadRelease; + }); + + const resolvedFullVersion = satisfiedVersions.length > 0 ? satisfiedVersions[0] : null; + if (!resolvedFullVersion) { + const availableOptions = availableVersions.map(item => item.version).join(', '); + const availableOptionsMessage = availableOptions + ? `\nAvailable versions: ${availableOptions}` + : ''; + throw new Error( + `Could not find satisfied version for semver ${version}. ${availableOptionsMessage}` + ); + } + + return resolvedFullVersion; + } + + protected async downloadTool(javaRelease: JavaDownloadRelease): Promise { + let extractedJavaPath: string; + + core.info( + `Downloading Java ${javaRelease.version} (${this.distribution}) from ${javaRelease.url} ...` + ); + const javaArchivePath = await tc.downloadTool(javaRelease.url); + + core.info(`Extracting Java archive...`); + let extension = getDownloadArchiveExtension(); + + extractedJavaPath = await extractJdkFile(javaArchivePath, extension); + + const archiveName = fs.readdirSync(extractedJavaPath)[0]; + const archivePath = path.join(extractedJavaPath, archiveName); + + const javaPath = await tc.cacheDir( + archivePath, + this.toolcacheFolderName, + this.getToolcacheVersionName(javaRelease.version), + this.architecture + ); + + return { version: javaRelease.version, path: javaPath }; + } + + private async getAvailableVersions(): Promise { + const { arch, hw_bitness, abi } = this.getArchitectureOptions(); + const [bundleType, features] = this.packageType.split('+'); + const platform = this.getPlatformOption(); + const extension = getDownloadArchiveExtension(); + const javafx = features?.includes('fx') ?? false; + const releaseStatus = this.stable ? 'ga' : 'ea'; + + console.time('azul-retrieve-available-versions'); + const requestArguments = [ + `os=${platform}`, + `ext=${extension}`, + `bundle_type=${bundleType}`, + `javafx=${javafx}`, + `arch=${arch}`, + `hw_bitness=${hw_bitness}`, + `release_status=${releaseStatus}`, + abi ? `abi=${abi}` : null, + features ? `features=${features}` : null + ] + .filter(Boolean) + .join('&'); + + const availableVersionsUrl = `https://api.azul.com/zulu/download/community/v1.0/bundles/?${requestArguments}`; + if (core.isDebug()) { + core.debug(`Gathering available versions from '${availableVersionsUrl}'`); + } + + const availableVersions = + (await this.http.getJson>(availableVersionsUrl)).result ?? []; + + if (core.isDebug()) { + core.startGroup('Print information about available versions'); + console.timeEnd('azul-retrieve-available-versions'); + console.log(`Available versions: [${availableVersions.length}]`); + console.log(availableVersions.map(item => item.jdk_version.join('.')).join(', ')); + core.endGroup(); + } + + return availableVersions; + } + + private getArchitectureOptions(): { + arch: string; + hw_bitness: string; + abi: string; + } { + if (this.architecture == 'x64') { + return { arch: 'x86', hw_bitness: '64', abi: '' }; + } else if (this.architecture == 'x86') { + return { arch: 'x86', hw_bitness: '32', abi: '' }; + } else { + return { arch: this.architecture, hw_bitness: '', abi: '' }; + } + } + + private getPlatformOption(): string { + // Azul has own platform names so need to map them + switch (process.platform) { + case 'darwin': + return 'macos'; + case 'win32': + return 'windows'; + default: + return process.platform; + } + } + + // Azul API returns jdk_version as array of digits like [11, 0, 2, 1] + private convertVersionToSemver(version_array: number[]) { + const mainVersion = version_array.slice(0, 3).join('.'); + if (version_array.length > 3) { + // intentionally ignore more than 4 numbers because it is invalid semver + return `${mainVersion}+${version_array[3]}`; + } + + return mainVersion; + } +} diff --git a/src/distributions/zulu/models.ts b/src/distributions/zulu/models.ts new file mode 100644 index 0000000..a97406f --- /dev/null +++ b/src/distributions/zulu/models.ts @@ -0,0 +1,9 @@ +// Models from https://app.swaggerhub.com/apis-docs/azul/zulu-download-community/1.0 + +export interface IZuluVersions { + id: number; + name: string; + url: string; + jdk_version: Array; + zulu_version: Array; +} diff --git a/src/gpg.ts b/src/gpg.ts index c8e5d7b..10c2033 100644 --- a/src/gpg.ts +++ b/src/gpg.ts @@ -3,7 +3,7 @@ import * as path from 'path'; import * as io from '@actions/io'; import * as exec from '@actions/exec'; import * as util from './util'; -import {ExecOptions} from '@actions/exec/lib/interfaces'; +import { ExecOptions } from '@actions/exec/lib/interfaces'; export const PRIVATE_KEY_FILE = path.join(util.getTempDir(), 'private-key.asc'); @@ -28,13 +28,7 @@ export async function importKey(privateKey: string) { await exec.exec( 'gpg', - [ - '--batch', - '--import-options', - 'import-show', - '--import', - PRIVATE_KEY_FILE - ], + ['--batch', '--import-options', 'import-show', '--import', PRIVATE_KEY_FILE], options ); @@ -45,14 +39,8 @@ export async function importKey(privateKey: string) { } export async function deleteKey(keyFingerprint: string) { - await exec.exec( - 'gpg', - ['--batch', '--yes', '--delete-secret-keys', keyFingerprint], - {silent: true} - ); - await exec.exec( - 'gpg', - ['--batch', '--yes', '--delete-keys', keyFingerprint], - {silent: true} - ); + await exec.exec('gpg', ['--batch', '--yes', '--delete-secret-keys', keyFingerprint], { + silent: true + }); + await exec.exec('gpg', ['--batch', '--yes', '--delete-keys', keyFingerprint], { silent: true }); } diff --git a/src/installer.ts b/src/installer.ts deleted file mode 100644 index b48eeb0..0000000 --- a/src/installer.ts +++ /dev/null @@ -1,298 +0,0 @@ -import * as core from '@actions/core'; -import * as io from '@actions/io'; -import * as exec from '@actions/exec'; -import * as httpm from '@actions/http-client'; -import * as tc from '@actions/tool-cache'; -import * as fs from 'fs'; -import * as path from 'path'; -import * as semver from 'semver'; -import * as util from './util'; - -const tempDirectory = util.getTempDir(); -const IS_WINDOWS = util.isWindows(); - -export async function getJava( - version: string, - arch: string, - jdkFile: string, - javaPackage: string -): Promise { - let toolPath = tc.find(javaPackage, version); - - if (toolPath) { - core.debug(`Tool found in cache ${toolPath}`); - } else { - let compressedFileExtension = ''; - if (!jdkFile) { - core.debug('Downloading JDK from Azul'); - const http = new httpm.HttpClient('setup-java', undefined, { - allowRetries: true, - maxRetries: 3 - }); - const url = 'https://static.azul.com/zulu/bin/'; - const response = await http.get(url); - const statusCode = response.message.statusCode || 0; - if (statusCode < 200 || statusCode > 299) { - let body = ''; - try { - body = await response.readBody(); - } catch (err) { - core.debug(`Unable to read body: ${err.message}`); - } - const message = `Unexpected HTTP status code '${response.message.statusCode}' when retrieving versions from '${url}'. ${body}`.trim(); - throw new Error(message); - } - - const contents = await response.readBody(); - const refs = contents.match(//gi) || []; - const downloadInfo = getDownloadInfo(refs, version, arch, javaPackage); - jdkFile = await tc.downloadTool(downloadInfo.url); - version = downloadInfo.version; - compressedFileExtension = IS_WINDOWS ? '.zip' : '.tar.gz'; - } else { - core.debug('Retrieving Jdk from local path'); - } - compressedFileExtension = compressedFileExtension || getFileEnding(jdkFile); - let tempDir: string = path.join( - tempDirectory, - 'temp_' + Math.floor(Math.random() * 2000000000) - ); - const jdkDir = await unzipJavaDownload( - jdkFile, - compressedFileExtension, - tempDir - ); - core.debug(`jdk extracted to ${jdkDir}`); - toolPath = await tc.cacheDir( - jdkDir, - javaPackage, - getCacheVersionString(version), - arch - ); - } - - let extendedJavaHome = 'JAVA_HOME_' + version + '_' + arch; - core.exportVariable(extendedJavaHome, toolPath); //TODO: remove for v2 - // For portability reasons environment variables should only consist of - // uppercase letters, digits, and the underscore. Therefore we convert - // the extendedJavaHome variable to upper case and replace '.' symbols and - // any other non-alphanumeric characters with an underscore. - extendedJavaHome = extendedJavaHome.toUpperCase().replace(/[^0-9A-Z_]/g, '_'); - core.exportVariable('JAVA_HOME', toolPath); - core.exportVariable(extendedJavaHome, toolPath); - core.addPath(path.join(toolPath, 'bin')); - core.setOutput('path', toolPath); - core.setOutput('version', version); -} - -function getCacheVersionString(version: string) { - const versionArray = version.split('.'); - const major = versionArray[0]; - const minor = versionArray.length > 1 ? versionArray[1] : '0'; - const patch = versionArray.length > 2 ? versionArray[2] : '0'; - return `${major}.${minor}.${patch}`; -} - -function getFileEnding(file: string): string { - let fileEnding = ''; - - if (file.endsWith('.tar')) { - fileEnding = '.tar'; - } else if (file.endsWith('.tar.gz')) { - fileEnding = '.tar.gz'; - } else if (file.endsWith('.zip')) { - fileEnding = '.zip'; - } else if (file.endsWith('.7z')) { - fileEnding = '.7z'; - } else { - throw new Error(`${file} has an unsupported file extension`); - } - - return fileEnding; -} - -async function extractFiles( - file: string, - fileEnding: string, - destinationFolder: string -): Promise { - const stats = fs.statSync(file); - if (!stats) { - throw new Error(`Failed to extract ${file} - it doesn't exist`); - } else if (stats.isDirectory()) { - throw new Error(`Failed to extract ${file} - it is a directory`); - } - - if ('.tar' === fileEnding || '.tar.gz' === fileEnding) { - await tc.extractTar(file, destinationFolder); - } else if ('.zip' === fileEnding) { - await tc.extractZip(file, destinationFolder); - } else { - // fall through and use sevenZip - await tc.extract7z(file, destinationFolder); - } -} - -// This method recursively finds all .pack files under fsPath and unpacks them with the unpack200 tool -async function unpackJars(fsPath: string, javaBinPath: string) { - if (fs.existsSync(fsPath)) { - if (fs.lstatSync(fsPath).isDirectory()) { - for (const file in fs.readdirSync(fsPath)) { - const curPath = path.join(fsPath, file); - await unpackJars(curPath, javaBinPath); - } - } else if (path.extname(fsPath).toLowerCase() === '.pack') { - // Unpack the pack file synchonously - const p = path.parse(fsPath); - const toolName = IS_WINDOWS ? 'unpack200.exe' : 'unpack200'; - const args = IS_WINDOWS ? '-r -v -l ""' : ''; - const name = path.join(p.dir, p.name); - await exec.exec(`"${path.join(javaBinPath, toolName)}"`, [ - `${args} "${name}.pack" "${name}.jar"` - ]); - } - } -} - -async function unzipJavaDownload( - repoRoot: string, - fileEnding: string, - destinationFolder: string, - extension?: string -): Promise { - // Create the destination folder if it doesn't exist - await io.mkdirP(destinationFolder); - - const jdkFile = path.normalize(repoRoot); - const stats = fs.statSync(jdkFile); - if (stats.isFile()) { - await extractFiles(jdkFile, fileEnding, destinationFolder); - const jdkDirectory = path.join( - destinationFolder, - fs.readdirSync(destinationFolder)[0] - ); - await unpackJars(jdkDirectory, path.join(jdkDirectory, 'bin')); - return jdkDirectory; - } else { - throw new Error(`Jdk argument ${jdkFile} is not a file`); - } -} - -function getDownloadInfo( - refs: string[], - version: string, - arch: string, - javaPackage: string -): {version: string; url: string} { - version = normalizeVersion(version); - - const archExtension = arch === 'x86' ? 'i686' : 'x64'; - - let extension = ''; - if (IS_WINDOWS) { - extension = `-win_${archExtension}.zip`; - } else { - if (process.platform === 'darwin') { - extension = `-macosx_${archExtension}.tar.gz`; - } else { - extension = `-linux_${archExtension}.tar.gz`; - } - } - - core.debug(`Searching for files with extension: ${extension}`); - - let pkgRegexp = new RegExp(''); - let pkgTypeLength = 0; - if (javaPackage === 'jdk') { - pkgRegexp = /jdk.*-/gi; - pkgTypeLength = 'jdk'.length; - } else if (javaPackage == 'jre') { - pkgRegexp = /jre.*-/gi; - pkgTypeLength = 'jre'.length; - } else if (javaPackage == 'jdk+fx') { - pkgRegexp = /fx-jdk.*-/gi; - pkgTypeLength = 'fx-jdk'.length; - } else { - throw new Error( - `package argument ${javaPackage} is not in [jdk | jre | jdk+fx]` - ); - } - - // Maps version to url - let versionMap = new Map(); - - // Filter by platform - refs.forEach(ref => { - if (!ref.endsWith(extension + '">')) { - return; - } - - // If we haven't returned, means we're looking at the correct platform - let versions = ref.match(pkgRegexp) || []; - if (versions.length > 1) { - throw new Error( - `Invalid ref received from https://static.azul.com/zulu/bin/: ${ref}` - ); - } - if (versions.length == 0) { - return; - } - const refVersion = versions[0].slice(pkgTypeLength, versions[0].length - 1); - - if (semver.satisfies(refVersion, version)) { - versionMap.set( - refVersion, - 'https://static.azul.com/zulu/bin/' + - ref.slice(''.length) - ); - } - }); - - // Choose the most recent satisfying version - let curVersion = '0.0.0'; - let curUrl = ''; - for (const entry of versionMap.entries()) { - const entryVersion = entry[0]; - const entryUrl = entry[1]; - if (semver.gt(entryVersion, curVersion)) { - curUrl = entryUrl; - curVersion = entryVersion; - } - } - - if (curUrl == '') { - throw new Error( - `No valid download found for version ${version} and package ${javaPackage}. Check https://static.azul.com/zulu/bin/ for a list of valid versions or download your own jdk file and add the jdkFile argument` - ); - } - - return {version: curVersion, url: curUrl}; -} - -function normalizeVersion(version: string): string { - if (version.slice(0, 2) === '1.') { - // Trim leading 1. for versions like 1.8 - version = version.slice(2); - if (!version) { - throw new Error('1. is not a valid version'); - } - } - - if (version.endsWith('-ea')) { - // convert e.g. 14-ea to 14.0.0-ea - if (version.indexOf('.') == -1) { - version = version.slice(0, version.length - 3) + '.0.0-ea'; - } - // match anything in -ea.X (semver won't do .x matching on pre-release versions) - if (version[0] >= '0' && version[0] <= '9') { - version = '>=' + version; - } - } else if (version.split('.').length < 3) { - // For non-ea versions, add trailing .x if it is missing - if (version[version.length - 1] != 'x') { - version = version + '.x'; - } - } - - return version; -} diff --git a/src/setup-java.ts b/src/setup-java.ts index 5ba3529..1641b78 100644 --- a/src/setup-java.ts +++ b/src/setup-java.ts @@ -1,60 +1,43 @@ import * as core from '@actions/core'; -import * as installer from './installer'; import * as auth from './auth'; -import * as gpg from './gpg'; + import * as constants from './constants'; import * as path from 'path'; +import { getJavaDistribution } from './distributions/distribution-factory'; +import { JavaInstallerOptions } from './distributions/base-models'; async function run() { try { - let version = core.getInput(constants.INPUT_VERSION); - if (!version) { - version = core.getInput(constants.INPUT_JAVA_VERSION, {required: true}); + const version = core.getInput(constants.INPUT_JAVA_VERSION, { required: true }); + const distributionName = core.getInput(constants.INPUT_DISTRIBUTION, { required: true }); + const architecture = core.getInput(constants.INPUT_ARCHITECTURE); + const packageType = core.getInput(constants.INPUT_JAVA_PACKAGE); + const jdkFile = core.getInput(constants.INPUT_JDK_FILE); + + const installerOptions: JavaInstallerOptions = { + architecture, + packageType, + version + }; + + const distribution = getJavaDistribution(distributionName, installerOptions, jdkFile); + if (!distribution) { + throw new Error(`No supported distribution was found for input ${distributionName}`); } - const arch = core.getInput(constants.INPUT_ARCHITECTURE, {required: true}); - if (!['x86', 'x64'].includes(arch)) { - throw new Error(`architecture "${arch}" is not in [x86 | x64]`); - } + const result = await distribution.setupJava(); - const javaPackage = core.getInput(constants.INPUT_JAVA_PACKAGE, { - required: true - }); - const jdkFile = core.getInput(constants.INPUT_JDK_FILE, {required: false}); - - await installer.getJava(version, arch, jdkFile, javaPackage); + core.info(''); + core.info('Java configuration:'); + core.info(` Distribution: ${distributionName}`); + core.info(` Version: ${result.version}`); + core.info(` Path: ${result.path}`); + core.info(''); const matchersPath = path.join(__dirname, '..', '..', '.github'); core.info(`##[add-matcher]${path.join(matchersPath, 'java.json')}`); - const id = core.getInput(constants.INPUT_SERVER_ID, {required: false}); - const username = core.getInput(constants.INPUT_SERVER_USERNAME, { - required: false - }); - const password = core.getInput(constants.INPUT_SERVER_PASSWORD, { - required: false - }); - const gpgPrivateKey = - core.getInput(constants.INPUT_GPG_PRIVATE_KEY, {required: false}) || - constants.INPUT_DEFAULT_GPG_PRIVATE_KEY; - const gpgPassphrase = - core.getInput(constants.INPUT_GPG_PASSPHRASE, {required: false}) || - (gpgPrivateKey ? constants.INPUT_DEFAULT_GPG_PASSPHRASE : undefined); - - if (gpgPrivateKey) { - core.setSecret(gpgPrivateKey); - } - - await auth.configAuthentication(id, username, password, gpgPassphrase); - - if (gpgPrivateKey) { - core.info('importing private key'); - const keyFingerprint = (await gpg.importKey(gpgPrivateKey)) || ''; - core.saveState( - constants.STATE_GPG_PRIVATE_KEY_FINGERPRINT, - keyFingerprint - ); - } + await auth.configureAuthentication(); } catch (error) { core.setFailed(error.message); } diff --git a/src/util.ts b/src/util.ts index 671727c..2864faa 100644 --- a/src/util.ts +++ b/src/util.ts @@ -1,26 +1,66 @@ -import * as path from 'path'; +import os from 'os'; +import path from 'path'; +import * as fs from 'fs'; +import * as semver from 'semver'; +import * as tc from '@actions/tool-cache'; export function getTempDir() { - let tempDirectory = process.env.RUNNER_TEMP; - if (tempDirectory === undefined) { - let baseLocation; - if (isWindows()) { - // On windows use the USERPROFILE env variable - baseLocation = process.env['USERPROFILE'] - ? process.env['USERPROFILE'] - : 'C:\\'; - } else { - if (process.platform === 'darwin') { - baseLocation = '/Users'; - } else { - baseLocation = '/home'; - } - } - tempDirectory = path.join(baseLocation, 'actions', 'temp'); - } + let tempDirectory = process.env['RUNNER_TEMP'] || os.tmpdir(); + return tempDirectory; } -export function isWindows() { - return process.platform === 'win32'; +export function getVersionFromToolcachePath(toolPath: string) { + if (toolPath) { + return path.basename(path.dirname(toolPath)); + } + + return toolPath; +} + +export async function extractJdkFile(toolPath: string, extension?: string) { + if (!extension) { + extension = toolPath.endsWith('.tar.gz') ? 'tar.gz' : path.extname(toolPath); + if (extension.startsWith('.')) { + extension = extension.substring(1); + } + } + + switch (extension) { + case 'tar.gz': + case 'tar': + return await tc.extractTar(toolPath); + case 'zip': + return await tc.extractZip(toolPath); + default: + return await tc.extract7z(toolPath); + } +} + +export function getDownloadArchiveExtension() { + return process.platform === 'win32' ? 'zip' : 'tar.gz'; +} + +export function isVersionSatisfies(range: string, version: string): boolean { + if (semver.valid(range)) { + // if full version with build digit is provided as a range (such as '1.2.3+4') + // we should check for exact equal via compareBuild + // since semver.satisfies doesn't handle 4th digit + const semRange = semver.parse(range); + if (semRange && semRange.build?.length > 0) { + return semver.compareBuild(range, version) === 0; + } + } + + return semver.satisfies(version, range); +} + +export function getToolcachePath(toolName: string, version: string, architecture: string) { + const toolcacheRoot = process.env['RUNNER_TOOL_CACHE'] ?? ''; + const fullPath = path.join(toolcacheRoot, toolName, version, architecture); + if (fs.existsSync(fullPath)) { + return fullPath; + } + + return null; } diff --git a/yaml-lint-config.yml b/yaml-lint-config.yml index addf0aa..21fad9c 100644 --- a/yaml-lint-config.yml +++ b/yaml-lint-config.yml @@ -1,7 +1,7 @@ extends: default rules: - # 80 chars should be enough, but don't fail if a line is longer + # 100 chars should be enough, but don't fail if a line is longer line-length: - max: 80 + max: 100 level: warning