[ { "path": ".dockerignore", "content": "/src/target" }, { "path": ".gitattributes", "content": "src/crusader-lib/assets/* linguist-vendored" }, { "path": ".github/workflows/ci.yml", "content": "name: ci\r\n\r\non:\r\n push:\r\n branches: [master]\r\n pull_request:\r\n\r\nenv:\r\n CARGO_INCREMENTAL: 0\r\n\r\njobs:\r\n build:\r\n runs-on: ubuntu-latest\r\n steps:\r\n - uses: actions/checkout@v2\r\n\r\n - uses: actions-rs/toolchain@v1\r\n with:\r\n toolchain: stable\r\n override: true\r\n components: rustfmt, clippy\r\n\r\n - name: Build server-only binary\r\n run: cargo build -p crusader --no-default-features\r\n working-directory: src\r\n\r\n - name: Build\r\n run: cargo build\r\n working-directory: src\r\n\r\n - name: Lint\r\n run: cargo clippy --all -- -D warnings\r\n working-directory: src\r\n\r\n - name: Format\r\n run: cargo fmt --all -- --check\r\n working-directory: src\r\n\r\n android:\r\n runs-on: ubuntu-latest\r\n steps:\r\n - uses: actions/checkout@v2\r\n\r\n - uses: actions-rs/toolchain@v1\r\n with:\r\n toolchain: stable\r\n override: true\r\n components: rustfmt, clippy\r\n\r\n - name: Install Rust targets\r\n run: >\r\n rustup target add\r\n aarch64-linux-android\r\n armv7-linux-androideabi\r\n x86_64-linux-android\r\n i686-linux-android\r\n\r\n - name: Install cargo-ndk\r\n run: cargo install cargo-ndk\r\n\r\n - name: Setup Java\r\n uses: actions/setup-java@v3\r\n with:\r\n distribution: 'temurin'\r\n java-version: '17'\r\n\r\n - name: Setup Android SDK\r\n uses: android-actions/setup-android@v2\r\n\r\n - name: Build Android Rust crates\r\n working-directory: android\r\n run: cargo ndk -t arm64-v8a -o app/src/main/jniLibs/ -- build\r\n\r\n - name: Build Android APK\r\n working-directory: android\r\n run: ./gradlew buildDebug\r\n\r\n # Wait for a new cargo ndk release for better clippy support\r\n #- name: Lint\r\n # run: cargo ndk -t arm64-v8a -- clippy --all -- -D warnings\r\n # working-directory: android\r\n\r\n - name: Format\r\n run: cargo fmt --all -- --check\r\n working-directory: android\r\n" }, { "path": ".github/workflows/release.md", "content": "Crusader has pre-built binaries for a number of operating systems. Download the appropriate binary below for your OS." }, { "path": ".github/workflows/release.yml", "content": "name: release\r\non:\r\n push:\r\n tags:\r\n - \"v*\"\r\n\r\nenv:\r\n CARGO_INCREMENTAL: 0\r\n\r\njobs:\r\n create-release:\r\n name: create-release\r\n runs-on: ubuntu-latest\r\n outputs:\r\n upload_url: ${{ steps.release.outputs.upload_url }}\r\n permissions:\r\n contents: write\r\n steps:\r\n - uses: actions/checkout@v2\r\n\r\n - name: Get the release version from the tag\r\n shell: bash\r\n run: echo \"TAG_NAME=${GITHUB_REF#refs/tags/}\" >> $GITHUB_ENV\r\n\r\n - name: Create GitHub release\r\n id: release\r\n uses: actions/create-release@v1.1.4\r\n env:\r\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\r\n with:\r\n tag_name: ${{ env.TAG_NAME }}\r\n release_name: Automated build of ${{ env.TAG_NAME }}\r\n prerelease: true\r\n body_path: .github/workflows/release.md\r\n\r\n release-assets:\r\n name: Release assets\r\n needs: create-release\r\n runs-on: ${{ matrix.build.os }}\r\n strategy:\r\n fail-fast: false\r\n matrix:\r\n build:\r\n - os: ubuntu-latest\r\n target: arm-unknown-linux-musleabihf\r\n friendly: Linux-ARM-32-bit\r\n exe_postfix:\r\n cargo: cross\r\n gui: false\r\n\r\n - os: ubuntu-latest\r\n target: aarch64-unknown-linux-musl\r\n friendly: Linux-ARM-64-bit\r\n exe_postfix:\r\n cargo: cross\r\n gui: false\r\n\r\n - os: ubuntu-latest\r\n target: x86_64-unknown-linux-musl\r\n friendly: Linux-X86-64-bit\r\n exe_postfix:\r\n cargo: cargo\r\n gui: false\r\n\r\n - os: macos-latest\r\n target: aarch64-apple-darwin\r\n friendly: macOS-ARM-64-bit\r\n exe_postfix:\r\n cargo: cargo\r\n gui: true\r\n\r\n - os: macos-latest\r\n target: x86_64-apple-darwin\r\n friendly: macOS-X86-64-bit\r\n exe_postfix:\r\n cargo: cargo\r\n gui: true\r\n\r\n - os: windows-latest\r\n target: i686-pc-windows-msvc\r\n friendly: Windows-X86-32-bit\r\n exe_postfix: .exe\r\n cargo: cargo\r\n gui: true\r\n\r\n - os: windows-latest\r\n target: x86_64-pc-windows-msvc\r\n friendly: Windows-X86-64-bit\r\n exe_postfix: .exe\r\n cargo: cargo\r\n gui: true\r\n steps:\r\n - uses: actions/checkout@v2\r\n\r\n - uses: actions-rs/toolchain@v1\r\n with:\r\n toolchain: stable\r\n override: true\r\n target: ${{ matrix.build.target }}\r\n\r\n - name: Install cross\r\n if: matrix.build.cargo == 'cross'\r\n run: cargo install cross\r\n\r\n - name: Install and use musl\r\n if: matrix.build.os == 'ubuntu-latest' && matrix.build.cargo != 'cross'\r\n run: |\r\n sudo apt-get install -y --no-install-recommends musl-tools\r\n echo \"CC=musl-gcc\" >> $GITHUB_ENV\r\n echo \"AR=ar\" >> $GITHUB_ENV\r\n\r\n - name: Build command line binary\r\n if: ${{ !matrix.build.gui }}\r\n run: ${{ matrix.build.cargo }} build -p crusader --target ${{ matrix.build.target }} --release\r\n working-directory: src\r\n env:\r\n RUSTFLAGS: \"-C target-feature=+crt-static\"\r\n\r\n - name: Build\r\n if: matrix.build.gui\r\n run: ${{ matrix.build.cargo }} build --target ${{ matrix.build.target }} --release\r\n working-directory: src\r\n env:\r\n RUSTFLAGS: \"-C target-feature=+crt-static\"\r\n\r\n - name: Build output\r\n shell: bash\r\n run: |\r\n staging=\"Crusader-${{ matrix.build.friendly }}\"\r\n mkdir -p \"$staging\"\r\n cp src/target/${{ matrix.build.target }}/release/crusader${{ matrix.build.exe_postfix }} \"$staging/\"\r\n\r\n - name: Copy GUI binary\r\n if: matrix.build.gui\r\n shell: bash\r\n run: |\r\n cp src/target/${{ matrix.build.target }}/release/crusader-gui${{ matrix.build.exe_postfix }} \"crusader-${{ matrix.build.friendly }}/\"\r\n\r\n - name: Archive output\r\n if: matrix.build.os == 'windows-latest'\r\n shell: bash\r\n run: |\r\n staging=\"Crusader-${{ matrix.build.friendly }}\"\r\n 7z a \"$staging.zip\" \"$staging\"\r\n echo \"ASSET=$staging.zip\" >> $GITHUB_ENV\r\n\r\n - name: Archive output\r\n if: matrix.build.os != 'windows-latest'\r\n shell: bash\r\n run: |\r\n staging=\"Crusader-${{ matrix.build.friendly }}\"\r\n tar czf \"$staging.tar.gz\" \"$staging\"\r\n echo \"ASSET=$staging.tar.gz\" >> $GITHUB_ENV\r\n\r\n - name: Upload archive\r\n uses: actions/upload-release-asset@v1.0.2\r\n env:\r\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\r\n with:\r\n upload_url: ${{ needs.create-release.outputs.upload_url }}\r\n asset_name: ${{ env.ASSET }}\r\n asset_path: ${{ env.ASSET }}\r\n asset_content_type: application/octet-stream\r\n\r\n release-android-assets:\r\n name: Android APK\r\n needs: create-release\r\n runs-on: ubuntu-latest\r\n steps:\r\n - uses: actions/checkout@v2\r\n\r\n - uses: actions-rs/toolchain@v1\r\n with:\r\n toolchain: stable\r\n override: true\r\n\r\n - name: Install Rust targets\r\n run: >\r\n rustup target add\r\n aarch64-linux-android\r\n armv7-linux-androideabi\r\n x86_64-linux-android\r\n i686-linux-android\r\n\r\n - name: Install cargo-ndk\r\n run: cargo install cargo-ndk\r\n\r\n - name: Setup Java\r\n uses: actions/setup-java@v3\r\n with:\r\n distribution: 'temurin'\r\n java-version: '17'\r\n\r\n - name: Setup Android SDK\r\n uses: android-actions/setup-android@v2\r\n\r\n - name: Build Android Rust crates\r\n working-directory: android\r\n run: >\r\n cargo ndk\r\n -t arm64-v8a\r\n -t armeabi-v7a\r\n -t x86_64\r\n -t x86\r\n -o app/src/main/jniLibs/ -- build --release\r\n\r\n - name: Decode Keystore\r\n env:\r\n ENCODED_STRING: ${{ secrets.KEYSTORE }}\r\n run: echo \"$ENCODED_STRING\" | base64 -di > ../android.keystore\r\n\r\n - name: Build Android APK\r\n working-directory: android\r\n run: ./gradlew build\r\n env:\r\n SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}\r\n SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}\r\n SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}\r\n\r\n - name: Upload APK\r\n uses: actions/upload-release-asset@v1.0.2\r\n env:\r\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\r\n with:\r\n upload_url: ${{ needs.create-release.outputs.upload_url }}\r\n asset_name: Crusader-Android.apk\r\n asset_path: android/app/build/outputs/apk/release/app-release.apk\r\n asset_content_type: application/octet-stream\r\n" }, { "path": ".gitignore", "content": "/src/target\n" }, { "path": "CHANGELOG.md", "content": "# CHANGELOG\n\nThe **Crusader Network Tester** measures network rates and latency\nin the presence of upload and download traffic.\nIt produces plots of the traffic rates,\nlatency and packet loss.\n\nThis file lists the changes that have occurred since January 2024 in the project.\n\n## Unreleased\n\n## 0.3.2 - 2024-10-03\n\n* Fix saved raw data path printed after a test\n* Avoid duplicate legends when plotting transferred bytes\n* Make `--plot-transferred` increase default plot height\n* Fix unique output path generation\n\n## 0.3.1 - 2024-09-30\n\n* Increase samples used for clock synchronization and idle latency measurement\n* Clock synchronization now uses the average of the lowest 1/3rd of samples\n* Adjust for clock drift in tests\n* Fix connecting to servers on non-standard port with peers\n* Make discovery more robust by sending multiple packets\n\n## 0.3 - 2024-09-16\n\n* Show throughput, latency, and packet loss summaries in plots and with the `test` command\n* Rename both option to bidirectional\n* Rename `--latency-peer-server` to `--latency-peer-address`\n* Continuous clock synchronization with the latency monitor\n* Support opening result files in the GUI by drag and drop\n* Add `--out-name` command line option to specify result filename prefix\n* Change filename prefix for both raw result and plots to `test`\n* Add file dialog to save options in GUI\n* Add buttons to save and load from the `crusader-results` folder in GUI\n* Add an `export` command line command to convert result files to JSON\n* Change timeout when connecting a peer to the server to 8 seconds\n* Hide advanced parameters in GUI\n* Add a reset parameters button in GUI\n* Add an option to measure latency-only for the client in the GUI\n* Don't allow peers to connect with the regular server\n* Added average lines in GUI\n\n## 0.2 - 2024-08-29\n\n* Added support for local discovery of server and peers using UDP port 35483\n* The `test` command line option `--latency-peer` is renamed to `--latency-peer-server`.\n A new flag `--latency-peer` will instead search for a local peer.\n* Improved error messages\n* Fix date/time display in remote web page\n* Rename the `Latency` tab to `Monitor`\n* Change default streams from 16 to 8.\n* Change default throughput sample interval from 20 ms to 60 ms.\n* Change default load duration from 5 s to 10 s.\n* Change default grace duration from 5 s to 10 s.\n* Fix serving from link-local interfaces on Linux\n* Fix peers on link-local interfaces\n* Show download and upload plots for aggregate tests in the GUI\n* Added a shortcut (space) to stop the latency monitor\n* Change timeout when connecting to servers and peers to 8 seconds\n* Added average lines to the plot output\n* Show interface IPs when starting servers\n\n## 0.1 - 2024-08-21\n\n* Added `crusader remote` command to start a web server listening on port 35482.\n It allows starting tests on a separate machine and\n displays the resulting charts in the web page.\n* Use system fonts in GUI\n* Improved error handling and error messages\n* Added `--idle` option to the client to test without traffic\n* Save results in a `crusader-results` folder\n* Allow building of a server-only binary\n* Generated files will use a YYYY-MM-DD HH.MM.SS format\n* Rename bandwidth to throughput\n* Rename sample rate to sample interval\n* Rename `Both` to `Aggregate` and `Total` to `Round-trip` in plots\n\n## 0.0.12 - 2024-07-31\n\n* Create UDP server for each server IP (fixes #22)\n* Improved error handling for log messages\n* Changed date format to use YYYY-MM-DD in logs\n\n## 0.0.11 - 2024-07-29\n\n* Log file includes timestamps and version number\n* Added peer latency measurements\n* Added version to title bar of GUI\n* Added `plot_max_bandwidth` and `plot_max_latency` command line options\n\n## 0.0.10 - 2024-01-09\n\n* Specify plot title\n* Ignore ENOBUFS error\n" }, { "path": "LICENSE-APACHE", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n" }, { "path": "LICENSE-MIT", "content": "Permission is hereby granted, free of charge, to any\nperson obtaining a copy of this software and associated\ndocumentation files (the \"Software\"), to deal in the\nSoftware without restriction, including without\nlimitation the rights to use, copy, modify, merge,\npublish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software\nis furnished to do so, subject to the following\nconditions:\n\nThe above copyright notice and this permission notice\nshall be included in all copies or substantial portions\nof the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF\nANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\nTO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\nPARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\nSHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\nIN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n" }, { "path": "README.md", "content": "# Crusader Network Tester\n\n[![GitHub Release](https://img.shields.io/github/v/release/Zoxc/crusader)](https://github.com/Zoxc/crusader/releases)\n[![Docker Hub](https://img.shields.io/badge/container-dockerhub-blue)](https://hub.docker.com/r/zoxc/crusader)\n[![MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/Zoxc/crusader/blob/master/LICENSE-MIT)\n[![Apache](https://img.shields.io/badge/license-Apache-blue.svg)](https://github.com/Zoxc/crusader/blob/master/LICENSE-APACHE)\n\n![Crusader Results Screenshot](./media/Crusader-Result.png)\n\nThe **Crusader Network Tester** measures network throughput, latency and packet loss\nin the presence of upload and download traffic.\nIt also incorporates a continuous latency tester for\nmonitoring background responsiveness.\n\nCrusader makes throughput measurements using TCP on port 35481\nand latency tests using UDP port 35481.\nThe remote web server option uses TCP port 35482.\nLocal server discovery uses UDP port 35483.\n\n**Pre-built binaries** for Windows, Mac, Linux,\nand Android are available on the\n[Releases](https://github.com/Zoxc/crusader/releases) page.\nThe GUI is not prebuilt for Linux and must be built from source.\n\n**Documentation** See the [Documentation](#documentation)\nsection below.\n\n**Status:** The latest Crusader release version is shown above.\n The [pre-built binaries](https://github.com/Zoxc/crusader/releases)\n always provide the latest version.\n See the [CHANGELOG.md](./CHANGELOG.md) file for details.\n\n## Crusader GUI\n\nA test run requires two separate computers,\nboth running Crusader:\na **server** that listens for connections, and\na **client** that initiates the test.\n\nThe Crusader GUI incorporates both the server and\nthe client and allows you to interact with results.\nTo use it, download the proper binary from the\n[Releases](https://github.com/Zoxc/crusader/releases) page.\n\nWhen you open the `crusader-gui` you see this window.\nEnter the address of another computer that's\nrunning the Crusader server, then click **Start test**.\nWhen the test is complete, the **Result** tab shows a\nchart like the second image below.\n\nAn easy way to use Crusader is to download\nthe Crusader GUI onto two computers, then\nstart the server on one computer, and the client on the other.\n\n![Crusader Client Screenshot](./media/Crusader-Client.png)\n\nThe Crusader GUI has five tabs:\n\n* **Client tab**\n Runs the Crusader client program.\n The options shown above are described in the\n [Command-line options](./docs/CLI.md) page.\n\n* **Server tab**\n Runs the Crusader server, listening for connections from other clients\n\n* **Remote tab**\n Starts a webserver (default port 35482).\n A browser that connects to that port can initiate\n a test to a Crusader server.\n \n* **Monitor tab**\n Continually displays the latency to the selected\n Crusader server until stopped.\n\n* **Result tab**\n Displays the result of the most recent client run\n\n## The Result Tab\n\n![Crusader Results Screenshot](./media/Crusader-Result.png)\n\nA Crusader test creates three bursts of traffic.\nBy default, it generates ten seconds each of\ndownload only, upload only, then bi-directional traffic.\nEach burst is separated by several seconds of idle time.\n\nThe Crusader Result tab displays the results of the test with\nthree plots (see image above):\n\n* The **Throughput** plot shows the bursts of traffic.\nGreen is download (from server to client),\nblue is upload, and\nthe purple line is the instantaneous\nsum of the download plus upload.\n\n* The **Latency** plot shows the corresponding latency.\nGreen shows the (uni-directional) time from the server to the client.\nBlue is the (uni-directional) time from the client to the server.\nBlack shows the sum from the client to the server\nand back (round-trip time).\n\n* The **Packet Loss** plot has green and blue marks\nthat indicate times when packets were lost.\n\nFor more details, see the\n[Understanding Crusader Results](./docs/RESULTS.md) page.\n\n## Documentation\n\n* [This README](./README.md)\n* [Understanding Crusader Results](./docs/RESULTS.md)\n* [Local Testing](./docs/LOCAL_TESTS.md)\n* [Command-line Options](./docs/CLI.md)\n* [Building Crusader from source](./docs/BUILDING.md)\n* [Troubleshooting](./docs/TROUBLESHOOTING.md)\n* [Docker container](https://hub.docker.com/r/zoxc/crusader)\n for the server is available on\n [dockerhub](https://hub.docker.com/r/zoxc/crusader).\n" }, { "path": "android/.gitignore", "content": ".gradle\n/target\n/app/build\n/app/src/main/jniLibs" }, { "path": "android/Cargo.toml", "content": "[package]\nname = \"crusader-android\"\nversion = \"0.1.0\"\nedition = \"2021\"\nresolver = \"2\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\nlog = \"0.4\"\neframe = { version = \"0.28.1\", features = [\"wgpu\"] }\ncrusader-gui-lib = { path = \"../src/crusader-gui-lib\" }\ncrusader-lib = { path = \"../src/crusader-lib\" }\nwinit = \"0.29.15\"\njni = \"0.19.0\"\nndk-context = \"0.1\"\n\n[target.'cfg(target_os = \"android\")'.dependencies]\nandroid_logger = \"0.11.0\"\nandroid-activity = { version = \"0.5\", features = [\"game-activity\"] }\n\n[patch.crates-io]\nwinit = { git = \"https://github.com/Zoxc/winit\", branch = \"crusader2\" }\negui = { git = \"https://github.com/Zoxc/egui\", branch = \"crusader2\" }\nepaint = { git = \"https://github.com/Zoxc/egui\", branch = \"crusader2\" }\nemath = { git = \"https://github.com/Zoxc/egui\", branch = \"crusader2\" }\negui_plot = { git = \"https://github.com/Zoxc/egui_plot\", branch = \"crusader\" }\n\n[lib]\nname = \"main\"\ncrate-type = [\"cdylib\"]\n" }, { "path": "android/app/build.gradle", "content": "plugins {\n id 'com.android.application'\n}\n\nandroid {\n compileSdk 31\n\n defaultConfig {\n applicationId \"zoxc.crusader\"\n minSdk 28\n targetSdk 31\n versionCode 1\n versionName \"1.0\"\n\n testInstrumentationRunner \"androidx.test.runner.AndroidJUnitRunner\"\n }\n\n signingConfigs {\n release {\n storeFile = file(\"../../../android.keystore\")\n storePassword System.getenv(\"SIGNING_STORE_PASSWORD\")\n keyAlias System.getenv(\"SIGNING_KEY_ALIAS\")\n keyPassword System.getenv(\"SIGNING_KEY_PASSWORD\")\n }\n }\n\n buildTypes {\n release {\n minifyEnabled false\n signingConfig signingConfigs.release\n }\n debug {\n minifyEnabled false\n //packagingOptions {\n // doNotStrip '**/*.so'\n //}\n //debuggable true\n }\n }\n compileOptions {\n sourceCompatibility JavaVersion.VERSION_1_8\n targetCompatibility JavaVersion.VERSION_1_8\n }\n}\n\ndependencies {\n implementation 'com.google.android.material:material:1.5.0'\n implementation \"androidx.games:games-activity:2.0.2\"\n\n // To use the Games Controller Library\n //implementation \"androidx.games:games-controller:1.1.0\"\n\n // To use the Games Text Input Library\n //implementation \"androidx.games:games-text-input:1.1.0\"\n}\n" }, { "path": "android/app/src/main/AndroidManifest.xml", "content": "\n\n\n \n\n \n\n \n \n \n \n \n \n\n \n \n \n\n" }, { "path": "android/app/src/main/java/zoxc/crusader/MainActivity.java", "content": "package zoxc.crusader;\n\nimport androidx.appcompat.app.AppCompatActivity;\nimport androidx.core.view.WindowCompat;\nimport androidx.core.view.WindowInsetsCompat;\nimport androidx.core.view.WindowInsetsControllerCompat;\n\nimport com.google.androidgamesdk.GameActivity;\n\nimport android.os.Bundle;\nimport android.content.pm.PackageManager;\nimport android.os.Build.VERSION;\nimport android.os.Build.VERSION_CODES;\nimport android.os.Bundle;\nimport android.view.View;\nimport android.view.WindowManager;\nimport android.util.Log;\nimport android.content.Intent;\nimport android.net.Uri;\nimport android.app.Activity;\nimport android.view.inputmethod.InputMethodManager;\nimport android.provider.OpenableColumns;\nimport android.database.Cursor;\nimport android.content.Context;\n\nimport java.io.ByteArrayOutputStream;\nimport java.io.InputStream;\nimport java.io.OutputStream;\n\npublic class MainActivity extends GameActivity {\n static {\n System.loadLibrary(\"main\");\n }\n\n public void showKeyboard(boolean show) {\n InputMethodManager input = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);\n if (show) {\n input.showSoftInput(getWindow().getDecorView().getRootView(), 0);\n } else {\n input.hideSoftInputFromWindow(getWindow().getDecorView().getRootView().getWindowToken(), 0);\n }\n }\n\n public void loadFile() {\n Intent intent = new Intent(Intent.ACTION_GET_CONTENT);\n intent.addCategory(Intent.CATEGORY_OPENABLE);\n intent.setType(\"*/*\");\n startActivityForResult(intent, ACTIVITY_LOAD_FILE);\n }\n\n public void saveFile(boolean image, String name, byte[] data) {\n Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);\n intent.addCategory(Intent.CATEGORY_OPENABLE);\n if (image) {\n intent.setType(\"image/png\");\n } else {\n intent.setType(\"application/octet-stream\");\n }\n intent.putExtra(Intent.EXTRA_TITLE, name);\n saveFileData = data;\n saveImage = image;\n startActivityForResult(intent, ACTIVITY_CREATE_FILE);\n }\n\n private byte[] saveFileData = null;\n private boolean saveImage;\n\n private static final int ACTIVITY_LOAD_FILE = 1;\n private static final int ACTIVITY_CREATE_FILE = 2;\n\n static native void fileLoaded(String name, byte[] data); \n\n static native void fileSaved(boolean image, String name); \n\n @Override\n public void onActivityResult(int requestCode, int resultCode,\n Intent resultData) {\n super.onActivityResult(requestCode, resultCode, resultData);\n\n if (requestCode == ACTIVITY_CREATE_FILE) {\n if (resultCode == Activity.RESULT_OK && resultData != null) {\n Uri uri = resultData.getData();\n String name = getName(uri);\n try {\n OutputStream stream = getContentResolver().openOutputStream(uri);\n stream.write(saveFileData);\n stream.close();\n fileSaved(saveImage, name);\n }\n catch(Exception e) {}\n }\n saveFileData = null;\n }\n\n if (requestCode == ACTIVITY_LOAD_FILE\n && resultCode == Activity.RESULT_OK\n && resultData != null) {\n Uri uri = resultData.getData();\n String name = getName(uri);\n\n try {\n InputStream stream = getContentResolver().openInputStream(uri);\n ByteArrayOutputStream buffer = new ByteArrayOutputStream();\n int read;\n byte[] byte_buffer = new byte[0x1000];\n while ((read = stream.read(byte_buffer, 0, byte_buffer.length)) != -1) {\n buffer.write(byte_buffer, 0, read);\n }\n stream.close();\n byte[] data = buffer.toByteArray();\n fileLoaded(name, data);\n }\n catch(Exception e) {}\n }\n }\n\n public String getName(Uri uri) {\n Cursor cursor = getContentResolver().query(uri, null, null, null, null, null);\n String name = \"\";\n try {\n if (cursor != null && cursor.moveToFirst()) {\n int column = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);\n if (column != -1) {\n name = cursor.getString(column);\n }\n return name;\n }\n } finally {\n cursor.close();\n }\n return name;\n }\n}" }, { "path": "android/app/src/main/res/values/colors.xml", "content": "\n\n #FFBB86FC\n #FF6200EE\n #FF3700B3\n #FF03DAC5\n #FF018786\n #FF000000\n #FFFFFFFF\n #FFE6E6E6\n" }, { "path": "android/app/src/main/res/values/themes.xml", "content": "\n \n \n" }, { "path": "android/build.gradle", "content": "// Top-level build file where you can add configuration options common to all sub-projects/modules.\nplugins {\n id 'com.android.application' version '7.1.2' apply false\n id 'com.android.library' version '7.1.2' apply false\n}\n\ntask clean(type: Delete) {\n delete rootProject.buildDir\n}\n" }, { "path": "android/debugInstall.ps1", "content": "$ErrorActionPreference = \"Stop\"\ncargo ndk -t arm64-v8a -o app/src/main/jniLibs/ -- build --release\nif ($lastexitcode -ne 0) {\n throw \"Error\"\n}\n\n./gradlew.bat buildDebug\nif ($lastexitcode -ne 0) {\n throw \"Error\"\n}\n\n./gradlew.bat installDebug\nif ($lastexitcode -ne 0) {\n throw \"Error\"\n}\n" }, { "path": "android/gradle/wrapper/gradle-wrapper.properties", "content": "#Mon May 02 15:39:12 BST 2022\ndistributionBase=GRADLE_USER_HOME\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-7.5-bin.zip\ndistributionPath=wrapper/dists\nzipStorePath=wrapper/dists\nzipStoreBase=GRADLE_USER_HOME\n" }, { "path": "android/gradle.properties", "content": "# Project-wide Gradle settings.\n# IDE (e.g. Android Studio) users:\n# Gradle settings configured through the IDE *will override*\n# any settings specified in this file.\n# For more details on how to configure your build environment visit\n# http://www.gradle.org/docs/current/userguide/build_environment.html\n# Specifies the JVM arguments used for the daemon process.\n# The setting is particularly useful for tweaking memory settings.\norg.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8\n# When configured, Gradle will run in incubating parallel mode.\n# This option should only be used with decoupled projects. More details, visit\n# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects\n# org.gradle.parallel=true\n# AndroidX package structure to make it clearer which packages are bundled with the\n# Android operating system, and which are packaged with your app\"s APK\n# https://developer.android.com/topic/libraries/support-library/androidx-rn\nandroid.useAndroidX=true\n# Enables namespacing of each library's R class so that its R class includes only the\n# resources declared in the library itself and none from the library's dependencies,\n# thereby reducing the size of the R class for that library\nandroid.nonTransitiveRClass=true" }, { "path": "android/gradlew", "content": "#!/usr/bin/env sh\n\n#\n# Copyright 2015 the original author or authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\n##############################################################################\n##\n## Gradle start up script for UN*X\n##\n##############################################################################\n\n# Attempt to set APP_HOME\n# Resolve links: $0 may be a link\nPRG=\"$0\"\n# Need this for relative symlinks.\nwhile [ -h \"$PRG\" ] ; do\n ls=`ls -ld \"$PRG\"`\n link=`expr \"$ls\" : '.*-> \\(.*\\)$'`\n if expr \"$link\" : '/.*' > /dev/null; then\n PRG=\"$link\"\n else\n PRG=`dirname \"$PRG\"`\"/$link\"\n fi\ndone\nSAVED=\"`pwd`\"\ncd \"`dirname \\\"$PRG\\\"`/\" >/dev/null\nAPP_HOME=\"`pwd -P`\"\ncd \"$SAVED\" >/dev/null\n\nAPP_NAME=\"Gradle\"\nAPP_BASE_NAME=`basename \"$0\"`\n\n# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nDEFAULT_JVM_OPTS='\"-Xmx64m\" \"-Xms64m\"'\n\n# Use the maximum available, or set MAX_FD != -1 to use that value.\nMAX_FD=\"maximum\"\n\nwarn () {\n echo \"$*\"\n}\n\ndie () {\n echo\n echo \"$*\"\n echo\n exit 1\n}\n\n# OS specific support (must be 'true' or 'false').\ncygwin=false\nmsys=false\ndarwin=false\nnonstop=false\ncase \"`uname`\" in\n CYGWIN* )\n cygwin=true\n ;;\n Darwin* )\n darwin=true\n ;;\n MINGW* )\n msys=true\n ;;\n NONSTOP* )\n nonstop=true\n ;;\nesac\n\nCLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar\n\n\n# Determine the Java command to use to start the JVM.\nif [ -n \"$JAVA_HOME\" ] ; then\n if [ -x \"$JAVA_HOME/jre/sh/java\" ] ; then\n # IBM's JDK on AIX uses strange locations for the executables\n JAVACMD=\"$JAVA_HOME/jre/sh/java\"\n else\n JAVACMD=\"$JAVA_HOME/bin/java\"\n fi\n if [ ! -x \"$JAVACMD\" ] ; then\n die \"ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\n fi\nelse\n JAVACMD=\"java\"\n which java >/dev/null 2>&1 || die \"ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\nfi\n\n# Increase the maximum file descriptors if we can.\nif [ \"$cygwin\" = \"false\" -a \"$darwin\" = \"false\" -a \"$nonstop\" = \"false\" ] ; then\n MAX_FD_LIMIT=`ulimit -H -n`\n if [ $? -eq 0 ] ; then\n if [ \"$MAX_FD\" = \"maximum\" -o \"$MAX_FD\" = \"max\" ] ; then\n MAX_FD=\"$MAX_FD_LIMIT\"\n fi\n ulimit -n $MAX_FD\n if [ $? -ne 0 ] ; then\n warn \"Could not set maximum file descriptor limit: $MAX_FD\"\n fi\n else\n warn \"Could not query maximum file descriptor limit: $MAX_FD_LIMIT\"\n fi\nfi\n\n# For Darwin, add options to specify how the application appears in the dock\nif $darwin; then\n GRADLE_OPTS=\"$GRADLE_OPTS \\\"-Xdock:name=$APP_NAME\\\" \\\"-Xdock:icon=$APP_HOME/media/gradle.icns\\\"\"\nfi\n\n# For Cygwin or MSYS, switch paths to Windows format before running java\nif [ \"$cygwin\" = \"true\" -o \"$msys\" = \"true\" ] ; then\n APP_HOME=`cygpath --path --mixed \"$APP_HOME\"`\n CLASSPATH=`cygpath --path --mixed \"$CLASSPATH\"`\n\n JAVACMD=`cygpath --unix \"$JAVACMD\"`\n\n # We build the pattern for arguments to be converted via cygpath\n ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`\n SEP=\"\"\n for dir in $ROOTDIRSRAW ; do\n ROOTDIRS=\"$ROOTDIRS$SEP$dir\"\n SEP=\"|\"\n done\n OURCYGPATTERN=\"(^($ROOTDIRS))\"\n # Add a user-defined pattern to the cygpath arguments\n if [ \"$GRADLE_CYGPATTERN\" != \"\" ] ; then\n OURCYGPATTERN=\"$OURCYGPATTERN|($GRADLE_CYGPATTERN)\"\n fi\n # Now convert the arguments - kludge to limit ourselves to /bin/sh\n i=0\n for arg in \"$@\" ; do\n CHECK=`echo \"$arg\"|egrep -c \"$OURCYGPATTERN\" -`\n CHECK2=`echo \"$arg\"|egrep -c \"^-\"` ### Determine if an option\n\n if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition\n eval `echo args$i`=`cygpath --path --ignore --mixed \"$arg\"`\n else\n eval `echo args$i`=\"\\\"$arg\\\"\"\n fi\n i=`expr $i + 1`\n done\n case $i in\n 0) set -- ;;\n 1) set -- \"$args0\" ;;\n 2) set -- \"$args0\" \"$args1\" ;;\n 3) set -- \"$args0\" \"$args1\" \"$args2\" ;;\n 4) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" ;;\n 5) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" ;;\n 6) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" ;;\n 7) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" ;;\n 8) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" ;;\n 9) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" \"$args8\" ;;\n esac\nfi\n\n# Escape application args\nsave () {\n for i do printf %s\\\\n \"$i\" | sed \"s/'/'\\\\\\\\''/g;1s/^/'/;\\$s/\\$/' \\\\\\\\/\" ; done\n echo \" \"\n}\nAPP_ARGS=`save \"$@\"`\n\n# Collect all arguments for the java command, following the shell quoting and substitution rules\neval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS \"\\\"-Dorg.gradle.appname=$APP_BASE_NAME\\\"\" -classpath \"\\\"$CLASSPATH\\\"\" org.gradle.wrapper.GradleWrapperMain \"$APP_ARGS\"\n\nexec \"$JAVACMD\" \"$@\"\n" }, { "path": "android/gradlew.bat", "content": "@rem\n@rem Copyright 2015 the original author or authors.\n@rem\n@rem Licensed under the Apache License, Version 2.0 (the \"License\");\n@rem you may not use this file except in compliance with the License.\n@rem You may obtain a copy of the License at\n@rem\n@rem https://www.apache.org/licenses/LICENSE-2.0\n@rem\n@rem Unless required by applicable law or agreed to in writing, software\n@rem distributed under the License is distributed on an \"AS IS\" BASIS,\n@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n@rem See the License for the specific language governing permissions and\n@rem limitations under the License.\n@rem\n\n@if \"%DEBUG%\" == \"\" @echo off\n@rem ##########################################################################\n@rem\n@rem Gradle startup script for Windows\n@rem\n@rem ##########################################################################\n\n@rem Set local scope for the variables with windows NT shell\nif \"%OS%\"==\"Windows_NT\" setlocal\n\nset DIRNAME=%~dp0\nif \"%DIRNAME%\" == \"\" set DIRNAME=.\nset APP_BASE_NAME=%~n0\nset APP_HOME=%DIRNAME%\n\n@rem Resolve any \".\" and \"..\" in APP_HOME to make it shorter.\nfor %%i in (\"%APP_HOME%\") do set APP_HOME=%%~fi\n\n@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nset DEFAULT_JVM_OPTS=\"-Xmx64m\" \"-Xms64m\"\n\n@rem Find java.exe\nif defined JAVA_HOME goto findJavaFromJavaHome\n\nset JAVA_EXE=java.exe\n%JAVA_EXE% -version >NUL 2>&1\nif \"%ERRORLEVEL%\" == \"0\" goto execute\n\necho.\necho ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\necho.\necho Please set the JAVA_HOME variable in your environment to match the\necho location of your Java installation.\n\ngoto fail\n\n:findJavaFromJavaHome\nset JAVA_HOME=%JAVA_HOME:\"=%\nset JAVA_EXE=%JAVA_HOME%/bin/java.exe\n\nif exist \"%JAVA_EXE%\" goto execute\n\necho.\necho ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%\necho.\necho Please set the JAVA_HOME variable in your environment to match the\necho location of your Java installation.\n\ngoto fail\n\n:execute\n@rem Setup the command line\n\nset CLASSPATH=%APP_HOME%\\gradle\\wrapper\\gradle-wrapper.jar\n\n\n@rem Execute Gradle\n\"%JAVA_EXE%\" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% \"-Dorg.gradle.appname=%APP_BASE_NAME%\" -classpath \"%CLASSPATH%\" org.gradle.wrapper.GradleWrapperMain %*\n\n:end\n@rem End local scope for the variables with windows NT shell\nif \"%ERRORLEVEL%\"==\"0\" goto mainEnd\n\n:fail\nrem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of\nrem the _cmd.exe /c_ return code!\nif not \"\" == \"%GRADLE_EXIT_CONSOLE%\" exit 1\nexit /b 1\n\n:mainEnd\nif \"%OS%\"==\"Windows_NT\" endlocal\n\n:omega\n" }, { "path": "android/settings.gradle", "content": "pluginManagement {\n repositories {\n gradlePluginPortal()\n google()\n mavenCentral()\n }\n}\ndependencyResolutionManagement {\n repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)\n repositories {\n google()\n mavenCentral()\n }\n}\n\ninclude ':app'\n" }, { "path": "android/src/lib.rs", "content": "#![allow(\n clippy::field_reassign_with_default,\n clippy::option_map_unit_fn,\n clippy::missing_safety_doc\n)]\n\nuse crusader_gui_lib::Tester;\nuse crusader_lib::file_format::RawResult;\nuse eframe::egui::{self, vec2, Align, FontFamily, Layout};\nuse jni::{\n objects::{JClass, JObject, JString},\n sys::{jboolean, jbyteArray},\n JNIEnv,\n};\nuse std::{\n error::Error,\n io::Cursor,\n path::Path,\n sync::{Arc, Mutex},\n};\n\n#[cfg(target_os = \"android\")]\nuse {\n android_activity::AndroidApp,\n crusader_lib::test::PlotConfig,\n eframe::{NativeOptions, Renderer, Theme},\n log::Level,\n std::fs,\n winit::platform::android::EventLoopBuilderExtAndroid,\n};\n\nstruct App {\n tester: Tester,\n keyboard_shown: bool,\n}\n\nimpl eframe::App for App {\n fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {\n use eframe::egui::FontFamily::Proportional;\n use eframe::egui::FontId;\n use eframe::egui::TextStyle::*;\n\n let mut style = ctx.style();\n let style_ = Arc::make_mut(&mut style);\n style_.spacing.button_padding = vec2(10.0, 0.0);\n style_.spacing.interact_size.y = 40.0;\n style_.spacing.item_spacing = vec2(10.0, 10.0);\n\n style_.text_styles = [\n (Heading, FontId::new(26.0, Proportional)),\n (Body, FontId::new(16.0, Proportional)),\n (Monospace, FontId::new(16.0, FontFamily::Monospace)),\n (Button, FontId::new(16.0, Proportional)),\n (Small, FontId::new(16.0, Proportional)),\n ]\n .into();\n\n ctx.set_style(style);\n\n egui::CentralPanel::default().show(ctx, |ui| {\n let mut rect = ui.max_rect();\n rect.set_top(rect.top() + 40.0);\n rect.set_height(rect.height() - 60.0);\n let mut ui = ui.child_ui(rect, Layout::left_to_right(Align::Center), None);\n ui.vertical(|ui| {\n ui.heading(\"Crusader Network Benchmark\");\n ui.separator();\n\n SAVED_FILE.lock().unwrap().take().map(|(image, name)| {\n if !image {\n self.tester.save_raw(Path::new(&name).to_owned());\n }\n });\n\n LOADED_FILE.lock().unwrap().take().map(|(name, data)| {\n RawResult::load_from_reader(Cursor::new(data))\n .map(|data| self.tester.load_file(Path::new(&name).to_owned(), data));\n });\n\n self.tester.show(ctx, ui);\n });\n });\n\n if ctx.wants_keyboard_input() != self.keyboard_shown {\n show_keyboard(ctx.wants_keyboard_input()).unwrap();\n self.keyboard_shown = ctx.wants_keyboard_input();\n }\n }\n}\n\nfn show_keyboard(show: bool) -> Result<(), Box> {\n let context = ndk_context::android_context();\n\n let vm = unsafe { jni::JavaVM::from_raw(context.vm().cast())? };\n\n let activity: JObject = (context.context() as jni::sys::jobject).into();\n\n let env = vm.attach_current_thread()?;\n\n env.call_method(activity, \"showKeyboard\", \"(Z)V\", &[show.into()])?\n .v()?;\n Ok(())\n}\n\nfn save_file(image: bool, name: String, data: Vec) -> Result<(), Box> {\n let context = ndk_context::android_context();\n let vm = unsafe { jni::JavaVM::from_raw(context.vm().cast())? };\n let activity: JObject = (context.context() as jni::sys::jobject).into();\n let env = vm.attach_current_thread()?;\n env.call_method(\n activity,\n \"saveFile\",\n \"(ZLjava/lang/String;[B)V\",\n &[\n image.into(),\n env.new_string(name).unwrap().into(),\n env.byte_array_from_slice(&data).unwrap().into(),\n ],\n )?\n .v()?;\n Ok(())\n}\n\nstatic SAVED_FILE: Mutex> = Mutex::new(None);\n\n#[no_mangle]\npub unsafe extern \"C\" fn Java_zoxc_crusader_MainActivity_fileSaved(\n env: JNIEnv,\n _: JClass,\n image: jboolean,\n name: JString,\n) {\n let name: String = env.get_string(name).unwrap().into();\n *SAVED_FILE.lock().unwrap() = Some((image != 0, name));\n}\n\nfn load_file() -> Result<(), Box> {\n let context = ndk_context::android_context();\n let vm = unsafe { jni::JavaVM::from_raw(context.vm().cast())? };\n let activity: JObject = (context.context() as jni::sys::jobject).into();\n let env = vm.attach_current_thread()?;\n env.call_method(activity, \"loadFile\", \"()V\", &[])?.v()?;\n Ok(())\n}\n\nstatic LOADED_FILE: Mutex)>> = Mutex::new(None);\n\n#[no_mangle]\npub unsafe extern \"C\" fn Java_zoxc_crusader_MainActivity_fileLoaded(\n env: JNIEnv,\n _: JClass,\n name: JString,\n data: jbyteArray,\n) {\n let name: String = env.get_string(name).unwrap().into();\n let data = env.convert_byte_array(data).unwrap();\n *LOADED_FILE.lock().unwrap() = Some((name, data));\n}\n\n#[cfg(target_os = \"android\")]\n#[no_mangle]\nfn android_main(app: AndroidApp) {\n android_logger::init_once(android_logger::Config::default().with_min_level(Level::Trace));\n\n crusader_lib::plot::register_fonts();\n\n let settings = app\n .internal_data_path()\n .map(|path| path.join(\"settings.toml\"));\n\n let temp_plot = app.internal_data_path().map(|path| path.join(\"plot.png\"));\n\n let mut options = NativeOptions::default();\n options.follow_system_theme = false;\n options.default_theme = Theme::Light;\n options.renderer = Renderer::Wgpu;\n options.event_loop_builder = Some(Box::new(move |builder| {\n builder.with_android_app(app.clone());\n }));\n let mut tester = Tester::new(settings);\n tester.file_loader = Some(Box::new(|_| load_file().unwrap()));\n tester.plot_saver = Some(Box::new(move |result| {\n let path = temp_plot.as_deref().unwrap();\n crusader_lib::plot::save_graph_to_path(path, &PlotConfig::default(), result).unwrap();\n let data = fs::read(path).unwrap();\n fs::remove_file(path).unwrap();\n let name = format!(\"{}.png\", crusader_lib::test::timed(\"plot\"));\n save_file(true, name, data).unwrap();\n }));\n tester.raw_saver = Some(Box::new(|result| {\n let mut writer = Cursor::new(Vec::new());\n result.save_to_writer(&mut writer).unwrap();\n let data = writer.into_inner();\n let name = format!(\"{}.crr\", crusader_lib::test::timed(\"data\"));\n save_file(false, name, data).unwrap();\n }));\n eframe::run_native(\n \"Crusader Network Tester\",\n options,\n Box::new(|_cc| {\n Ok(Box::new(App {\n tester,\n keyboard_shown: false,\n }))\n }),\n )\n .unwrap();\n}\n" }, { "path": "docker/README.md", "content": "To build a statically linked server image:\r\n```\r\ndocker build .. -t crusader -f server-static.Dockerfile\r\n```\r\n\r\nTo build a statically linked remote image:\r\n```\r\ndocker build .. -t crusader -f remote-static.Dockerfile\r\n```\r\nThis image allow initiation of tests using the web application running on port 35482.\r\n\r\nSupported platforms:\r\n- `linux/i386`\r\n- `linux/x86_64`\r\n- `linux/arm/v7`\r\n- `linux/arm64`\r\n\r\nAvailable profiles:\r\n - `--build-arg PROFILE=release` (default)\r\n - `--build-arg PROFILE=speed`\r\n - `--build-arg PROFILE=size`" }, { "path": "docker/remote-static.Dockerfile", "content": "FROM rust AS build\r\nARG TARGETARCH\r\nARG PROFILE=release\r\n\r\nCOPY src /src\r\nWORKDIR /src\r\n\r\nRUN echo no-target-detected > /target\r\n\r\nRUN if [ \"$TARGETARCH\" = \"386\" ]; then\\\r\n echo i686-unknown-linux-musl > /target; fi\r\nRUN if [ \"$TARGETARCH\" = \"amd64\" ]; then\\\r\n echo x86_64-unknown-linux-musl > /target; fi\r\nRUN if [ \"$TARGETARCH\" = \"arm\" ]; then\\\r\n echo arm-unknown-linux-musleabihf > /target; fi\r\nRUN if [ \"$TARGETARCH\" = \"arm64\" ]; then\\\r\n echo aarch64-unknown-linux-musl > /target; fi\r\n\r\nENV RUSTFLAGS=\"-C target-feature=+crt-static\"\r\n\r\nRUN rustup target add $(cat /target)\r\n\r\nRUN cargo build -p crusader --profile=$PROFILE --target $(cat /target)\r\n\r\nRUN cp target/$(cat /target)/$PROFILE/crusader /\r\n\r\nFROM scratch\r\nCOPY --from=build /crusader /\r\n\r\nEXPOSE 35482/tcp\r\nENTRYPOINT [ \"/crusader\", \"remote\" ]\r\n" }, { "path": "docker/server-static.Dockerfile", "content": "FROM rust AS build\r\nARG TARGETARCH\r\nARG PROFILE=release\r\n\r\nCOPY src /src\r\nWORKDIR /src\r\n\r\nRUN echo no-target-detected > /target\r\n\r\nRUN if [ \"$TARGETARCH\" = \"386\" ]; then\\\r\n echo i686-unknown-linux-musl > /target; fi\r\nRUN if [ \"$TARGETARCH\" = \"amd64\" ]; then\\\r\n echo x86_64-unknown-linux-musl > /target; fi\r\nRUN if [ \"$TARGETARCH\" = \"arm\" ]; then\\\r\n echo arm-unknown-linux-musleabihf > /target; fi\r\nRUN if [ \"$TARGETARCH\" = \"arm64\" ]; then\\\r\n echo aarch64-unknown-linux-musl > /target; fi\r\n\r\nENV RUSTFLAGS=\"-C target-feature=+crt-static\"\r\n\r\nRUN rustup target add $(cat /target)\r\n\r\nRUN cargo build -p crusader --no-default-features --profile=$PROFILE --target $(cat /target)\r\n\r\nRUN cp target/$(cat /target)/$PROFILE/crusader /\r\n\r\nFROM scratch\r\nCOPY --from=build /crusader /\r\n\r\nEXPOSE 35481/tcp 35481/udp 35483/udp\r\nENTRYPOINT [ \"/crusader\", \"serve\" ]\r\n" }, { "path": "docs/BUILDING.md", "content": "# Building Crusader from source\n\nReminder: [Pre-built binaries](https://github.com/Zoxc/crusader/releases)\nare available for everyday tests.\n\n## Required dependencies\n\n* A Rust and C toolchain.\n* `fontconfig` (optional, required for `crusader-gui`)\n\n_Note:_ To install `fontconfig` on Ubuntu:\n\n```sh\nsudo apt install libfontconfig1-dev\n```\n\n## Building Crusader\n\nTo develop or debug Crusader, use the commands below\nto build the full set of binaries.\nExecutables are placed in _src/target/release_\n\nTo build the `crusader` command line executable:\n\n```sh\ncd src\ncargo build -p crusader --release\n```\n\nTo build both command line and GUI executables:\n\n```sh\ncd src\ncargo build --release\n```\n\n## Debug build\n\nCreate a debug build by using `cargo build`\n(instead of `cargo build --release`).\nBinaries are saved in the _src/target/debug_ directory\n\n## Docker\n\nTo build a docker container that runs the server:\n\n```sh\ncd docker\ndocker build .. -t crusader -f server-static.Dockerfile\n```\n" }, { "path": "docs/CLI.md", "content": "# Running Crusader from the command line\n\n## Server\n\nTo host a Crusader server, run this on the _server_ machine:\n\n```sh\ncrusader serve\n```\n\n## Client\n\nTo start a test, run this on the _client machine_.\nSee the [command-line options](#options-for-the-test-command) below for details.\n\n```sh\ncrusader test \n```\n\n## Remote\n\nTo host a web server that provides remote control of a Crusader client,\nrun the command below, then connect to\n`http://ip-of-the-crusader-device:35482`\n\n```sh\ncrusader remote\n```\n\n## Plot\n\nCrusader creates a `.png` file from a `.crr` file using `crusader plot path-to-crr-file`\nThe resulting `.png` is saved in the same directory as the input file.\n\n## Export\n\nCrusader exports raw data samples from a `.crr` file\ninto a `.json` file using `crusader export path-to-crr-file`\nThe resulting `.json` is saved in the same directory as the input file.\n\n## Options for the `test` command\n\n**Usage: `crusader test [OPTIONS] `**\n\n**Arguments:** `` address of a Crusader server\n\n**Options:**\n\n* **`--download`**\n Run a download test\n* **`--upload`**\n Run an upload test\n* **`--bidirectional`**\n Run a test doing both download and upload\n* **`--idle`**\n Run a test, only measuring latency without inducing traffic.\n The duration is specified by `grace_duration`\n* **`--port `**\n Specify the TCP and UDP port used by the server\n [default: 35481]\n* **`--streams `**\n The number of TCP connections used to generate\n traffic in a single direction\n [default: 8]\n* **`--stream-stagger `**\n The delay between the start of each stream\n [default: 0.0]\n* **`--load-duration `**\n The duration in which traffic is generated\n [default: 10.0]\n* **`--grace-duration `**\n The idle time between each test\n [default: 2.0]\n* **`--latency-sample-interval `**\n [default: 5.0]\n* **`--throughput-sample-interval `**\n [default: 60.0]\n* **`--plot-transferred`**\n Plot transferred bytes\n* **`--plot-split-throughput`**\n Plot upload and download separately and plot streams\n* **`--plot-max-throughput `**\n Set the axis for throughput to at least this value.\n SI units are supported so `100M` would specify 100 Mbps\n* **`--plot-max-latency `**\n Set the axis for latency to at least this value\n* **`--plot-width `**\n* **`--plot-height `**\n* **`--plot-title `**\n* **`--latency-peer-address `**\n Address of another Crusader server (the \"peer\") which\n concurrently measures the latency to the server and reports\n the values to the client\n* **`--latency-peer`**\n Trigger the client to instruct a peer (another Crusader server)\n to begin measuring the latency to the main server\n and report the latency back\n* **`--out-name `**\n The filename prefix used for the raw data and plot filenames\n* **`-h, --help`**\n Print help (see a summary with '-h')\n" }, { "path": "docs/LOCAL_TESTS.md", "content": "# Local network testing with Crusader\n\n**Background:**\nThe Crusader Network Tester measures network throughput\nand latency in the presence of upload and download traffic\nand produces plots of the traffic rates, latency and packet loss.\n\n## Making local tests - Wifi or Wired\n\nTo test the equipment between two points on your network,\nCrusader requires two computers,\none acting as a server, the other as a client.\n\nThe Crusader program can act as both client and server.\nInstall the latest pre-built binary of\n[Crusader](https://github.com/Zoxc/crusader/releases)\non two separate computers. Then:\n\n1. Connect one of those computers to your router's LAN port using an\n Ethernet cable.\n Start the Crusader program on it, then click the **Server** tab. See the\n [screen shot](../media/Crusader-Server.png).\n Click **Start server** and look for the\n address(es) where the Crusader Server is listening.\n (Note: The Crusader binary can also run on a small\n computer such as a Raspberry Pi.\n A Pi4 acting as a server can easily support 1Gbps speeds.)\n2. Connect the other computer either by Ethernet, Wi-fi,\n or some other adapter.\n Run the Crusader program and click the Client tab. See the\n [screen shot](../media/Crusader-Client.png).\n Enter the address of a Crusader Server into the GUI,\n and click **Start test**\n3. When the test completes, you'll see charts of three bursts of traffic:\n Download, Upload, and Bidirectional,\n along with the latency during that activity.\n See the\n [Crusader README](../README.md) and\n [Understanding Crusader Results](./RESULTS.md)\n for details.\n\n**Note:** If both the computers (client and server) are on the LAN\n side of the router (whether they are on Wi-Fi or Ethernet),\n the results will reflect the _switching_ capability, not the\n _routing_ capability of the router.\n To test the routing capability, test against a server that's\n on the WAN side of the router or the broader Internet.\n\n**Note:** The Crusader program has both a GUI and a command-line binary.\nBoth act as a client or a server.\nThese instructions tell how to run the client on a laptop.\nYou may find it convenient to run the server on a remote computer.\nGet both binaries from the\n[Releases page](https://github.com/Zoxc/crusader/releases).\n\n## What can we learn?\n\nYour local router, Wi-fi, and other network equipment\nall affect your total performance.\nEven with very high speed internet service,\nif the router is max'ed out it can hold back your throughput.\nAnd you're stuck with whatever latency the router and\nother local equipment create - it's added to any latency from your ISP network.\nIn particular:\n\n* Ethernet-to-Ethernet connections tend to be good:\n high throughput with low latency.\n But you should always check your network.\n On a 1Gbps network, typical results are above 950 Mbps,\n and less than a dozen milliseconds of latency.\n* Wi-fi has a reputation for \"being slow\".\n This often is a result of the Wi-fi drivers injecting\n hundreds of milliseconds of latency.\n In addition, wireless connections will always have lower\n throughput than wired connections.\n* Many powerline adapters (that provide an Ethernet connection\n between two AC outlets) may have high specifications,\n but in practice are known to give limited throughput\n and have high latency.\n\nRunning a Crusader test between computers on the local network measures\nthe performance of that portion of the network.\n\n## Why is this important?\n\nThese test results - the actual throughput or latency numbers -\nare not very important.\nIf you are satisfied with you network's performance,\nthen these numerical results don't matter.\n\nBut if you are experiencing problems,\nthese tests help divide the troubleshooting problem in two.\n\n* If the local network is running fine,\n performance problems must be elsewhere \n (in your ISP or their upstream service,\n which likely is out of your control).\n* But if the local performance is not what you expected,\n you can start investigating your router, switch, etc.\n" }, { "path": "docs/RESULTS.md", "content": "# Understanding Crusader Results\n\nThe Crusader GUI provides a compact summary of the test data.\nHere are some hints for evaluating the results.\n\n## Result window\n\n![Result with statistics](../media/Crusader-Result-with-stats.png)\n\nCrusader tests the connection using three bursts of traffic.\nThe Throughput, Latency, and Packet loss are shown in the charts.\nIn the image above notice:\n\n* **Hovering over a chart** shows crosshairs that give the throughput\n or latency of that point in the chart.\n In the screen shot above, the Down latency\n peaks around 250 ms.\n* **Hovering over, or clicking the ⓘ symbol** opens a window that displays\n a summary of the measurements.\n See the description below for details.\n* **Clicking a legend** (\"color\") in the charts shows/hides\n the associated graph.\n In the screen shot above, the Latency's \"Round-trip\" legend has been clicked,\n hiding the (black) round-trip trace,\n and showing only the Up and Down latency plots.\n* The **Save to results** button saves two files: a plot (as `.png`)\n and the data (as `.crr`) to the _crusader-results_ directory\n in the _current directory_.\n* The **Open from results** button opens a `.crr` file\n from the _crusader-results_ directory.\n* The **Save** button opens a file dialog to save the current `.crr` file.\n* The **Open** button opens a file dialog to select a `.crr` file to open.\n* The **Export plot** button opens a file dialog to save a `.png` file.\n\n## Numerical Summary Windows\n\nThe Crusader GUI displays charts showing Throughput, Latency,\nand Packet loss.\nThe ⓘ symbol opens a window showing a numerical summary of the charted data.\n\n### Throughput\n\n\"description\"\n\n* Download - Steady state throughput, ignoring any startup transients,\n during the Download portion of the test\n* Upload - Steady state throughput, ignoring any startup transients,\n during the Upload portion of the test\n* Bidirectional - Sum of the Download and Upload throughputs\n during the Bidirectional portion of the test.\n Also displays the individual Download and Upload throughputs.\n* Streams - number of TCP connections used in each direction\n* Stream Stagger - The delay between the start of each stream\n* Throughput sample interval - Interval between throughput measurements\n\n### Latency\n\n\"description\"\n\nCrusader smooths all the latency samples over a 400 ms window.\nThe values shown in the window display the maximum of those smoothed values.\nThis emphasizes sustained peaks of latency.\n\n* Download - Summarizes the round-trip latency during the\n Download portion of the test.\n Also displays the measured one-way delay for Download (from server to client)\n and Upload (client to server)\n* Upload - Summarizes the latency for the Upload portion of the test\n* Bidirectional - Summarizes the latency for the Bidirectional portion of the test\n* Idle latency - Measured latency when no traffic is present.\n* Latency sample interval - Interval between latency measurements\n\n### Packet loss\n\n\"description\"\n\nWhen it measures packet loss, Crusader is using the UDP packets\nthat it also uses for latency measurements.\n\n* Download - Summarizes packet loss during the Download portion of the test\n* Upload - Summarizes packet loss during the Upload portion of the test\n* Bidirectional - Summarizes packet loss during the Bidirectional\n portion of the test\n" }, { "path": "docs/TROUBLESHOOTING.md", "content": "# Troubleshooting\n\n* Crusader requires that TCP and UDP ports 35481 are open for its tests.\n Crusader also uses ports 35482 for the remote webserver\n and port 35483 for discovering other Crusader servers.\n Check that your firewall is letting those ports through.\n\n* On macOS, the first time you double-click\n the pre-built `crusader` or `crusader-gui` icon,\n the OS refuses to let it run.\n You must use **System Preferences -> Privacy & Security**\n to approve Crusader to run.\n\n* The message\n `Warning: Load termination timed out. There may be residual untracked traffic in the background.`\n is not necessarily harmful.\n It may happen due to the TCP termination being lost\n or TCP incompatibilities between OSes.\n It's likely benign if you see throughput and latency drop\n to idle values after the tests in the graph.\n\n* The up and down latency measurements rely on symmetric stable latency\n measurements to the server.\n These values may be wrong if those assumption don't hold on test startup." }, { "path": "media/Crusader Screen Shots.md", "content": "# Verify Crusader Screen Shots\n\nThis page is useful for checking the appearance of screen shots.\nCapture the screen shots (Cmd-Shift-5 on macOS) and save with filenames\nlike \"Client.png\", \"Server.png\", etc., one for each of the tabs.\n\nRun the `batch_add_border.sh` script - it finds all these files,\nremoves the drop shadow and adds \"Crusader-\" to each result file.\n\nRemove the original files before committing to git.\n\n## Client\n\n![Options](./Crusader-Client.png)\n\n## Server\n\n![Server](./Crusader-Server.png)\n\n## Remote\n\n![Remote](./Crusader-Remote.png)\n\n## Monitor\n\n![Monitor](./Crusader-Monitor.png)\n\n## Result\n\n![Result](./Crusader-Result.png)\n\n## Result with stats\n\n![Options](./Crusader-Result-with-stats.png)\n\n## Throughput popup\n\n![Throughput](./Crusader-Throughput.png)\n\"description\"\n\n## Latency popup\n\n![Latency](./Crusader-Latency.png)\n\"description\"\n\n## Packet loss popup\n\n![Packet Loss](./Crusader-Loss.png)\n\"description\"\n" }, { "path": "media/batch_add_border.sh", "content": "#!/bin/bash\n\n# add_border.sh - This script uses ImageMagick to process\n# macOS screen shots for publication\n\n# Usage: \n# 1. Take screen shots (Cmd-Shift-5) on macOS\n# 2. Save the file with a name that would be a good suffix (e.g. Remote.png)\n# 3. Run this script. The script outputs modified files prefixed with \"Crusader-\"\n# 4. Discard the original files\n\n# The script does the following - for the .png files in the directory:\n# - find all .png files that don't begin with \"Crusader\"\n# - remove the transparent area/drop shadow from a macOS screen shot\n# - shrink the image to the size of the image\n# - draw a grey border 1 px wide around the window.\n# - save the resulting file as \"Crusader-....png\"\n# Thanks, ChatGPT\n\n# Get the directory where the script is located\nscript_dir=\"$(dirname \"$0\")\"\n\n# Define the border size (1 pixel) and colors\nborder_size=1\nborder_color=\"gray\"\nbackground_color=\"white\"\n\n# Loop through all .png files \nfor input_file in \"$script_dir\"/[a-zA-Z]*.png; do\n # Check if the file actually exists (in case no files match)\n if [ ! -f \"$input_file\" ]; then\n continue\n fi\n\n # Ignore files that already start with \"Crusader\"\n if [[ $(basename \"$input_file\") == Crusader* ]]; then\n echo \"Skipping: $input_file\"\n continue\n fi\n\n # Output file name (prepend \"Crusader-\" to the original file name)\n output_file=\"$script_dir/Crusader-$(basename \"$input_file\")\"\n\n # Process the image:\n # 1. Remove the alpha channel (transparency) by filling with white\n # 2. Trim the image to its non-transparent content\n # 3. Add a 1-pixel grey border\n magick \"$input_file\" \\\n -alpha off \\\n -trim \\\n -bordercolor $border_color \\\n -border ${border_size}x${border_size} \\\n \"$output_file\"\n\n echo \"Processed: $input_file -> $output_file\"\ndone\n\necho \"All matching .png files processed.\"\n" }, { "path": "src/Cargo.toml", "content": "[workspace]\r\nmembers = [\"crusader\", \"crusader-lib\", \"crusader-gui-lib\", \"crusader-gui\"]\r\nresolver = \"1\"\r\n\r\n[profile.dev]\r\npanic = \"abort\"\r\n\r\n[profile.release]\r\npanic = \"abort\"\r\nstrip = \"symbols\"\r\n\r\n[profile.speed]\r\nopt-level = 3\r\ncodegen-units = 1\r\ninherits = \"release\"\r\nlto = \"fat\"\r\n\r\n[profile.size]\r\ninherits = \"speed\"\r\nopt-level = \"z\"\r\n\r\n[patch.crates-io]\r\negui_plot = { git = \"https://github.com/Zoxc/egui_plot\", branch = \"crusader\" }\r\n" }, { "path": "src/crusader/Cargo.toml", "content": "[package]\nname = \"crusader\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\ncrusader-lib = { path = \"../crusader-lib\" }\nclap = { version = \"4.5.13\", features = [\"derive\", \"string\"] }\nclap-num = \"1.1.1\"\nenv_logger = \"0.10.0\"\nanyhow = \"1.0.86\"\nserde_json = { version = \"1.0.122\", optional = true }\n\n[features]\ndefault = [\"client\"]\nclient = [\"crusader-lib/client\", \"dep:serde_json\"]\n" }, { "path": "src/crusader/src/main.rs", "content": "use anyhow::Context;\nuse clap::{Parser, Subcommand};\nuse clap_num::si_number;\n#[cfg(feature = \"client\")]\nuse crusader_lib::file_format::RawResult;\n#[cfg(feature = \"client\")]\nuse crusader_lib::test::PlotConfig;\nuse crusader_lib::{protocol, version};\n#[cfg(feature = \"client\")]\nuse crusader_lib::{with_time, Config};\n#[cfg(feature = \"client\")]\nuse std::path::PathBuf;\nuse std::process;\n#[cfg(feature = \"client\")]\nuse {\n anyhow::anyhow,\n std::fs::OpenOptions,\n std::io::{BufWriter, Write},\n std::path::Path,\n std::time::Duration,\n};\n\n#[derive(Parser)]\n#[command(version = version())]\nstruct Cli {\n #[command(subcommand)]\n command: Commands,\n}\n\n#[derive(clap::Args)]\nstruct PlotArgs {\n #[arg(long, help = \"Plot transferred bytes\")]\n plot_transferred: bool,\n #[arg(long, help = \"Plot upload and download separately and plot streams\")]\n plot_split_throughput: bool,\n #[arg(long, value_parser=si_number::, value_name = \"BPS\",\n long_help = \"Sets the axis for throughput to at least this value. \\\n SI units are supported so `100M` would specify 100 Mbps\")]\n plot_max_throughput: Option,\n #[arg(\n long,\n value_name = \"MILLISECONDS\",\n help = \"Sets the axis for latency to at least this value\"\n )]\n plot_max_latency: Option,\n #[arg(long, value_name = \"PIXELS\")]\n plot_width: Option,\n #[arg(long, value_name = \"PIXELS\")]\n plot_height: Option,\n #[arg(long)]\n plot_title: Option,\n}\n\nimpl PlotArgs {\n #[cfg(feature = \"client\")]\n fn config(&self) -> PlotConfig {\n PlotConfig {\n transferred: self.plot_transferred,\n split_throughput: self.plot_split_throughput,\n max_throughput: self.plot_max_throughput,\n max_latency: self.plot_max_latency,\n width: self.plot_width,\n height: self.plot_height,\n title: self.plot_title.clone(),\n }\n }\n}\n\n#[derive(Subcommand)]\nenum Commands {\n #[command(about = \"Runs the server\")]\n Serve {\n #[arg(long, default_value_t = protocol::PORT, help = \"Specifies the TCP and UDP port used by the server\")]\n port: u16,\n #[arg(long, help = \"Allow use and discovery as a peer\")]\n peer: bool,\n },\n #[command(\n long_about = \"Runs a test client against a specified server and saves the result to the current directory. \\\n By default this does a download test, an upload test, and a test doing both download and upload while measuring the latency to the server\"\n )]\n #[cfg(feature = \"client\")]\n Test {\n server: Option,\n #[arg(long, help = \"Run a download test\")]\n download: bool,\n #[arg(long, help = \"Run an upload test\")]\n upload: bool,\n #[arg(long, help = \"Run a test doing both download and upload\")]\n bidirectional: bool,\n #[arg(\n long,\n long_help = \"Run a test only measuring latency. The duration is specified by `grace_duration`\"\n )]\n idle: bool,\n #[arg(long, default_value_t = protocol::PORT, help = \"Specifies the TCP and UDP port used by the server\")]\n port: u16,\n #[arg(\n long,\n default_value_t = 8,\n help = \"The number of TCP connections used to generate traffic in a single direction\"\n )]\n streams: u64,\n #[arg(\n long,\n default_value_t = 0.0,\n value_name = \"SECONDS\",\n help = \"The delay between the start of each stream\"\n )]\n stream_stagger: f64,\n #[arg(\n long,\n default_value_t = 10.0,\n value_name = \"SECONDS\",\n help = \"The duration in which traffic is generated\"\n )]\n load_duration: f64,\n #[arg(\n long,\n default_value_t = 2.0,\n value_name = \"SECONDS\",\n help = \"The idle time between each test\"\n )]\n grace_duration: f64,\n #[arg(long, default_value_t = 5, value_name = \"MILLISECONDS\")]\n latency_sample_interval: u64,\n #[arg(long, default_value_t = 60, value_name = \"MILLISECONDS\")]\n throughput_sample_interval: u64,\n #[command(flatten)]\n plot: PlotArgs,\n #[arg(\n long,\n long_help = \"Specifies another server (peer) which will also measure the latency to the server independently of the client\"\n )]\n latency_peer_address: Option,\n #[arg(\n long,\n help = \"Use another server (peer) which will also measure the latency to the server independently of the client\"\n )]\n latency_peer: bool,\n #[arg(\n long,\n help = \"The filename prefix used for the test result raw data and plot filenames\"\n )]\n out_name: Option,\n },\n #[cfg(feature = \"client\")]\n #[command(about = \"Plots a previous result\")]\n Plot {\n data: PathBuf,\n #[command(flatten)]\n plot: PlotArgs,\n },\n #[cfg(feature = \"client\")]\n #[command(about = \"Allows the client to be controlled over a web server\")]\n Remote {\n #[arg(\n long,\n default_value_t = protocol::PORT + 1,\n help = \"Specifies the HTTP port used by the server\"\n )]\n port: u16,\n },\n #[cfg(feature = \"client\")]\n #[command(about = \"Converts a result file to JSON\")]\n Export {\n data: PathBuf,\n #[arg(\n long,\n short('o'),\n help = \"The path where the output JSON will be stored\"\n )]\n output: Option,\n #[arg(long, short('f'), help = \"Overwrite the file if it exists\")]\n force: bool,\n },\n}\n\nfn run() -> Result<(), anyhow::Error> {\n let cli = Cli::parse();\n\n match &cli.command {\n #[cfg(feature = \"client\")]\n &Commands::Test {\n ref server,\n download,\n upload,\n bidirectional,\n idle,\n throughput_sample_interval,\n latency_sample_interval,\n ref plot,\n port,\n streams,\n stream_stagger,\n grace_duration,\n load_duration,\n ref latency_peer_address,\n latency_peer,\n ref out_name,\n } => {\n let mut config = Config {\n port,\n streams,\n stream_stagger: Duration::from_secs_f64(stream_stagger),\n grace_duration: Duration::from_secs_f64(grace_duration),\n load_duration: Duration::from_secs_f64(load_duration),\n download: !idle,\n upload: !idle,\n bidirectional: !idle,\n ping_interval: Duration::from_millis(latency_sample_interval),\n throughput_interval: Duration::from_millis(throughput_sample_interval),\n };\n\n if download || upload || bidirectional {\n if idle {\n println!(\"Cannot run `idle` test with a load test\");\n process::exit(1);\n }\n config.download = download;\n config.upload = upload;\n config.bidirectional = bidirectional;\n }\n\n crusader_lib::test::test(\n config,\n plot.config(),\n server.as_deref(),\n (latency_peer || latency_peer_address.is_some())\n .then_some(latency_peer_address.as_deref()),\n out_name.as_deref().unwrap_or(\"test\"),\n )\n }\n &Commands::Serve { port, peer } => crusader_lib::serve::serve(port, peer),\n\n #[cfg(feature = \"client\")]\n Commands::Remote { port } => crusader_lib::remote::run(*port),\n\n #[cfg(feature = \"client\")]\n Commands::Plot { data, plot } => {\n let result = RawResult::load(data).ok_or(anyhow!(\"Unable to load data\"))?;\n let root = data.parent().unwrap_or(Path::new(\"\"));\n let file = crusader_lib::plot::save_graph(\n &plot.config(),\n &result.to_test_result(),\n data.file_stem()\n .and_then(|name| name.to_str())\n .unwrap_or(\"plot\"),\n data.parent().unwrap_or(Path::new(\"\")),\n )?;\n println!(\n \"{}\",\n with_time(&format!(\"Saved plot as {}\", root.join(file).display()))\n );\n Ok(())\n }\n #[cfg(feature = \"client\")]\n Commands::Export {\n data,\n output,\n force,\n } => {\n let result = RawResult::load(data).ok_or(anyhow!(\"Unable to load data\"))?;\n let output = output\n .clone()\n .unwrap_or_else(|| data.with_extension(\"json\"));\n let file = OpenOptions::new()\n .create_new(!*force)\n .create(*force)\n .truncate(true)\n .write(true)\n .open(output)\n .context(\"Failed to create output file\")?;\n let mut file = BufWriter::new(file);\n serde_json::to_writer_pretty(&mut file, &result).context(\"Failed to serialize data\")?;\n file.flush().context(\"Failed to flush output\")?;\n\n Ok(())\n }\n }\n}\n\nfn main() {\n env_logger::init();\n\n #[cfg(feature = \"client\")]\n crusader_lib::plot::register_fonts();\n\n if let Err(error) = run() {\n println!(\"Error: {:?}\", error);\n process::exit(1);\n }\n}\n" }, { "path": "src/crusader-gui/Cargo.toml", "content": "[package]\nname = \"crusader-gui\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\ncrusader-lib = { path = \"../crusader-lib\" }\ncrusader-gui-lib = { path = \"../crusader-gui-lib\" }\nenv_logger = \"0.10.0\"\neframe = \"0.28.1\"\nfont-kit = \"0.14.2\"\n" }, { "path": "src/crusader-gui/src/main.rs", "content": "#![allow(\r\n clippy::field_reassign_with_default,\r\n clippy::option_map_unit_fn,\r\n clippy::type_complexity\r\n)]\r\n#![cfg_attr(not(debug_assertions), windows_subsystem = \"windows\")] // hide console window on Windows in release\r\n\r\nuse std::{error::Error, process, sync::Arc};\r\n\r\nuse crusader_gui_lib::Tester;\r\nuse crusader_lib::version;\r\nuse eframe::{\r\n egui::{self, Context, FontData, FontDefinitions, FontFamily},\r\n emath::vec2,\r\n Theme,\r\n};\r\n#[allow(unused_imports)]\r\nuse font_kit::family_name::FamilyName;\r\nuse font_kit::{handle::Handle, properties::Properties, source::SystemSource};\r\n\r\nfn main() {\r\n env_logger::init();\r\n\r\n let mut options = eframe::NativeOptions::default();\r\n options.follow_system_theme = false;\r\n options.default_theme = Theme::Light;\r\n\r\n crusader_lib::plot::register_fonts();\r\n\r\n let settings = std::env::current_exe()\r\n .ok()\r\n .map(|exe| exe.with_extension(\"toml\"));\r\n\r\n let result = eframe::run_native(\r\n &format!(\"Crusader Network Tester {}\", version()),\r\n options,\r\n Box::new(move |cc| {\r\n let ctx = &cc.egui_ctx;\r\n let mut style = ctx.style();\r\n let style_ = Arc::make_mut(&mut style);\r\n\r\n style_.spacing.button_padding = vec2(6.0, 0.0);\r\n style_.spacing.interact_size.y = 30.0;\r\n style_.spacing.item_spacing = vec2(5.0, 5.0);\r\n\r\n let font_size = if cfg!(target_os = \"macos\") {\r\n 13.5\r\n } else {\r\n 12.5\r\n };\r\n\r\n style_.text_styles.get_mut(&egui::TextStyle::Body).map(|v| {\r\n v.size = font_size;\r\n });\r\n style_\r\n .text_styles\r\n .get_mut(&egui::TextStyle::Button)\r\n .map(|v| {\r\n v.size = font_size;\r\n });\r\n style_\r\n .text_styles\r\n .get_mut(&egui::TextStyle::Small)\r\n .map(|v| {\r\n v.size = font_size;\r\n });\r\n style_\r\n .text_styles\r\n .get_mut(&egui::TextStyle::Monospace)\r\n .map(|v| {\r\n v.size = font_size;\r\n });\r\n ctx.set_style(style);\r\n\r\n load_system_font(ctx).ok();\r\n\r\n Ok(Box::new(App {\r\n tester: Tester::new(settings),\r\n }))\r\n }),\r\n );\r\n if let Err(e) = result {\r\n eprintln!(\"Failed to run GUI: {}\", e);\r\n process::exit(1);\r\n }\r\n}\r\n\r\nfn load_system_font(ctx: &Context) -> Result<(), Box> {\r\n let mut fonts = FontDefinitions::default();\r\n\r\n let handle = SystemSource::new().select_best_match(\r\n &[\r\n #[cfg(target_os = \"macos\")]\r\n FamilyName::SansSerif,\r\n #[cfg(windows)]\r\n FamilyName::Title(\"Segoe UI\".to_string()),\r\n ],\r\n &Properties::new(),\r\n )?;\r\n\r\n let buf: Vec = match handle {\r\n Handle::Memory { bytes, .. } => bytes.to_vec(),\r\n Handle::Path { path, .. } => std::fs::read(path)?,\r\n };\r\n\r\n const UI_FONT: &str = \"System Sans Serif\";\r\n\r\n fonts\r\n .font_data\r\n .insert(UI_FONT.to_owned(), FontData::from_owned(buf));\r\n\r\n if let Some(vec) = fonts.families.get_mut(&FontFamily::Proportional) {\r\n vec.insert(0, UI_FONT.to_owned());\r\n }\r\n\r\n if let Some(vec) = fonts.families.get_mut(&FontFamily::Monospace) {\r\n vec.insert(0, UI_FONT.to_owned());\r\n }\r\n\r\n ctx.set_fonts(fonts);\r\n\r\n Ok(())\r\n}\r\n\r\nstruct App {\r\n tester: Tester,\r\n}\r\n\r\nimpl eframe::App for App {\r\n fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {\r\n egui::CentralPanel::default().show(ctx, |ui| {\r\n self.tester.show(ctx, ui);\r\n });\r\n }\r\n}\r\n" }, { "path": "src/crusader-gui-lib/Cargo.toml", "content": "[package]\nname = \"crusader-gui-lib\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[dependencies]\ntoml = \"0.5.9\"\nserde = { version = \"1.0.137\", features = [\"derive\"] }\ncrusader-lib = { path = \"../crusader-lib\", features = [\"server\", \"client\"] }\ntokio = { version = \"1.18.2\", features = [\"full\"] }\neframe = \"0.28.1\"\negui_plot = \"0.28.1\"\negui_extras = { version = \"0.28.1\", default-features = false }\nopen = \"5.3.0\"\n\n[target.'cfg(not(target_os = \"android\"))'.dependencies]\nrfd = { version = \"0.10.0\", default-features = false, features = [\n \"xdg-portal\",\n] }\n" }, { "path": "src/crusader-gui-lib/src/client.rs", "content": "use crate::{Tab, Tester};\nuse crusader_lib::{\n file_format::RawResult,\n protocol,\n test::{self},\n with_time, Config,\n};\nuse eframe::{\n egui::{self, vec2, Grid, ScrollArea, TextEdit, Ui},\n emath::Align,\n};\nuse serde::{Deserialize, Serialize};\nuse std::{mem, sync::Arc, time::Duration};\nuse tokio::sync::{\n mpsc::{self},\n oneshot,\n};\n\n#[derive(Serialize, Deserialize, Clone, PartialEq)]\n#[serde(default)]\npub struct ClientSettings {\n pub server: String,\n pub download: bool,\n pub upload: bool,\n pub bidirectional: bool,\n pub streams: u64,\n pub load_duration: f64,\n pub grace_duration: f64,\n pub stream_stagger: f64,\n pub latency_sample_interval: u64,\n pub throughput_sample_interval: u64,\n pub latency_peer: bool,\n pub latency_peer_server: String,\n pub advanced: bool,\n pub idle_test: bool,\n pub idle_duration: f64,\n}\n\nimpl ClientSettings {\n fn config(&self) -> Config {\n Config {\n port: protocol::PORT,\n streams: self.streams,\n grace_duration: Duration::from_secs_f64(self.grace_duration),\n load_duration: Duration::from_secs_f64(self.load_duration),\n stream_stagger: Duration::from_secs_f64(self.stream_stagger),\n download: self.download,\n upload: self.upload,\n bidirectional: self.bidirectional,\n ping_interval: Duration::from_millis(self.latency_sample_interval),\n throughput_interval: Duration::from_millis(self.throughput_sample_interval),\n }\n }\n}\n\nimpl Default for ClientSettings {\n fn default() -> Self {\n Self {\n server: String::new(),\n download: true,\n upload: true,\n bidirectional: true,\n streams: 8,\n load_duration: 10.0,\n grace_duration: 2.0,\n stream_stagger: 0.0,\n latency_sample_interval: 5,\n throughput_sample_interval: 60,\n latency_peer: false,\n latency_peer_server: String::new(),\n advanced: false,\n idle_test: false,\n idle_duration: 10.0,\n }\n }\n}\n\npub struct Client {\n rx: mpsc::UnboundedReceiver,\n pub done: Option>>>,\n pub abort: Option>,\n}\n\n#[derive(PartialEq, Eq)]\npub enum ClientState {\n Stopped,\n Stopping,\n Running,\n}\n\nimpl Tester {\n fn start_client(&mut self, ctx: &egui::Context) {\n self.save_settings();\n self.msgs.clear();\n self.msg_scrolled = 0;\n\n let (signal_done, done) = oneshot::channel();\n let (tx, rx) = mpsc::unbounded_channel();\n\n let ctx = ctx.clone();\n let ctx_ = ctx.clone();\n\n let config = if self.settings.client.idle_test {\n let mut config = ClientSettings::default().config();\n config.grace_duration = Duration::from_secs_f64(self.settings.client.idle_duration);\n config.ping_interval =\n Duration::from_millis(self.settings.client.latency_sample_interval);\n config.bidirectional = false;\n config.download = false;\n config.upload = false;\n config\n } else {\n self.settings.client.config()\n };\n\n let abort = test::test_callback(\n config,\n (!self.settings.client.server.trim().is_empty())\n .then_some(&self.settings.client.server),\n self.settings.client.latency_peer.then_some(\n (!self.settings.client.latency_peer_server.trim().is_empty())\n .then_some(&self.settings.client.latency_peer_server),\n ),\n Arc::new(move |msg| {\n tx.send(with_time(msg)).unwrap();\n ctx.request_repaint();\n }),\n Box::new(move |result| {\n signal_done.send(result).map_err(|_| ()).unwrap();\n ctx_.request_repaint();\n }),\n );\n\n self.client = Some(Client {\n done: Some(done),\n rx,\n abort: Some(abort),\n });\n self.client_state = ClientState::Running;\n }\n\n fn idle_settings(&mut self, ui: &mut Ui) {\n Grid::new(\"idle-settings\").show(ui, |ui| {\n ui.label(\"Duration: \");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.idle_duration)\n .range(0..=1000)\n .speed(0.05),\n );\n ui.label(\"seconds\");\n ui.end_row();\n if self.settings.client.advanced {\n ui.label(\"Latency sample interval:\");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.latency_sample_interval)\n .range(1..=1000)\n .speed(0.05),\n );\n ui.label(\"milliseconds\");\n ui.end_row();\n }\n });\n\n if self.settings.client.advanced {\n ui.separator();\n\n ui.horizontal_wrapped(|ui| {\n ui.checkbox(&mut self.settings.client.latency_peer, \"Latency peer:\").on_hover_text(\"Specifies another server (peer) which will also measure the latency to the server independently of the client\");\n ui.add_enabled_ui(self.settings.client.latency_peer, |ui| {\n ui.add(\n TextEdit::singleline(&mut self.settings.client.latency_peer_server)\n .hint_text(\"(Locate local peer)\"),\n );\n });\n });\n }\n\n ui.separator();\n\n if !self.settings.client.advanced {\n let mut any = false;\n let config = self.settings.client.clone();\n let default = ClientSettings::default();\n\n if config.latency_sample_interval != default.latency_sample_interval {\n any = true;\n ui.label(format!(\n \"Latency sample interval: {:.2} milliseconds\",\n config.latency_sample_interval\n ));\n }\n\n if config.latency_peer != default.latency_peer {\n any = true;\n let server = (!config.latency_peer_server.trim().is_empty())\n .then_some(&*config.latency_peer_server);\n ui.label(format!(\"Latency peer: {}\", server.unwrap_or(\"\")));\n }\n\n if any {\n ui.separator();\n }\n }\n }\n\n fn latency_under_load_settings(&mut self, ui: &mut Ui, compact: bool) {\n if !self.settings.client.advanced || compact {\n ui.horizontal_wrapped(|ui| {\n ui.checkbox(&mut self.settings.client.download, \"Download\")\n .on_hover_text(\"Run a download test\");\n ui.add_space(10.0);\n ui.checkbox(&mut self.settings.client.upload, \"Upload\")\n .on_hover_text(\"Run an upload test\");\n ui.add_space(10.0);\n ui.checkbox(&mut self.settings.client.bidirectional, \"Bidirectional\")\n .on_hover_text(\"Run a test doing both download and upload\");\n });\n Grid::new(\"settings-compact\").show(ui, |ui| {\n ui.label(\"Streams: \").on_hover_text(\n \"The number of TCP connections used to generate traffic in a single direction\",\n );\n ui.add(\n egui::DragValue::new(&mut self.settings.client.streams)\n .range(1..=1000)\n .speed(0.05),\n );\n ui.end_row();\n ui.label(\"Load duration: \")\n .on_hover_text(\"The duration in which traffic is generated\");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.load_duration)\n .range(0..=1000)\n .speed(0.05),\n );\n ui.label(\"seconds\");\n ui.end_row();\n if self.settings.client.advanced {\n ui.label(\"Grace duration: \")\n .on_hover_text(\"The idle time between each test\");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.grace_duration)\n .range(0..=1000)\n .speed(0.05),\n );\n ui.label(\"seconds\");\n ui.end_row();\n ui.label(\"Stream stagger: \")\n .on_hover_text(\"The delay between the start of each stream\");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.stream_stagger)\n .range(0..=1000)\n .speed(0.05),\n );\n ui.label(\"seconds\");\n ui.end_row();\n ui.label(\"Latency sample interval:\");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.latency_sample_interval)\n .range(1..=1000)\n .speed(0.05),\n );\n ui.label(\"milliseconds\");\n ui.end_row();\n ui.label(\"Throughput sample interval:\");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.throughput_sample_interval)\n .range(1..=1000)\n .speed(0.05),\n );\n ui.label(\"milliseconds\");\n ui.end_row();\n }\n });\n } else {\n Grid::new(\"settings\").show(ui, |ui| {\n ui.checkbox(&mut self.settings.client.download, \"Download\")\n .on_hover_text(\"Run a download test\");\n ui.allocate_space(vec2(1.0, 1.0));\n ui.label(\"Streams: \").on_hover_text(\n \"The number of TCP connections used to generate traffic in a single direction\",\n );\n ui.add(\n egui::DragValue::new(&mut self.settings.client.streams)\n .range(1..=1000)\n .speed(0.05),\n );\n ui.label(\"\");\n ui.allocate_space(vec2(1.0, 1.0));\n\n ui.label(\"Stream stagger: \")\n .on_hover_text(\"The delay between the start of each stream\");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.stream_stagger)\n .range(0..=1000)\n .speed(0.05),\n );\n ui.label(\"seconds\");\n ui.end_row();\n\n ui.checkbox(&mut self.settings.client.upload, \"Upload\")\n .on_hover_text(\"Run an upload test\");\n ui.label(\"\");\n ui.label(\"Load duration: \")\n .on_hover_text(\"The duration in which traffic is generated\");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.load_duration)\n .range(0..=1000)\n .speed(0.05),\n );\n ui.label(\"seconds\");\n ui.label(\"\");\n\n ui.label(\"Latency sample interval: \");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.latency_sample_interval)\n .range(1..=1000)\n .speed(0.05),\n );\n ui.label(\"milliseconds\");\n ui.end_row();\n\n ui.checkbox(&mut self.settings.client.bidirectional, \"Bidirectional\")\n .on_hover_text(\"Run a test doing both download and upload\");\n ui.label(\"\");\n ui.label(\"Grace duration: \")\n .on_hover_text(\"The idle time between each test\");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.grace_duration)\n .range(0..=1000)\n .speed(0.05),\n );\n ui.label(\"seconds\");\n ui.label(\"\");\n ui.label(\"Throughput sample interval: \");\n ui.add(\n egui::DragValue::new(&mut self.settings.client.throughput_sample_interval)\n .range(1..=1000)\n .speed(0.05),\n );\n ui.label(\"milliseconds\");\n ui.end_row();\n });\n }\n\n if self.settings.client.advanced {\n ui.separator();\n\n ui.horizontal_wrapped(|ui| {\n ui.checkbox(&mut self.settings.client.latency_peer, \"Latency peer:\").on_hover_text(\"Specifies another server (peer) which will also measure the latency to the server independently of the client\");\n ui.add_enabled_ui(self.settings.client.latency_peer, |ui| {\n ui.add(\n TextEdit::singleline(&mut self.settings.client.latency_peer_server)\n .hint_text(\"(Locate local peer)\"),\n );\n });\n });\n }\n\n ui.separator();\n\n if !self.settings.client.advanced {\n let mut any = false;\n let config = self.settings.client.clone();\n let default = ClientSettings::default();\n\n if config.grace_duration != default.grace_duration {\n any = true;\n ui.label(format!(\n \"Grace duration: {:.2} seconds\",\n config.grace_duration\n ));\n }\n\n if config.stream_stagger != default.stream_stagger {\n any = true;\n ui.label(format!(\n \"Stream stagger: {:.2} seconds\",\n config.stream_stagger\n ));\n }\n\n if config.latency_sample_interval != default.latency_sample_interval {\n any = true;\n ui.label(format!(\n \"Latency sample interval: {:.2} milliseconds\",\n config.latency_sample_interval\n ));\n }\n\n if config.throughput_sample_interval != default.throughput_sample_interval {\n any = true;\n ui.label(format!(\n \"Throughput sample interval: {:.2} milliseconds\",\n config.throughput_sample_interval\n ));\n }\n\n if config.latency_peer != default.latency_peer {\n any = true;\n let server = (!config.latency_peer_server.trim().is_empty())\n .then_some(&*config.latency_peer_server);\n ui.label(format!(\"Latency peer: {}\", server.unwrap_or(\"\")));\n }\n\n if any {\n ui.separator();\n }\n }\n }\n\n pub fn client(&mut self, ctx: &egui::Context, ui: &mut Ui, compact: bool) {\n let active = self.client_state == ClientState::Stopped;\n\n ui.horizontal_wrapped(|ui| {\n ui.add_enabled_ui(active, |ui| {\n ui.label(\"Server address:\");\n let response = ui.add(\n TextEdit::singleline(&mut self.settings.client.server)\n .hint_text(\"(Locate local server)\"),\n );\n if self.client_state == ClientState::Stopped\n && response.lost_focus()\n && ui.input(|i| i.key_pressed(egui::Key::Enter))\n {\n self.start_client(ctx)\n }\n });\n\n match self.client_state {\n ClientState::Running => {\n if ui.button(\"Stop test\").clicked() {\n let client = self.client.as_mut().unwrap();\n mem::take(&mut client.abort).unwrap().send(()).unwrap();\n self.client_state = ClientState::Stopping;\n }\n }\n ClientState::Stopping => {\n ui.add_enabled_ui(false, |ui| {\n let _ = ui.button(\"Stopping test..\");\n });\n }\n ClientState::Stopped => {\n if ui.button(\"Start test\").clicked() {\n self.start_client(ctx)\n }\n }\n }\n });\n\n ui.separator();\n\n ScrollArea::vertical()\n .auto_shrink([false; 2])\n .show(ui, |ui| {\n ui.add_enabled_ui(active, |ui| {\n ui.horizontal(|ui| {\n ui.label(\"Measure:\");\n ui.selectable_value(\n &mut self.settings.client.idle_test,\n false,\n \"Latency under load\",\n );\n ui.selectable_value(\n &mut self.settings.client.idle_test,\n true,\n \"Latency only\",\n );\n });\n\n ui.separator();\n\n if self.settings.client.idle_test {\n self.idle_settings(ui);\n } else {\n self.latency_under_load_settings(ui, compact);\n }\n\n ui.horizontal(|ui| {\n let mut default = ClientSettings::default();\n default.idle_test = self.settings.client.idle_test;\n default.advanced = self.settings.client.advanced;\n default.server = self.settings.client.server.clone();\n default.latency_peer_server =\n self.settings.client.latency_peer_server.clone();\n\n let parameters_changed = self.settings.client != default;\n\n ui.add_enabled_ui(parameters_changed, |ui| {\n if ui.button(\"Reset settings\").clicked() {\n self.settings.client = default;\n }\n });\n\n ui.toggle_value(&mut self.settings.client.advanced, \"Advanced mode\");\n })\n });\n\n if self.client_state == ClientState::Running\n || self.client_state == ClientState::Stopping\n {\n let client = self.client.as_mut().unwrap();\n\n while let Ok(msg) = client.rx.try_recv() {\n println!(\"[Client] {msg}\");\n self.msgs.push(msg);\n }\n\n if let Ok(result) = client.done.as_mut().unwrap().try_recv() {\n match result {\n Some(Ok(result)) => {\n self.msgs.push(with_time(\"Test complete\"));\n let result = result.to_test_result();\n self.set_result(result);\n if self.tab == Tab::Client {\n self.tab = Tab::Result;\n }\n }\n Some(Err(error)) => {\n self.msgs.push(with_time(&format!(\"Error: {error}\")));\n }\n None => {\n self.msgs.push(with_time(\"Aborted...\"));\n }\n }\n self.client = None;\n self.client_state = ClientState::Stopped;\n }\n }\n\n if !self.msgs.is_empty() {\n ui.separator();\n }\n\n for (i, msg) in self.msgs.iter().enumerate() {\n let response = ui.label(msg);\n if self.msg_scrolled <= i {\n self.msg_scrolled = i + 1;\n response.scroll_to_me(Some(Align::Max));\n }\n }\n });\n }\n}\n" }, { "path": "src/crusader-gui-lib/src/lib.rs", "content": "#![allow(\n clippy::field_reassign_with_default,\n clippy::option_map_unit_fn,\n clippy::type_complexity,\n clippy::too_many_arguments\n)]\n\nuse std::ffi::OsStr;\nuse std::hash::Hash;\nuse std::{\n fs, mem,\n path::{Path, PathBuf},\n sync::Arc,\n time::Duration,\n};\n\nuse client::{Client, ClientSettings, ClientState};\nuse crusader_lib::plot::{smooth, LatencySummary};\nuse crusader_lib::test::timed;\nuse crusader_lib::{\n file_format::{RawPing, RawResult, TestKind},\n latency,\n plot::{self, float_max, to_rates},\n protocol, remote, serve,\n test::{self, PlotConfig},\n with_time,\n};\nuse eframe::egui::{AboveOrBelow, Label, Layout, TextWrapMode};\nuse eframe::{\n egui::{\n self, Grid, Id, PopupCloseBehavior, RichText, ScrollArea, TextEdit, TextStyle, Ui, Vec2b,\n },\n emath::Align,\n epaint::Color32,\n};\nuse egui_extras::{Size, Strip, StripBuilder};\nuse egui_plot::{ColorConflictHandling, Legend, Line, Plot, PlotPoints};\n\n#[cfg(not(target_os = \"android\"))]\nuse rfd::FileDialog;\n\nuse serde::{Deserialize, Serialize};\nuse tokio::sync::{\n mpsc::{self, error::TryRecvError},\n oneshot,\n};\n\nmod client;\n\nstruct Server {\n done: Option>,\n msgs: Vec,\n rx: mpsc::UnboundedReceiver,\n stop: Option>,\n started: oneshot::Receiver>,\n}\n\nenum ServerState {\n Stopped(Option),\n Starting,\n Stopping,\n Running,\n}\n\nstruct Latency {\n done: Option>>>,\n abort: Option>,\n}\n\n#[derive(PartialEq, Eq)]\nenum Tab {\n Client,\n Server,\n Remote,\n Monitor,\n Result,\n}\n\n#[derive(Serialize, Deserialize, Clone, PartialEq)]\n#[serde(default)]\npub struct LatencyMonitorSettings {\n pub server: String,\n pub history: f64,\n pub latency_sample_interval: u64,\n}\n\nimpl Default for LatencyMonitorSettings {\n fn default() -> Self {\n Self {\n server: \"\".to_owned(),\n history: 60.0,\n latency_sample_interval: 5,\n }\n }\n}\n\n#[derive(Serialize, Deserialize, Clone, PartialEq, Default)]\n#[serde(default)]\npub struct Settings {\n pub client: ClientSettings,\n pub latency_monitor: LatencyMonitorSettings,\n}\n\nimpl Settings {\n fn from_path(path: &Path) -> Self {\n fs::read_to_string(path)\n .ok()\n .and_then(|data| toml::from_str(&data).ok())\n .unwrap_or_default()\n }\n}\n\npub struct Tester {\n tab: Tab,\n settings: Settings,\n settings_path: Option,\n saved_settings: Settings,\n server_state: ServerState,\n server: Option,\n remote_state: ServerState,\n remote_server: Option,\n client_state: ClientState,\n client: Option,\n result_plot_reset: bool,\n result: Option,\n raw_result_saved: Option,\n open_result: Vec,\n result_name: String,\n msgs: Vec,\n msg_scrolled: usize,\n pub file_loader: Option>,\n pub plot_saver: Option>,\n pub raw_saver: Option>,\n\n latency_state: ClientState,\n latency: Option,\n latency_data: Arc,\n latency_stop: Duration,\n latency_error: Option,\n latency_plot_reset: bool,\n}\n\npub struct LatencyResult {\n total: Vec<(f64, f64)>,\n max: f64,\n up: Vec<(f64, f64)>,\n down: Vec<(f64, f64)>,\n loss: Vec<(f64, Option)>,\n}\nimpl LatencyResult {\n fn new(result: &plot::TestResult, pings: &[RawPing]) -> Self {\n let start = result.start.as_secs_f64();\n let total: Vec<_> = pings\n .iter()\n .filter(|p| p.sent >= result.start)\n .filter_map(|p| {\n p.latency.and_then(|latency| {\n latency\n .total\n .map(|total| (p.sent.as_secs_f64() - start, total.as_secs_f64() * 1000.0))\n })\n })\n .collect();\n\n let up: Vec<_> = pings\n .iter()\n .filter(|p| p.sent >= result.start)\n .filter_map(|p| {\n p.latency.map(|latency| {\n (\n p.sent.as_secs_f64() - start,\n latency.up.as_secs_f64() * 1000.0,\n )\n })\n })\n .collect();\n\n let down: Vec<_> = pings\n .iter()\n .filter(|p| p.sent >= result.start)\n .filter_map(|p| {\n p.latency.and_then(|latency| {\n latency\n .down()\n .map(|down| (p.sent.as_secs_f64() - start, down.as_secs_f64() * 1000.0))\n })\n })\n .collect();\n\n let loss = pings\n .iter()\n .filter(|p| p.sent >= result.start)\n .filter_map(|ping| {\n if ping.latency.and_then(|latency| latency.total).is_none() {\n let down_loss =\n (result.raw_result.version >= 2).then_some(ping.latency.is_some());\n Some((ping.sent.as_secs_f64() - start, down_loss))\n } else {\n None\n }\n })\n .collect();\n let max = float_max(total.iter().map(|v| v.1));\n LatencyResult {\n total,\n up,\n down,\n loss,\n max,\n }\n }\n}\n\npub struct TestResult {\n result: plot::TestResult,\n download: Option>,\n download_avg: Option>,\n upload: Option>,\n upload_avg: Option>,\n both_download: Option>,\n both_download_avg: Option>,\n both_upload: Option>,\n both_upload_avg: Option>,\n both: Option>,\n both_avg: Option>,\n local_latency: LatencyResult,\n peer_latency: Option,\n throughput_max: f64,\n}\n\nimpl TestResult {\n fn new(result: plot::TestResult) -> Self {\n let smooth_interval =\n Duration::from_secs_f64(1.0).min(result.raw_result.config.grace_duration);\n let interval = result.raw_result.config.bandwidth_interval;\n\n let start = result.start.as_secs_f64();\n\n let download = result\n .download_bytes\n .as_ref()\n .map(|bytes| handle_bytes(bytes, start));\n let download_avg = result\n .download_bytes\n .as_ref()\n .map(|bytes| smooth_bytes(bytes, start, interval, smooth_interval));\n\n let upload = result\n .upload_bytes\n .as_ref()\n .map(|bytes| handle_bytes(bytes, start));\n let upload_avg = result\n .upload_bytes\n .as_ref()\n .map(|bytes| smooth_bytes(bytes, start, interval, smooth_interval));\n\n let both_upload = result\n .both_upload_bytes\n .as_ref()\n .map(|bytes| handle_bytes(bytes, start));\n let both_upload_avg = result\n .both_upload_bytes\n .as_ref()\n .map(|bytes| smooth_bytes(bytes, start, interval, smooth_interval));\n\n let both_download = result\n .both_download_bytes\n .as_ref()\n .map(|bytes| handle_bytes(bytes, start));\n let both_download_avg = result\n .both_download_bytes\n .as_ref()\n .map(|bytes| smooth_bytes(bytes, start, interval, smooth_interval));\n\n let both = result\n .both_bytes\n .as_ref()\n .map(|bytes| handle_bytes(bytes, start));\n let both_avg = result\n .both_bytes\n .as_ref()\n .map(|bytes| smooth_bytes(bytes, start, interval, smooth_interval));\n\n let download_max = download\n .as_ref()\n .map(|data| float_max(data.iter().map(|v| v.1)));\n let upload_max = upload\n .as_ref()\n .map(|data| float_max(data.iter().map(|v| v.1)));\n let both_upload_max = both_upload\n .as_ref()\n .map(|data| float_max(data.iter().map(|v| v.1)));\n let both_download_max = both_download\n .as_ref()\n .map(|data| float_max(data.iter().map(|v| v.1)));\n let both_max = both\n .as_ref()\n .map(|data| float_max(data.iter().map(|v| v.1)));\n let throughput_max = float_max(\n [\n download_max,\n upload_max,\n both_upload_max,\n both_download_max,\n both_max,\n ]\n .into_iter()\n .flatten(),\n );\n\n TestResult {\n download,\n download_avg,\n upload,\n upload_avg,\n both_download,\n both_download_avg,\n both_upload,\n both_upload_avg,\n both,\n both_avg,\n throughput_max,\n local_latency: LatencyResult::new(&result, &result.pings),\n peer_latency: result\n .raw_result\n .peer_pings\n .as_ref()\n .map(|pings| LatencyResult::new(&result, pings)),\n result,\n }\n }\n}\n\npub fn handle_bytes(data: &[(u64, f64)], start: f64) -> Vec<(f64, f64)> {\n to_rates(data)\n .into_iter()\n .map(|(time, speed)| (Duration::from_micros(time).as_secs_f64() - start, speed))\n .collect()\n}\n\npub fn smooth_bytes(\n data: &[(u64, f64)],\n start: f64,\n interval: Duration,\n smoothing_interval: Duration,\n) -> Vec<(f64, f64)> {\n smooth(data, interval, smoothing_interval)\n .into_iter()\n .map(|(time, speed)| (Duration::from_micros(time).as_secs_f64() - start, speed))\n .collect()\n}\n\nfn hover_popup(\n ui: &mut Ui,\n id_source: impl Hash,\n position: AboveOrBelow,\n popup: impl FnOnce(&mut Ui),\n) {\n ui.scope(|ui| {\n let id = ui.make_persistent_id(id_source);\n\n ui.spacing_mut().interact_size.y = 18.0;\n let active = id.with(\"active\");\n\n let active_value = ui.memory_mut(|mem| {\n let active = mem.data.get_temp_mut_or_default(active);\n *active\n });\n\n let style = ui.style_mut();\n\n style.visuals.widgets.inactive.rounding = 50.0.into();\n style.visuals.widgets.hovered.rounding = 50.0.into();\n style.visuals.widgets.active.rounding = 50.0.into();\n style.visuals.widgets.inactive.fg_stroke.color = Color32::from_gray(140);\n\n if active_value {\n style.visuals.widgets.inactive.weak_bg_fill = style.visuals.selection.bg_fill;\n style.visuals.widgets.hovered.weak_bg_fill = style.visuals.selection.bg_fill;\n }\n\n let stats = ui.button(\"i\");\n let popup_id = id.with(\"popup\");\n\n let contains_pointer =\n if let Some(pointer) = ui.ctx().input(|input| input.pointer.latest_pos()) {\n stats.interact_rect.expand(5.0).contains(pointer)\n } else {\n false\n };\n\n if stats.hovered() && contains_pointer {\n ui.memory_mut(|mem| {\n if !mem.any_popup_open() {\n mem.open_popup(popup_id);\n }\n });\n } else if !active_value && !contains_pointer {\n ui.memory_mut(|mem| {\n if mem.is_popup_open(popup_id) {\n mem.close_popup();\n }\n });\n }\n\n if stats.clicked() {\n ui.memory_mut(|mem| {\n let active: &mut bool = mem.data.get_temp_mut_or_default(active);\n *active = !*active;\n if *active {\n mem.open_popup(popup_id);\n } else {\n mem.close_popup();\n }\n });\n }\n\n egui::popup::popup_above_or_below_widget(\n ui,\n popup_id,\n &stats,\n position,\n PopupCloseBehavior::CloseOnClickOutside,\n |ui| {\n popup(ui);\n },\n );\n\n ui.memory_mut(|mem| {\n if !mem.is_popup_open(popup_id) {\n let active: &mut bool = mem.data.get_temp_mut_or_default(active);\n if *active {\n // ui.ctx().request_repaint();\n }\n *active = false;\n }\n });\n });\n}\n\nimpl Drop for Tester {\n fn drop(&mut self) {\n self.save_settings();\n\n // Stop client\n self.client.as_mut().map(|client| {\n mem::take(&mut client.abort).map(|abort| {\n abort.send(()).unwrap();\n });\n mem::take(&mut client.done).map(|done| {\n done.blocking_recv().ok();\n });\n });\n\n // Stop server\n self.server.as_mut().map(|server| {\n mem::take(&mut server.stop).map(|stop| {\n stop.send(()).unwrap();\n });\n mem::take(&mut server.done).map(|done| {\n done.blocking_recv().ok();\n });\n });\n\n // Stop latency\n self.latency.as_mut().map(|latency| {\n mem::take(&mut latency.abort).map(|abort| {\n abort.send(()).unwrap();\n });\n mem::take(&mut latency.done).map(|done| {\n done.blocking_recv().ok();\n });\n });\n }\n}\n\nimpl Tester {\n pub fn new(settings_path: Option) -> Tester {\n let settings = settings_path\n .as_deref()\n .map_or(Settings::default(), Settings::from_path);\n Tester {\n tab: Tab::Client,\n saved_settings: settings.clone(),\n settings,\n settings_path,\n client_state: ClientState::Stopped,\n client: None,\n result: None,\n result_plot_reset: false,\n raw_result_saved: None,\n result_name: \"\".to_string(),\n open_result: Vec::new(),\n msgs: Vec::new(),\n msg_scrolled: 0,\n server_state: ServerState::Stopped(None),\n server: None,\n remote_state: ServerState::Stopped(None),\n remote_server: None,\n file_loader: None,\n raw_saver: None,\n plot_saver: None,\n latency_state: ClientState::Stopped,\n latency: None,\n latency_data: Arc::new(latency::Data::new(0, Arc::new(|| {}))),\n latency_stop: Duration::from_secs(0),\n latency_error: None,\n latency_plot_reset: false,\n }\n }\n\n pub fn set_result(&mut self, result: plot::TestResult) {\n self.result = Some(TestResult::new(result));\n self.result_name = \"test\".to_owned();\n self.result_plot_reset = true;\n self.raw_result_saved = None;\n }\n\n pub fn load_file(&mut self, name: PathBuf, raw: RawResult) {\n self.set_result(raw.to_test_result());\n self.raw_result_saved = Some(name);\n }\n\n pub fn save_raw(&mut self, name: PathBuf) {\n self.raw_result_saved = Some(name);\n }\n\n fn save_settings(&mut self) {\n if self.settings != self.saved_settings {\n self.settings_path.as_deref().map(|path| {\n toml::ser::to_string_pretty(&self.settings)\n .map(|data| fs::write(path, data.as_bytes()))\n .ok();\n });\n self.saved_settings = self.settings.clone();\n }\n }\n\n fn load_result(&mut self) {\n #[cfg(not(target_os = \"android\"))]\n {\n FileDialog::new()\n .add_filter(\"Crusader Raw Result\", &[\"crr\"])\n .add_filter(\"All files\", &[\"*\"])\n .pick_file()\n .map(|file| {\n RawResult::load(&file).map(|raw| {\n self.load_file(file, raw);\n })\n });\n }\n let file_loader = self.file_loader.take();\n file_loader.as_ref().map(|loader| loader(self));\n self.file_loader = file_loader;\n }\n\n fn latency_and_loss(\n &mut self,\n strip: &mut Strip<'_, '_>,\n link: Id,\n reset: bool,\n peer: bool,\n y_axis_size: f32,\n ) {\n let result = self.result.as_ref().unwrap();\n\n let data = if peer {\n result.peer_latency.as_ref().unwrap()\n } else {\n &result.local_latency\n };\n\n let latencies = if peer {\n &result.result.peer_latencies\n } else {\n &result.result.latencies\n };\n\n let duration = result.result.duration.as_secs_f64() * 1.1;\n\n strip.cell(|ui| {\n ui.horizontal(|ui| {\n let label = if peer { \"Peer latency\" } else { \"Latency\" };\n ui.label(label);\n\n hover_popup(\n ui,\n (label, \"Popup\"),\n if !peer && result.result.raw_result.idle() {\n AboveOrBelow::Below\n } else {\n AboveOrBelow::Above\n },\n |ui| {\n ui.spacing_mut().item_spacing.x = 0.0;\n ui.spacing_mut().interact_size.y = 10.0;\n\n let stats = |ui: &mut Ui, name, color, latency: &LatencySummary| {\n ui.vertical(|ui| {\n ui.add_space(5.0);\n ui.horizontal(|ui| {\n ui.label(RichText::new(format!(\"{name}: \")).color(color));\n ui.label(format!(\n \"{:.01} ms\",\n latency.total.as_secs_f64() * 1000.0\n ));\n });\n ui.horizontal(|ui| {\n ui.label(format!(\n \"\\t\\t{:.01} ms \",\n latency.down.as_secs_f64() * 1000.0\n ));\n ui.label(\n RichText::new(\"down\").color(Color32::from_rgb(95, 145, 62)),\n );\n });\n ui.horizontal(|ui| {\n ui.label(format!(\n \"\\t\\t{:.01} ms \",\n latency.up.as_secs_f64() * 1000.0\n ));\n ui.label(\n RichText::new(\"up\").color(Color32::from_rgb(37, 83, 169)),\n );\n });\n });\n };\n\n if let Some(latency) = latencies.latencies.get(&Some(TestKind::Download)) {\n stats(ui, \"Download\", Color32::from_rgb(95, 145, 62), latency);\n }\n\n if let Some(latency) = latencies.latencies.get(&Some(TestKind::Upload)) {\n stats(ui, \"Upload\", Color32::from_rgb(37, 83, 169), latency);\n }\n\n if let Some(latency) =\n latencies.latencies.get(&Some(TestKind::Bidirectional))\n {\n stats(\n ui,\n \"Bidirectional\",\n Color32::from_rgb(149, 96, 153),\n latency,\n );\n }\n\n if let Some(latency) = latencies.latencies.get(&None) {\n stats(ui, \"Latency\", Color32::from_rgb(0, 0, 0), latency);\n }\n\n ui.vertical(|ui| {\n ui.add_space(5.0);\n ui.horizontal(|ui| {\n ui.label(\n RichText::new(\"Idle latency: \")\n .color(Color32::from_rgb(128, 128, 128)),\n );\n ui.label(format!(\n \"{:.02} ms\",\n result.result.raw_result.server_latency.as_secs_f64() * 1000.0\n ));\n });\n });\n\n ui.vertical(|ui| {\n ui.add_space(5.0);\n ui.horizontal(|ui| {\n ui.label(\n RichText::new(\"Latency sample interval: \")\n .color(Color32::from_rgb(128, 128, 128)),\n );\n ui.label(format!(\n \"{:.02} ms\",\n result.result.raw_result.config.ping_interval.as_secs_f64()\n * 1000.0\n ));\n });\n });\n },\n );\n });\n\n // Latency\n let mut plot = Plot::new((peer, \"ping\"))\n .legend(Legend::default().insertion_order(true))\n .y_axis_min_width(y_axis_size)\n .link_axis(link, true, false)\n .link_cursor(link, true, false)\n .include_x(0.0)\n .include_x(duration)\n .include_y(0.0)\n .include_y(data.max * 1.1)\n .label_formatter(|_, value| {\n format!(\"Latency = {:.2} ms\\nTime = {:.2} s\", value.y, value.x)\n });\n\n if reset {\n plot = plot.reset();\n }\n\n plot.show(ui, |plot_ui| {\n if result.result.raw_result.version >= 1 {\n let latency = data.up.iter().map(|v| [v.0, v.1]);\n let latency = Line::new(PlotPoints::from_iter(latency))\n .color(Color32::from_rgb(37, 83, 169))\n .name(\"Up\");\n\n plot_ui.line(latency);\n\n let latency = data.down.iter().map(|v| [v.0, v.1]);\n let latency = Line::new(PlotPoints::from_iter(latency))\n .color(Color32::from_rgb(95, 145, 62))\n .name(\"Down\");\n\n plot_ui.line(latency);\n }\n\n let latency = data.total.iter().map(|v| [v.0, v.1]);\n let latency = Line::new(PlotPoints::from_iter(latency))\n .color(Color32::from_rgb(50, 50, 50))\n .name(\"Round-trip\");\n\n plot_ui.line(latency);\n });\n });\n\n strip.cell(|ui| {\n ui.horizontal(|ui| {\n let label = if peer {\n \"Peer packet loss\"\n } else {\n \"Packet loss\"\n };\n ui.label(label);\n\n hover_popup(ui, (label, \"Popup\"), AboveOrBelow::Above, |ui| {\n ui.spacing_mut().item_spacing.x = 0.0;\n ui.spacing_mut().interact_size.y = 10.0;\n\n let stats = |ui: &mut Ui, name, color, (down, up): (f64, f64)| {\n ui.vertical(|ui| {\n ui.add_space(5.0);\n ui.horizontal(|ui| {\n ui.label(RichText::new(format!(\"{name}: \")).color(color));\n if down == 0.0 && up == 0.0 {\n ui.label(\"0%\");\n } else {\n ui.label(format!(\n \"{:.1$}% \",\n down * 100.0,\n if down == 0.0 { 0 } else { 2 }\n ));\n ui.label(\n RichText::new(\"down\").color(Color32::from_rgb(95, 145, 62)),\n );\n ui.label(format!(\n \", {:.1$}% \",\n up * 100.0,\n if up == 0.0 { 0 } else { 2 }\n ));\n ui.label(\n RichText::new(\"up\").color(Color32::from_rgb(37, 83, 169)),\n );\n }\n });\n });\n };\n\n if let Some(loss) = latencies.loss.get(&Some(TestKind::Download)) {\n stats(ui, \"Download\", Color32::from_rgb(95, 145, 62), *loss);\n }\n\n if let Some(loss) = latencies.loss.get(&Some(TestKind::Upload)) {\n stats(ui, \"Upload\", Color32::from_rgb(37, 83, 169), *loss);\n }\n\n if let Some(loss) = latencies.loss.get(&Some(TestKind::Bidirectional)) {\n stats(ui, \"Bidirectional\", Color32::from_rgb(149, 96, 153), *loss);\n }\n\n if let Some(loss) = latencies.loss.get(&None) {\n stats(ui, \"Packet loss\", Color32::from_rgb(0, 0, 0), *loss);\n }\n });\n });\n\n // Packet loss\n let mut plot = Plot::new((peer, \"loss\"))\n .legend(Legend::default())\n .show_axes([false, true])\n .show_grid(Vec2b::new(true, false))\n .y_axis_min_width(y_axis_size)\n .y_axis_formatter(|_, _| String::new())\n .link_axis(link, true, false)\n .link_cursor(link, true, false)\n .center_y_axis(true)\n .allow_zoom(false)\n .allow_boxed_zoom(false)\n .include_x(0.0)\n .include_x(duration)\n .include_y(-1.0)\n .include_y(1.0)\n .height(30.0)\n .label_formatter(|_, value| format!(\"Time = {:.2} s\", value.x));\n\n if reset {\n plot = plot.reset();\n }\n\n plot.show(ui, |plot_ui| {\n for &(loss, down_loss) in &data.loss {\n let (color, s, e) = down_loss\n .map(|down_loss| {\n if down_loss {\n (Color32::from_rgb(95, 145, 62), 1.0, 0.0)\n } else {\n (Color32::from_rgb(37, 83, 169), -1.0, 0.0)\n }\n })\n .unwrap_or((Color32::from_rgb(193, 85, 85), -1.0, 1.0));\n\n plot_ui.line(\n Line::new(PlotPoints::from_iter(\n [[loss, s], [loss, e]].iter().copied(),\n ))\n .color(color),\n );\n\n if down_loss.is_some() {\n plot_ui.line(\n Line::new(PlotPoints::from_iter(\n [[loss, s], [loss, s - s / 5.0]].iter().copied(),\n ))\n .width(3.0)\n .color(color),\n );\n }\n }\n });\n });\n }\n\n fn load_popup(&mut self, ui: &mut Ui) {\n if cfg!(not(target_os = \"android\")) {\n ui.add_space(10.0);\n\n let popup_id = ui.make_persistent_id(\"Load-Popup\");\n\n let button = ui.button(\"Open from results\");\n\n if button.clicked() {\n ui.memory_mut(|mem| {\n mem.toggle_popup(popup_id);\n if mem.is_popup_open(popup_id) {\n self.open_result = fs::read_dir(\"crusader-results\")\n .ok()\n .map(|dir| {\n dir.filter_map(|file| {\n file.ok()\n .map(|file| file.path())\n .filter(|path| path.extension() == Some(OsStr::new(\"crr\")))\n })\n .collect()\n })\n .unwrap_or_default();\n }\n });\n }\n\n egui::popup::popup_below_widget(\n ui,\n popup_id,\n &button,\n PopupCloseBehavior::CloseOnClickOutside,\n |ui| {\n ui.set_min_width(300.0);\n ui.horizontal_wrapped(|ui| {\n ui.label(\"Results available in the\");\n if ui.link(\"crusader-results\").clicked() {\n open::that(\"crusader-results\").ok();\n }\n ui.label(\"folder:\");\n });\n\n ScrollArea::vertical().show(ui, |ui| {\n ui.with_layout(Layout::top_down_justified(Align::LEFT), |ui| {\n for file in self.open_result.clone() {\n if let Some(prefix) =\n file.file_name().and_then(|stem| stem.to_str())\n {\n if ui.toggle_value(&mut false, prefix).clicked() {\n ui.memory_mut(|mem| mem.close_popup());\n RawResult::load(&file).map(|raw| {\n self.load_file(file, raw);\n });\n }\n }\n }\n });\n });\n },\n );\n }\n }\n\n fn result(&mut self, _ctx: &egui::Context, ui: &mut Ui) {\n if self.result.is_none() {\n ui.horizontal_wrapped(|ui| {\n if ui.button(\"Open\").clicked() {\n self.load_result();\n }\n self.load_popup(ui);\n });\n ui.separator();\n ui.label(\"No result.\");\n return;\n }\n\n ui.horizontal_wrapped(|ui| {\n if ui.button(\"Open\").clicked() {\n self.load_result();\n }\n\n if ui.button(\"Save\").clicked() {\n match self.raw_saver.as_ref() {\n Some(saver) => {\n saver(&self.result.as_ref().unwrap().result.raw_result);\n }\n None => {\n #[cfg(not(target_os = \"android\"))]\n {\n FileDialog::new()\n .add_filter(\"Crusader Raw Result\", &[\"crr\"])\n .add_filter(\"All files\", &[\"*\"])\n .set_file_name(&format!(\"{}.crr\", timed(\"test\")))\n .save_file()\n .map(|file| {\n if self\n .result\n .as_ref()\n .unwrap()\n .result\n .raw_result\n .save(&file)\n .is_ok()\n {\n self.raw_result_saved = Some(file);\n }\n });\n }\n }\n }\n }\n\n self.load_popup(ui);\n\n if cfg!(not(target_os = \"android\")) {\n let popup_id = ui.make_persistent_id(\"Save-Popup\");\n\n let button = ui.button(\"Save to results\");\n\n if button.clicked() {\n ui.memory_mut(|mem| {\n mem.toggle_popup(popup_id);\n });\n }\n\n egui::popup::popup_below_widget(\n ui,\n popup_id,\n &button,\n PopupCloseBehavior::CloseOnClickOutside,\n |ui| {\n ui.set_min_width(250.0);\n ui.horizontal_wrapped(|ui| {\n ui.label(\"This saves both the data and plot in the\");\n if ui.link(\"crusader-results\").clicked() {\n open::that(\"crusader-results\").ok();\n }\n ui.label(\"folder.\");\n });\n ui.horizontal(|ui| {\n ui.label(\"Name: \");\n let mut click = ui\n .add(\n TextEdit::singleline(&mut self.result_name)\n .desired_width(175.0),\n )\n .lost_focus()\n && ui.input(|i| i.key_pressed(egui::Key::Enter));\n click |= ui.button(\"Save\").clicked();\n if click {\n let name = timed(&self.result_name);\n self.raw_result_saved = test::save_raw(\n &self.result.as_ref().unwrap().result.raw_result,\n &name,\n Path::new(\"crusader-results\"),\n )\n .ok();\n plot::save_graph(\n &PlotConfig::default(),\n &self.result.as_ref().unwrap().result,\n &name,\n Path::new(\"crusader-results\"),\n )\n .ok();\n ui.memory_mut(|mem| {\n mem.close_popup();\n });\n }\n });\n },\n );\n }\n\n ui.add_space(10.0);\n\n if ui.button(\"Export plot\").clicked() {\n match self.plot_saver.as_ref() {\n Some(saver) => {\n saver(&self.result.as_ref().unwrap().result);\n }\n None => {\n #[cfg(not(target_os = \"android\"))]\n {\n let name = self\n .raw_result_saved\n .as_ref()\n .and_then(|file| {\n file.file_stem()\n .unwrap_or_default()\n .to_str()\n .map(|s| s.to_owned())\n })\n .unwrap_or(timed(\"test\"));\n\n let mut dialog = FileDialog::new()\n .add_filter(\"Portable Network Graphics\", &[\"png\"])\n .add_filter(\"All files\", &[\"*\"])\n .set_file_name(&format!(\"{}.png\", name));\n\n if let Some(file) = self.raw_result_saved.as_ref() {\n if let Some(parent) = file.parent() {\n dialog = dialog.set_directory(parent);\n }\n }\n\n dialog.save_file().map(|file| {\n if plot::save_graph_to_path(\n &file,\n &PlotConfig::default(),\n &self.result.as_ref().unwrap().result,\n )\n .is_ok()\n {\n file.file_name()\n .unwrap_or_default()\n .to_str()\n .map(|s| s.to_owned());\n }\n });\n }\n }\n }\n }\n });\n ui.separator();\n\n self.raw_result_saved\n .as_ref()\n .and_then(|file| {\n file.file_name()\n .unwrap_or_default()\n .to_str()\n .map(|s| s.to_owned())\n })\n .map(|file| {\n ui.label(format!(\"Saved as: {file}\"));\n ui.separator();\n });\n\n let result = self.result.as_ref().unwrap();\n\n if result.result.raw_result.server_overload {\n ui.label(\"Warning: Server overload detected during test. Result should be discarded.\");\n ui.separator();\n }\n\n if result.result.raw_result.load_termination_timeout {\n ui.label(\"Warning: Load termination timed out. There may be residual untracked traffic in the background.\");\n ui.separator();\n }\n\n let packet_loss_size = 75.0;\n\n let result = self.result.as_ref().unwrap();\n\n let link = ui.id().with(\"result-link\");\n\n let mut strip = StripBuilder::new(ui);\n\n if result.result.raw_result.streams() > 0 {\n strip = strip.size(Size::remainder());\n }\n\n for _ in 0..(1 + result.peer_latency.is_some() as u8) {\n strip = strip\n .size(Size::remainder())\n .size(Size::exact(packet_loss_size));\n }\n\n strip.vertical(|mut strip| {\n let reset = mem::take(&mut self.result_plot_reset);\n\n let result = self.result.as_ref().unwrap();\n\n let y_axis_size = 30.0;\n\n let duration = result.result.duration.as_secs_f64() * 1.1;\n\n if result.result.raw_result.streams() > 0 {\n strip.cell(|ui| {\n ui.horizontal(|ui| {\n ui.label(\"Throughput\");\n\n hover_popup(ui, \"Throughput-Popup\", AboveOrBelow::Below, |ui| {\n ui.spacing_mut().item_spacing.x = 0.0;\n ui.spacing_mut().interact_size.y = 10.0;\n\n if let Some(throughput) = result\n .result\n .throughputs\n .get(&(TestKind::Download, TestKind::Download))\n {\n ui.vertical(|ui| {\n ui.add_space(5.0);\n ui.horizontal(|ui| {\n ui.label(\n RichText::new(\"Download: \")\n .color(Color32::from_rgb(95, 145, 62)),\n );\n ui.label(format!(\"{:.02} Mbps\", throughput));\n });\n });\n }\n\n if let Some(throughput) = result\n .result\n .throughputs\n .get(&(TestKind::Upload, TestKind::Upload))\n {\n ui.vertical(|ui| {\n ui.add_space(5.0);\n ui.horizontal(|ui| {\n ui.label(\n RichText::new(\"Upload: \")\n .color(Color32::from_rgb(37, 83, 169)),\n );\n ui.label(format!(\"{:.02} Mbps\", throughput));\n });\n });\n }\n\n if let Some(throughput) = result\n .result\n .throughputs\n .get(&(TestKind::Bidirectional, TestKind::Bidirectional))\n {\n ui.vertical(|ui| {\n ui.add_space(5.0);\n ui.horizontal(|ui| {\n ui.label(\n RichText::new(\"Bidirectional: \")\n .color(Color32::from_rgb(149, 96, 153)),\n );\n ui.label(format!(\"{:.02} Mbps \", throughput));\n });\n if let Some(down) = result\n .result\n .throughputs\n .get(&(TestKind::Bidirectional, TestKind::Download))\n {\n if let Some(up) = result\n .result\n .throughputs\n .get(&(TestKind::Bidirectional, TestKind::Upload))\n {\n ui.horizontal(|ui| {\n ui.label(format!(\"\\t\\t{:.02} Mbps \", down));\n ui.label(\n RichText::new(\"down\")\n .color(Color32::from_rgb(95, 145, 62)),\n );\n });\n ui.horizontal(|ui| {\n ui.label(format!(\"\\t\\t{:.02} Mbps \", up));\n ui.label(\n RichText::new(\"up\")\n .color(Color32::from_rgb(37, 83, 169)),\n );\n });\n }\n }\n });\n }\n\n ui.vertical(|ui| {\n ui.add_space(5.0);\n ui.horizontal(|ui| {\n ui.label(\n RichText::new(\"Streams: \")\n .color(Color32::from_rgb(128, 128, 128)),\n );\n ui.label(format!(\"{}\", result.result.raw_result.streams()));\n });\n });\n\n ui.vertical(|ui| {\n ui.add_space(5.0);\n ui.horizontal(|ui| {\n ui.label(\n RichText::new(\"Stream Stagger: \")\n .color(Color32::from_rgb(128, 128, 128)),\n );\n ui.label(format!(\n \"{:.02} seconds\",\n result.result.raw_result.config.stagger.as_secs_f64()\n ));\n });\n });\n\n ui.vertical(|ui| {\n ui.add_space(5.0);\n ui.horizontal(|ui| {\n ui.label(\n RichText::new(\"Throughput sample interval: \")\n .color(Color32::from_rgb(128, 128, 128)),\n );\n ui.label(format!(\n \"{:.02} ms\",\n result\n .result\n .raw_result\n .config\n .bandwidth_interval\n .as_secs_f64()\n * 1000.0\n ));\n });\n });\n });\n });\n\n // Throughput\n let mut plot = Plot::new(\"result\")\n .legend(\n Legend::default()\n .color_conflict_handling(ColorConflictHandling::PickFirst)\n .insertion_order(true),\n )\n .y_axis_min_width(y_axis_size)\n .link_axis(link, true, false)\n .link_cursor(link, true, false)\n .include_x(0.0)\n .include_x(duration)\n .include_y(0.0)\n .include_y(result.throughput_max * 1.1)\n .height(ui.available_height())\n .label_formatter(|_, value| {\n format!(\"Throughput = {:.2} Mbps\\nTime = {:.2} s\", value.y, value.x)\n });\n\n if reset {\n plot = plot.reset();\n }\n\n plot.show(ui, |plot_ui| {\n let width = 1.0;\n if let Some(data) = result.download.as_ref() {\n let download = data.iter().map(|v| [v.0, v.1]);\n let download = Line::new(PlotPoints::from_iter(download))\n .color(Color32::from_rgb(95, 145, 62))\n .width(width)\n .name(\"Download\");\n\n plot_ui.line(download);\n }\n if let Some(data) = result.upload.as_ref() {\n let upload = data.iter().map(|v| [v.0, v.1]);\n let upload = Line::new(PlotPoints::from_iter(upload))\n .color(Color32::from_rgb(37, 83, 169))\n .width(width)\n .name(\"Upload\");\n\n plot_ui.line(upload);\n }\n if let Some(data) = result.both_download.as_ref() {\n let download = data.iter().map(|v| [v.0, v.1]);\n let download = Line::new(PlotPoints::from_iter(download))\n .color(Color32::from_rgb(95, 145, 62))\n .width(width)\n .name(\"Download\");\n\n plot_ui.line(download);\n }\n if let Some(data) = result.both_upload.as_ref() {\n let upload = data.iter().map(|v| [v.0, v.1]);\n let upload = Line::new(PlotPoints::from_iter(upload))\n .color(Color32::from_rgb(37, 83, 169))\n .width(width)\n .name(\"Upload\");\n\n plot_ui.line(upload);\n }\n if let Some(data) = result.both.as_ref() {\n let both = data.iter().map(|v| [v.0, v.1]);\n let both = Line::new(PlotPoints::from_iter(both))\n .color(Color32::from_rgb(149, 96, 153))\n .width(width)\n .name(\"Aggregate\");\n\n plot_ui.line(both);\n }\n\n // Average lines\n let darken = 0.5;\n let alpha = 0.35;\n\n if let Some(data) = result.download_avg.as_ref() {\n let download = data.iter().map(|v| [v.0, v.1]);\n let download = Line::new(PlotPoints::from_iter(download))\n .color(\n Color32::from_rgb(95, 145, 62)\n .lerp_to_gamma(Color32::BLACK, darken)\n .gamma_multiply(alpha),\n )\n .allow_hover(false)\n .width(3.5)\n .name(\"Download\");\n\n plot_ui.line(download);\n }\n if let Some(data) = result.upload_avg.as_ref() {\n let upload = data.iter().map(|v| [v.0, v.1]);\n let upload = Line::new(PlotPoints::from_iter(upload))\n .color(\n Color32::from_rgb(37, 83, 169)\n .lerp_to_gamma(Color32::BLACK, darken)\n .gamma_multiply(alpha),\n )\n .allow_hover(false)\n .width(3.5)\n .name(\"Upload\");\n\n plot_ui.line(upload);\n }\n if let Some(data) = result.both_download_avg.as_ref() {\n let download = data.iter().map(|v| [v.0, v.1]);\n let download = Line::new(PlotPoints::from_iter(download))\n .color(\n Color32::from_rgb(95, 145, 62)\n .lerp_to_gamma(Color32::BLACK, darken)\n .gamma_multiply(alpha),\n )\n .allow_hover(false)\n .width(3.5)\n .name(\"Download\");\n\n plot_ui.line(download);\n }\n if let Some(data) = result.both_upload_avg.as_ref() {\n let upload = data.iter().map(|v| [v.0, v.1]);\n let upload = Line::new(PlotPoints::from_iter(upload))\n .color(\n Color32::from_rgb(37, 83, 169)\n .lerp_to_gamma(Color32::BLACK, darken)\n .gamma_multiply(alpha),\n )\n .allow_hover(false)\n .width(3.5)\n .name(\"Upload\");\n\n plot_ui.line(upload);\n }\n if let Some(data) = result.both_avg.as_ref() {\n let both = data.iter().map(|v| [v.0, v.1]);\n let both = Line::new(PlotPoints::from_iter(both))\n .color(\n Color32::from_rgb(149, 96, 153)\n .lerp_to_gamma(Color32::BLACK, darken)\n .gamma_multiply(alpha),\n )\n .allow_hover(false)\n .width(3.5)\n .name(\"Aggregate\");\n\n plot_ui.line(both);\n }\n });\n })\n }\n\n self.latency_and_loss(&mut strip, link, reset, false, y_axis_size);\n\n let result = self.result.as_ref().unwrap();\n\n if result.peer_latency.is_some() {\n self.latency_and_loss(&mut strip, link, reset, true, y_axis_size);\n }\n });\n }\n\n fn server(&mut self, ctx: &egui::Context, ui: &mut Ui) {\n match self.server_state {\n ServerState::Stopped(ref error) => {\n let (server_button, peer_button) = ui\n .horizontal_wrapped(|ui| (ui.button(\"Start server\"), ui.button(\"Start peer\")))\n .inner;\n\n if let Some(error) = error {\n ui.separator();\n ui.label(format!(\"Unable to start server: {}\", error));\n }\n\n if server_button.clicked() || peer_button.clicked() {\n let ctx = ctx.clone();\n let ctx_ = ctx.clone();\n let ctx__ = ctx.clone();\n let (tx, rx) = mpsc::unbounded_channel();\n let (signal_started, started) = oneshot::channel();\n let (signal_done, done) = oneshot::channel();\n\n let stop = serve::serve_until(\n protocol::PORT,\n peer_button.clicked(),\n Box::new(move |msg| {\n tx.send(with_time(msg)).ok();\n ctx.request_repaint();\n }),\n Box::new(move |result| {\n signal_started.send(result).ok();\n ctx_.request_repaint();\n }),\n Box::new(move || {\n signal_done.send(()).ok();\n ctx__.request_repaint();\n }),\n )\n .ok();\n\n if let Some(stop) = stop {\n self.server = Some(Server {\n done: Some(done),\n stop: Some(stop),\n started,\n rx,\n msgs: Vec::new(),\n });\n self.server_state = ServerState::Starting;\n }\n };\n ui.separator();\n ui.label(format!(\n \"A server listens on TCP and UDP port {}. It allows clients \\\n to run tests and measure latency against it. It can also act as a latency peer for tests connecting to another server.\",\n protocol::PORT\n ));\n }\n ServerState::Running => {\n let server = self.server.as_mut().unwrap();\n let button = ui.button(\"Stop server\");\n\n ui.separator();\n\n loop {\n match server.rx.try_recv() {\n Ok(msg) => {\n println!(\"[Server] {msg}\");\n server.msgs.push(msg);\n }\n Err(TryRecvError::Disconnected) => panic!(),\n Err(TryRecvError::Empty) => break,\n }\n }\n\n ScrollArea::vertical()\n .stick_to_bottom(true)\n .auto_shrink([false; 2])\n .show_rows(\n ui,\n ui.text_style_height(&TextStyle::Body),\n server.msgs.len(),\n |ui, rows| {\n for row in rows {\n ui.label(&server.msgs[row]);\n }\n },\n );\n\n if button.clicked() {\n mem::take(&mut server.stop).unwrap().send(()).unwrap();\n self.server_state = ServerState::Stopping;\n };\n }\n ServerState::Starting => {\n let server = self.server.as_mut().unwrap();\n\n if let Ok(result) = server.started.try_recv() {\n if let Err(error) = result {\n self.server_state = ServerState::Stopped(Some(error));\n self.server = None;\n } else {\n self.server_state = ServerState::Running;\n }\n }\n\n ui.add_enabled_ui(false, |ui| {\n let _ = ui.button(\"Starting..\");\n });\n }\n ServerState::Stopping => {\n if let Ok(()) = self\n .server\n .as_mut()\n .unwrap()\n .done\n .as_mut()\n .unwrap()\n .try_recv()\n {\n self.server_state = ServerState::Stopped(None);\n self.server = None;\n }\n\n ui.add_enabled_ui(false, |ui| {\n let _ = ui.button(\"Stopping..\");\n });\n }\n }\n }\n\n fn remote(&mut self, ctx: &egui::Context, ui: &mut Ui) {\n match self.remote_state {\n ServerState::Stopped(ref error) => {\n let button = ui\n .vertical(|ui| {\n let button = ui.button(\"Start server\");\n if let Some(error) = error {\n ui.separator();\n ui.label(format!(\"Unable to start server: {}\", error));\n }\n button\n })\n .inner;\n\n if button.clicked() {\n let ctx = ctx.clone();\n let ctx_ = ctx.clone();\n let ctx__ = ctx.clone();\n let (tx, rx) = mpsc::unbounded_channel();\n let (signal_started, started) = oneshot::channel();\n let (signal_done, done) = oneshot::channel();\n\n let stop = remote::serve_until(\n protocol::PORT + 1,\n Box::new(move |msg| {\n tx.send(with_time(msg)).ok();\n ctx.request_repaint();\n }),\n Box::new(move |result| {\n signal_started.send(result).ok();\n ctx_.request_repaint();\n }),\n Box::new(move || {\n signal_done.send(()).ok();\n ctx__.request_repaint();\n }),\n )\n .ok();\n\n if let Some(stop) = stop {\n self.remote_server = Some(Server {\n done: Some(done),\n stop: Some(stop),\n started,\n rx,\n msgs: Vec::new(),\n });\n self.remote_state = ServerState::Starting;\n }\n };\n ui.separator();\n ui.label(format!(\n \"A remote server runs a web server on TCP port {}. It allows web clients to remotely start \\\n tests against other servers.\",\n protocol::PORT + 1\n ));\n }\n ServerState::Running => {\n let remote_server = self.remote_server.as_mut().unwrap();\n let button = ui.button(\"Stop server\");\n\n ui.separator();\n\n loop {\n match remote_server.rx.try_recv() {\n Ok(msg) => {\n println!(\"[Remote] {msg}\");\n remote_server.msgs.push(msg);\n }\n Err(TryRecvError::Disconnected) => panic!(),\n Err(TryRecvError::Empty) => break,\n }\n }\n\n ScrollArea::vertical()\n .stick_to_bottom(true)\n .auto_shrink([false; 2])\n .show_rows(\n ui,\n ui.text_style_height(&TextStyle::Body),\n remote_server.msgs.len(),\n |ui, rows| {\n for row in rows {\n ui.label(&remote_server.msgs[row]);\n }\n },\n );\n\n if button.clicked() {\n mem::take(&mut remote_server.stop)\n .unwrap()\n .send(())\n .unwrap();\n self.remote_state = ServerState::Stopping;\n };\n }\n ServerState::Starting => {\n let remote_server = self.remote_server.as_mut().unwrap();\n\n if let Ok(result) = remote_server.started.try_recv() {\n if let Err(error) = result {\n self.remote_state = ServerState::Stopped(Some(error));\n self.remote_server = None;\n } else {\n self.remote_state = ServerState::Running;\n }\n }\n\n ui.add_enabled_ui(false, |ui| {\n let _ = ui.button(\"Starting..\");\n });\n }\n ServerState::Stopping => {\n if let Ok(()) = self\n .remote_server\n .as_mut()\n .unwrap()\n .done\n .as_mut()\n .unwrap()\n .try_recv()\n {\n self.remote_state = ServerState::Stopped(None);\n self.remote_server = None;\n }\n\n ui.add_enabled_ui(false, |ui| {\n let _ = ui.button(\"Stopping..\");\n });\n }\n }\n }\n\n fn start_monitor(&mut self, ctx: &egui::Context) {\n self.save_settings();\n\n let (signal_done, done) = oneshot::channel();\n\n let ctx_ = ctx.clone();\n let data = Arc::new(latency::Data::new(\n ((self.settings.latency_monitor.history * 1000.0)\n / self.settings.latency_monitor.latency_sample_interval as f64)\n .round() as usize,\n Arc::new(move || {\n ctx_.request_repaint();\n }),\n ));\n\n let ctx_ = ctx.clone();\n let abort = latency::test_callback(\n latency::Config {\n port: protocol::PORT,\n ping_interval: Duration::from_millis(\n self.settings.latency_monitor.latency_sample_interval,\n ),\n },\n (!self.settings.latency_monitor.server.trim().is_empty())\n .then_some(&self.settings.latency_monitor.server),\n data.clone(),\n Box::new(move |result| {\n signal_done.send(result).map_err(|_| ()).unwrap();\n ctx_.request_repaint();\n }),\n );\n\n self.latency = Some(Latency {\n done: Some(done),\n abort: Some(abort),\n });\n self.latency_state = ClientState::Running;\n self.latency_data = data;\n self.latency_error = None;\n self.latency_plot_reset = true;\n }\n\n fn monitor(&mut self, ctx: &egui::Context, ui: &mut Ui) {\n let running = self.latency_state != ClientState::Stopped;\n\n if !running {\n ui.horizontal_wrapped(|ui| {\n ui.label(\"Server address:\");\n let response = ui.add(\n TextEdit::singleline(&mut self.settings.latency_monitor.server)\n .hint_text(\"(Locate local server)\"),\n );\n let enter = response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));\n\n if ui.button(\"Start test\").clicked() || enter {\n self.start_monitor(ctx)\n }\n });\n }\n\n if running {\n ui.horizontal(|ui| {\n match self.latency_state {\n ClientState::Running => {\n if ui.button(\"Stop test\").clicked()\n || ui.input(|i| i.key_pressed(egui::Key::Space))\n {\n let latency = self.latency.as_mut().unwrap();\n mem::take(&mut latency.abort).unwrap().send(()).unwrap();\n self.latency_state = ClientState::Stopping;\n }\n }\n ClientState::Stopping => {\n ui.add_enabled_ui(false, |ui| {\n let _ = ui.button(\"Stopping test..\");\n });\n }\n ClientState::Stopped => {}\n }\n\n let state = match *self.latency_data.state.lock() {\n latency::State::Connecting => \"Connecting..\".to_owned(),\n latency::State::Monitoring { ref at } => format!(\"Connected to {at}\"),\n latency::State::Syncing => \"Synchronizing clocks..\".to_owned(),\n };\n ui.add(Label::new(state).wrap_mode(TextWrapMode::Truncate));\n\n let latency = self.latency.as_mut().unwrap();\n\n if let Ok(result) = latency.done.as_mut().unwrap().try_recv() {\n self.latency_error = match result {\n Some(Ok(())) => None,\n Some(Err(error)) => Some(error),\n None => Some(\"Aborted...\".to_owned()),\n };\n self.latency_stop = self.latency_data.start.elapsed();\n self.latency = None;\n self.latency_state = ClientState::Stopped;\n }\n });\n }\n\n ui.separator();\n\n ui.add_enabled_ui(!running, |ui| {\n Grid::new(\"latency-settings-compact\").show(ui, |ui| {\n ui.label(\"History: \");\n ui.add(\n egui::DragValue::new(&mut self.settings.latency_monitor.history)\n .range(0..=1000)\n .speed(0.05),\n );\n ui.label(\"seconds\");\n ui.end_row();\n ui.label(\"Latency sample interval:\");\n ui.add(\n egui::DragValue::new(\n &mut self.settings.latency_monitor.latency_sample_interval,\n )\n .range(1..=1000)\n .speed(0.05),\n );\n ui.label(\"milliseconds\");\n });\n });\n\n ui.separator();\n\n if let Some(error) = self.latency_error.as_ref() {\n ui.label(format!(\"Error: {}\", error));\n ui.separator();\n }\n\n self.latency_data(ctx, ui);\n }\n\n fn latency_data(&mut self, ctx: &egui::Context, ui: &mut Ui) {\n ui.vertical(|ui| {\n let packet_loss_size = 80.0;\n let height = ui.available_height();\n\n let duration = self.settings.latency_monitor.history;\n\n let points = self.latency_data.points.blocking_lock().clone();\n\n let now = if self.latency_state == ClientState::Running {\n ctx.request_repaint();\n self.latency_data.start.elapsed()\n } else {\n self.latency_stop\n }\n .as_secs_f64();\n\n let reset = mem::take(&mut self.latency_plot_reset);\n\n let link = ui.id().with(\"latency-link\");\n\n let y_axis_size = 30.0;\n\n // Latency\n let mut plot = Plot::new(\"latency-ping\")\n .legend(Legend::default().insertion_order(true))\n .link_axis(link, true, false)\n .link_cursor(link, true, false)\n .include_x(-duration)\n .include_x(0.0)\n .include_x(duration * 0.20)\n .include_y(0.0)\n .include_y(10.0)\n .height(height - packet_loss_size)\n .y_axis_min_width(y_axis_size)\n .auto_bounds(Vec2b::new(false, true))\n .label_formatter(|_, value| {\n format!(\"Latency = {:.2} ms\\nTime = {:.2} s\", value.y, value.x)\n });\n\n if reset {\n plot = plot.reset();\n }\n\n ui.label(\"Latency\");\n plot.show(ui, |plot_ui| {\n let latency = points.iter().filter_map(|point| {\n point.up.map(|up| {\n let up = if let Some(total) = point.total {\n up.min(total)\n } else {\n up\n };\n [point.sent.as_secs_f64() - now, 1000.0 * up.as_secs_f64()]\n })\n });\n let latency = Line::new(PlotPoints::from_iter(latency))\n .color(Color32::from_rgb(37, 83, 169))\n .name(\"Up\");\n\n plot_ui.line(latency);\n\n let latency = points.iter().filter_map(|point| {\n point\n .up\n .and_then(|up| point.total.map(|total| total.saturating_sub(up)))\n .map(|down| [point.sent.as_secs_f64() - now, 1000.0 * down.as_secs_f64()])\n });\n let latency = Line::new(PlotPoints::from_iter(latency))\n .color(Color32::from_rgb(95, 145, 62))\n .name(\"Down\");\n\n plot_ui.line(latency);\n\n let latency = points.iter().filter_map(|point| {\n point\n .total\n .map(|total| [point.sent.as_secs_f64() - now, 1000.0 * total.as_secs_f64()])\n });\n let latency = Line::new(PlotPoints::from_iter(latency))\n .color(Color32::from_rgb(50, 50, 50))\n .name(\"Round-trip\");\n\n plot_ui.line(latency);\n });\n\n // Packet loss\n let mut plot = Plot::new(\"latency-loss\")\n .legend(Legend::default())\n .show_axes([false, true])\n .show_grid(Vec2b::new(true, false))\n .y_axis_min_width(y_axis_size)\n .y_axis_formatter(|_, _| String::new())\n .link_axis(link, true, false)\n .link_cursor(link, true, false)\n .center_y_axis(true)\n .allow_zoom(false)\n .allow_boxed_zoom(false)\n .include_x(-duration)\n .include_x(0.0)\n .include_x(duration * 0.15)\n .include_y(-1.0)\n .include_y(1.0)\n .height(30.0)\n .label_formatter(|_, value| format!(\"Time = {:.2} s\", value.x));\n\n if reset {\n plot = plot.reset();\n }\n\n ui.label(\"Packet loss\");\n plot.show(ui, |plot_ui| {\n let loss = points\n .iter()\n .filter(|point| !point.pending && point.total.is_none());\n\n for point in loss {\n let loss = point.sent.as_secs_f64() - now;\n\n let (color, s, e) = if point.up.is_some() {\n (Color32::from_rgb(95, 145, 62), 1.0, 0.0)\n } else {\n (Color32::from_rgb(37, 83, 169), -1.0, 0.0)\n };\n\n plot_ui.line(\n Line::new(PlotPoints::from_iter(\n [[loss, s], [loss, e]].iter().copied(),\n ))\n .color(color),\n );\n\n plot_ui.line(\n Line::new(PlotPoints::from_iter(\n [[loss, s], [loss, s - s / 5.0]].iter().copied(),\n ))\n .width(3.0)\n .color(color),\n );\n }\n });\n });\n }\n\n pub fn show(&mut self, ctx: &egui::Context, ui: &mut Ui) {\n ctx.input(|input| {\n if let Some(file) = input\n .raw\n .dropped_files\n .first()\n .and_then(|file| file.path.as_deref())\n {\n RawResult::load(file).map(|raw| {\n self.load_file(file.to_owned(), raw);\n self.tab = Tab::Result;\n });\n }\n });\n\n let compact = ui.available_width() < 660.0;\n ui.horizontal_wrapped(|ui| {\n ui.selectable_value(&mut self.tab, Tab::Client, \"Client\");\n ui.selectable_value(&mut self.tab, Tab::Server, \"Server\");\n ui.selectable_value(&mut self.tab, Tab::Remote, \"Remote\");\n ui.selectable_value(&mut self.tab, Tab::Monitor, \"Monitor\");\n ui.selectable_value(&mut self.tab, Tab::Result, \"Result\");\n });\n ui.separator();\n\n match self.tab {\n Tab::Client => self.client(ctx, ui, compact),\n Tab::Server => self.server(ctx, ui),\n Tab::Remote => self.remote(ctx, ui),\n Tab::Monitor => self.monitor(ctx, ui),\n Tab::Result => self.result(ctx, ui),\n }\n }\n}\n" }, { "path": "src/crusader-lib/Cargo.toml", "content": "[package]\nname = \"crusader-lib\"\nversion = \"0.1.0\"\nedition = \"2021\"\nbuild = \"build.rs\"\n\n# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n\n[features]\nserver = []\nclient = [\"dep:plotters\", \"dep:axum\", \"dep:image\", \"dep:snap\", \"dep:serde_json\"]\n\n[dependencies]\nplotters = { version = \"0.3.6\", default-features = false, optional = true, features = [\n \"ab_glyph\",\n \"bitmap_backend\",\n \"line_series\",\n \"bitmap_encoder\",\n] }\nchrono = \"0.4.19\"\nbincode = \"1.3.3\"\nserde = { version = \"1.0.137\", features = [\"derive\"] }\nserde_json = { version = \"1.0.122\", optional = true }\nrand = \"0.8.5\"\nparking_lot = \"0.12.0\"\nhostname = \"0.4.0\"\ntokio = { version = \"1.18.2\", features = [\"full\"] }\ntokio-util = { version = \"0.7.2\", features = [\"codec\"] }\nfutures = \"0.3.21\"\nbytes = \"1.1.0\"\nsnap = { version = \"1.0.5\", optional = true }\nrmp-serde = \"1.1.0\"\nsocket2 = \"0.4.6\"\nnix = { version = \"0.29.0\", features = [\"net\"] }\nlibc = \"0.2\"\nanyhow = \"1.0.86\"\naxum = { version = \"0.7.5\", features = [\n \"ws\",\n \"tokio\",\n \"http1\",\n], default-features = false, optional = true }\nimage = { version = \"0.24.9\", optional = true }\n\n[target.\"cfg(target_os = \\\"windows\\\")\".dependencies]\nipconfig = { version = \"=0.3.2\", default-features = false }\nwidestring = \"=1.1.0\"\n" }, { "path": "src/crusader-lib/UFL.txt", "content": "-------------------------------\r\nUBUNTU FONT LICENCE Version 1.0\r\n-------------------------------\r\n\r\nPREAMBLE\r\nThis licence allows the licensed fonts to be used, studied, modified and\r\nredistributed freely. The fonts, including any derivative works, can be\r\nbundled, embedded, and redistributed provided the terms of this licence\r\nare met. The fonts and derivatives, however, cannot be released under\r\nany other licence. The requirement for fonts to remain under this\r\nlicence does not require any document created using the fonts or their\r\nderivatives to be published under this licence, as long as the primary\r\npurpose of the document is not to be a vehicle for the distribution of\r\nthe fonts.\r\n\r\nDEFINITIONS\r\n\"Font Software\" refers to the set of files released by the Copyright\r\nHolder(s) under this licence and clearly marked as such. This may\r\ninclude source files, build scripts and documentation.\r\n\r\n\"Original Version\" refers to the collection of Font Software components\r\nas received under this licence.\r\n\r\n\"Modified Version\" refers to any derivative made by adding to, deleting,\r\nor substituting -- in part or in whole -- any of the components of the\r\nOriginal Version, by changing formats or by porting the Font Software to\r\na new environment.\r\n\r\n\"Copyright Holder(s)\" refers to all individuals and companies who have a\r\ncopyright ownership of the Font Software.\r\n\r\n\"Substantially Changed\" refers to Modified Versions which can be easily\r\nidentified as dissimilar to the Font Software by users of the Font\r\nSoftware comparing the Original Version with the Modified Version.\r\n\r\nTo \"Propagate\" a work means to do anything with it that, without\r\npermission, would make you directly or secondarily liable for\r\ninfringement under applicable copyright law, except executing it on a\r\ncomputer or modifying a private copy. Propagation includes copying,\r\ndistribution (with or without modification and with or without charging\r\na redistribution fee), making available to the public, and in some\r\ncountries other activities as well.\r\n\r\nPERMISSION & CONDITIONS\r\nThis licence does not grant any rights under trademark law and all such\r\nrights are reserved.\r\n\r\nPermission is hereby granted, free of charge, to any person obtaining a\r\ncopy of the Font Software, to propagate the Font Software, subject to\r\nthe below conditions:\r\n\r\n1) Each copy of the Font Software must contain the above copyright\r\nnotice and this licence. These can be included either as stand-alone\r\ntext files, human-readable headers or in the appropriate machine-\r\nreadable metadata fields within text or binary files as long as those\r\nfields can be easily viewed by the user.\r\n\r\n2) The font name complies with the following:\r\n(a) The Original Version must retain its name, unmodified.\r\n(b) Modified Versions which are Substantially Changed must be renamed to\r\navoid use of the name of the Original Version or similar names entirely.\r\n(c) Modified Versions which are not Substantially Changed must be\r\nrenamed to both (i) retain the name of the Original Version and (ii) add\r\nadditional naming elements to distinguish the Modified Version from the\r\nOriginal Version. The name of such Modified Versions must be the name of\r\nthe Original Version, with \"derivative X\" where X represents the name of\r\nthe new work, appended to that name.\r\n\r\n3) The name(s) of the Copyright Holder(s) and any contributor to the\r\nFont Software shall not be used to promote, endorse or advertise any\r\nModified Version, except (i) as required by this licence, (ii) to\r\nacknowledge the contribution(s) of the Copyright Holder(s) or (iii) with\r\ntheir explicit written permission.\r\n\r\n4) The Font Software, modified or unmodified, in part or in whole, must\r\nbe distributed entirely under this licence, and must not be distributed\r\nunder any other licence. The requirement for fonts to remain under this\r\nlicence does not affect any document created using the Font Software,\r\nexcept any version of the Font Software extracted from a document\r\ncreated using the Font Software may only be distributed under this\r\nlicence.\r\n\r\nTERMINATION\r\nThis licence becomes null and void if any of the above conditions are\r\nnot met.\r\n\r\nDISCLAIMER\r\nTHE FONT SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\r\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF\r\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF\r\nCOPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE\r\nCOPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\r\nINCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL\r\nDAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\r\nFROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER\r\nDEALINGS IN THE FONT SOFTWARE.\r\n" }, { "path": "src/crusader-lib/assets/vue.js", "content": "/**\n* vue v3.4.35\n* (c) 2018-present Yuxi (Evan) You and Vue contributors\n* @license MIT\n**/\n/*! #__NO_SIDE_EFFECTS__ */\n// @__NO_SIDE_EFFECTS__\nfunction makeMap(str, expectsLowerCase) {\n const set = new Set(str.split(\",\"));\n return expectsLowerCase ? (val) => set.has(val.toLowerCase()) : (val) => set.has(val);\n}\n\nconst EMPTY_OBJ = Object.freeze({}) ;\nconst EMPTY_ARR = Object.freeze([]) ;\nconst NOOP = () => {\n};\nconst NO = () => false;\nconst isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter\n(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);\nconst isModelListener = (key) => key.startsWith(\"onUpdate:\");\nconst extend = Object.assign;\nconst remove = (arr, el) => {\n const i = arr.indexOf(el);\n if (i > -1) {\n arr.splice(i, 1);\n }\n};\nconst hasOwnProperty$1 = Object.prototype.hasOwnProperty;\nconst hasOwn = (val, key) => hasOwnProperty$1.call(val, key);\nconst isArray = Array.isArray;\nconst isMap = (val) => toTypeString(val) === \"[object Map]\";\nconst isSet = (val) => toTypeString(val) === \"[object Set]\";\nconst isDate = (val) => toTypeString(val) === \"[object Date]\";\nconst isRegExp = (val) => toTypeString(val) === \"[object RegExp]\";\nconst isFunction = (val) => typeof val === \"function\";\nconst isString = (val) => typeof val === \"string\";\nconst isSymbol = (val) => typeof val === \"symbol\";\nconst isObject = (val) => val !== null && typeof val === \"object\";\nconst isPromise = (val) => {\n return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);\n};\nconst objectToString = Object.prototype.toString;\nconst toTypeString = (value) => objectToString.call(value);\nconst toRawType = (value) => {\n return toTypeString(value).slice(8, -1);\n};\nconst isPlainObject = (val) => toTypeString(val) === \"[object Object]\";\nconst isIntegerKey = (key) => isString(key) && key !== \"NaN\" && key[0] !== \"-\" && \"\" + parseInt(key, 10) === key;\nconst isReservedProp = /* @__PURE__ */ makeMap(\n // the leading comma is intentional so empty string \"\" is also included\n \",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted\"\n);\nconst isBuiltInDirective = /* @__PURE__ */ makeMap(\n \"bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo\"\n);\nconst cacheStringFunction = (fn) => {\n const cache = /* @__PURE__ */ Object.create(null);\n return (str) => {\n const hit = cache[str];\n return hit || (cache[str] = fn(str));\n };\n};\nconst camelizeRE = /-(\\w)/g;\nconst camelize = cacheStringFunction((str) => {\n return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : \"\");\n});\nconst hyphenateRE = /\\B([A-Z])/g;\nconst hyphenate = cacheStringFunction(\n (str) => str.replace(hyphenateRE, \"-$1\").toLowerCase()\n);\nconst capitalize = cacheStringFunction((str) => {\n return str.charAt(0).toUpperCase() + str.slice(1);\n});\nconst toHandlerKey = cacheStringFunction((str) => {\n const s = str ? `on${capitalize(str)}` : ``;\n return s;\n});\nconst hasChanged = (value, oldValue) => !Object.is(value, oldValue);\nconst invokeArrayFns = (fns, ...arg) => {\n for (let i = 0; i < fns.length; i++) {\n fns[i](...arg);\n }\n};\nconst def = (obj, key, value, writable = false) => {\n Object.defineProperty(obj, key, {\n configurable: true,\n enumerable: false,\n writable,\n value\n });\n};\nconst looseToNumber = (val) => {\n const n = parseFloat(val);\n return isNaN(n) ? val : n;\n};\nconst toNumber = (val) => {\n const n = isString(val) ? Number(val) : NaN;\n return isNaN(n) ? val : n;\n};\nlet _globalThis;\nconst getGlobalThis = () => {\n return _globalThis || (_globalThis = typeof globalThis !== \"undefined\" ? globalThis : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : typeof global !== \"undefined\" ? global : {});\n};\n\nconst PatchFlagNames = {\n [1]: `TEXT`,\n [2]: `CLASS`,\n [4]: `STYLE`,\n [8]: `PROPS`,\n [16]: `FULL_PROPS`,\n [32]: `NEED_HYDRATION`,\n [64]: `STABLE_FRAGMENT`,\n [128]: `KEYED_FRAGMENT`,\n [256]: `UNKEYED_FRAGMENT`,\n [512]: `NEED_PATCH`,\n [1024]: `DYNAMIC_SLOTS`,\n [2048]: `DEV_ROOT_FRAGMENT`,\n [-1]: `HOISTED`,\n [-2]: `BAIL`\n};\n\nconst slotFlagsText = {\n [1]: \"STABLE\",\n [2]: \"DYNAMIC\",\n [3]: \"FORWARDED\"\n};\n\nconst GLOBALS_ALLOWED = \"Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error\";\nconst isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);\n\nconst range = 2;\nfunction generateCodeFrame(source, start = 0, end = source.length) {\n start = Math.max(0, Math.min(start, source.length));\n end = Math.max(0, Math.min(end, source.length));\n if (start > end) return \"\";\n let lines = source.split(/(\\r?\\n)/);\n const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);\n lines = lines.filter((_, idx) => idx % 2 === 0);\n let count = 0;\n const res = [];\n for (let i = 0; i < lines.length; i++) {\n count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);\n if (count >= start) {\n for (let j = i - range; j <= i + range || end > count; j++) {\n if (j < 0 || j >= lines.length) continue;\n const line = j + 1;\n res.push(\n `${line}${\" \".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`\n );\n const lineLength = lines[j].length;\n const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;\n if (j === i) {\n const pad = start - (count - (lineLength + newLineSeqLength));\n const length = Math.max(\n 1,\n end > count ? lineLength - pad : end - start\n );\n res.push(` | ` + \" \".repeat(pad) + \"^\".repeat(length));\n } else if (j > i) {\n if (end > count) {\n const length = Math.max(Math.min(end - count, lineLength), 1);\n res.push(` | ` + \"^\".repeat(length));\n }\n count += lineLength + newLineSeqLength;\n }\n }\n break;\n }\n }\n return res.join(\"\\n\");\n}\n\nfunction normalizeStyle(value) {\n if (isArray(value)) {\n const res = {};\n for (let i = 0; i < value.length; i++) {\n const item = value[i];\n const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);\n if (normalized) {\n for (const key in normalized) {\n res[key] = normalized[key];\n }\n }\n }\n return res;\n } else if (isString(value) || isObject(value)) {\n return value;\n }\n}\nconst listDelimiterRE = /;(?![^(]*\\))/g;\nconst propertyDelimiterRE = /:([^]+)/;\nconst styleCommentRE = /\\/\\*[^]*?\\*\\//g;\nfunction parseStringStyle(cssText) {\n const ret = {};\n cssText.replace(styleCommentRE, \"\").split(listDelimiterRE).forEach((item) => {\n if (item) {\n const tmp = item.split(propertyDelimiterRE);\n tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\n }\n });\n return ret;\n}\nfunction stringifyStyle(styles) {\n let ret = \"\";\n if (!styles || isString(styles)) {\n return ret;\n }\n for (const key in styles) {\n const value = styles[key];\n if (isString(value) || typeof value === \"number\") {\n const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);\n ret += `${normalizedKey}:${value};`;\n }\n }\n return ret;\n}\nfunction normalizeClass(value) {\n let res = \"\";\n if (isString(value)) {\n res = value;\n } else if (isArray(value)) {\n for (let i = 0; i < value.length; i++) {\n const normalized = normalizeClass(value[i]);\n if (normalized) {\n res += normalized + \" \";\n }\n }\n } else if (isObject(value)) {\n for (const name in value) {\n if (value[name]) {\n res += name + \" \";\n }\n }\n }\n return res.trim();\n}\nfunction normalizeProps(props) {\n if (!props) return null;\n let { class: klass, style } = props;\n if (klass && !isString(klass)) {\n props.class = normalizeClass(klass);\n }\n if (style) {\n props.style = normalizeStyle(style);\n }\n return props;\n}\n\nconst HTML_TAGS = \"html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot\";\nconst SVG_TAGS = \"svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view\";\nconst MATH_TAGS = \"annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics\";\nconst VOID_TAGS = \"area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr\";\nconst isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);\nconst isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);\nconst isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);\nconst isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);\n\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\nconst isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);\nconst isBooleanAttr = /* @__PURE__ */ makeMap(\n specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`\n);\nfunction includeBooleanAttr(value) {\n return !!value || value === \"\";\n}\nconst isKnownHtmlAttr = /* @__PURE__ */ makeMap(\n `accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`\n);\nconst isKnownSvgAttr = /* @__PURE__ */ makeMap(\n `xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`\n);\nfunction isRenderableAttrValue(value) {\n if (value == null) {\n return false;\n }\n const type = typeof value;\n return type === \"string\" || type === \"number\" || type === \"boolean\";\n}\n\nfunction looseCompareArrays(a, b) {\n if (a.length !== b.length) return false;\n let equal = true;\n for (let i = 0; equal && i < a.length; i++) {\n equal = looseEqual(a[i], b[i]);\n }\n return equal;\n}\nfunction looseEqual(a, b) {\n if (a === b) return true;\n let aValidType = isDate(a);\n let bValidType = isDate(b);\n if (aValidType || bValidType) {\n return aValidType && bValidType ? a.getTime() === b.getTime() : false;\n }\n aValidType = isSymbol(a);\n bValidType = isSymbol(b);\n if (aValidType || bValidType) {\n return a === b;\n }\n aValidType = isArray(a);\n bValidType = isArray(b);\n if (aValidType || bValidType) {\n return aValidType && bValidType ? looseCompareArrays(a, b) : false;\n }\n aValidType = isObject(a);\n bValidType = isObject(b);\n if (aValidType || bValidType) {\n if (!aValidType || !bValidType) {\n return false;\n }\n const aKeysCount = Object.keys(a).length;\n const bKeysCount = Object.keys(b).length;\n if (aKeysCount !== bKeysCount) {\n return false;\n }\n for (const key in a) {\n const aHasKey = a.hasOwnProperty(key);\n const bHasKey = b.hasOwnProperty(key);\n if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {\n return false;\n }\n }\n }\n return String(a) === String(b);\n}\nfunction looseIndexOf(arr, val) {\n return arr.findIndex((item) => looseEqual(item, val));\n}\n\nconst isRef$1 = (val) => {\n return !!(val && val.__v_isRef === true);\n};\nconst toDisplayString = (val) => {\n return isString(val) ? val : val == null ? \"\" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);\n};\nconst replacer = (_key, val) => {\n if (isRef$1(val)) {\n return replacer(_key, val.value);\n } else if (isMap(val)) {\n return {\n [`Map(${val.size})`]: [...val.entries()].reduce(\n (entries, [key, val2], i) => {\n entries[stringifySymbol(key, i) + \" =>\"] = val2;\n return entries;\n },\n {}\n )\n };\n } else if (isSet(val)) {\n return {\n [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))\n };\n } else if (isSymbol(val)) {\n return stringifySymbol(val);\n } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {\n return String(val);\n }\n return val;\n};\nconst stringifySymbol = (v, i = \"\") => {\n var _a;\n return (\n // Symbol.description in es2019+ so we need to cast here to pass\n // the lib: es2016 check\n isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v\n );\n};\n\nfunction warn$2(msg, ...args) {\n console.warn(`[Vue warn] ${msg}`, ...args);\n}\n\nlet activeEffectScope;\nclass EffectScope {\n constructor(detached = false) {\n this.detached = detached;\n /**\n * @internal\n */\n this._active = true;\n /**\n * @internal\n */\n this.effects = [];\n /**\n * @internal\n */\n this.cleanups = [];\n this.parent = activeEffectScope;\n if (!detached && activeEffectScope) {\n this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(\n this\n ) - 1;\n }\n }\n get active() {\n return this._active;\n }\n run(fn) {\n if (this._active) {\n const currentEffectScope = activeEffectScope;\n try {\n activeEffectScope = this;\n return fn();\n } finally {\n activeEffectScope = currentEffectScope;\n }\n } else {\n warn$2(`cannot run an inactive effect scope.`);\n }\n }\n /**\n * This should only be called on non-detached scopes\n * @internal\n */\n on() {\n activeEffectScope = this;\n }\n /**\n * This should only be called on non-detached scopes\n * @internal\n */\n off() {\n activeEffectScope = this.parent;\n }\n stop(fromParent) {\n if (this._active) {\n let i, l;\n for (i = 0, l = this.effects.length; i < l; i++) {\n this.effects[i].stop();\n }\n for (i = 0, l = this.cleanups.length; i < l; i++) {\n this.cleanups[i]();\n }\n if (this.scopes) {\n for (i = 0, l = this.scopes.length; i < l; i++) {\n this.scopes[i].stop(true);\n }\n }\n if (!this.detached && this.parent && !fromParent) {\n const last = this.parent.scopes.pop();\n if (last && last !== this) {\n this.parent.scopes[this.index] = last;\n last.index = this.index;\n }\n }\n this.parent = void 0;\n this._active = false;\n }\n }\n}\nfunction effectScope(detached) {\n return new EffectScope(detached);\n}\nfunction recordEffectScope(effect, scope = activeEffectScope) {\n if (scope && scope.active) {\n scope.effects.push(effect);\n }\n}\nfunction getCurrentScope() {\n return activeEffectScope;\n}\nfunction onScopeDispose(fn) {\n if (activeEffectScope) {\n activeEffectScope.cleanups.push(fn);\n } else {\n warn$2(\n `onScopeDispose() is called when there is no active effect scope to be associated with.`\n );\n }\n}\n\nlet activeEffect;\nclass ReactiveEffect {\n constructor(fn, trigger, scheduler, scope) {\n this.fn = fn;\n this.trigger = trigger;\n this.scheduler = scheduler;\n this.active = true;\n this.deps = [];\n /**\n * @internal\n */\n this._dirtyLevel = 4;\n /**\n * @internal\n */\n this._trackId = 0;\n /**\n * @internal\n */\n this._runnings = 0;\n /**\n * @internal\n */\n this._shouldSchedule = false;\n /**\n * @internal\n */\n this._depsLength = 0;\n recordEffectScope(this, scope);\n }\n get dirty() {\n if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {\n this._dirtyLevel = 1;\n pauseTracking();\n for (let i = 0; i < this._depsLength; i++) {\n const dep = this.deps[i];\n if (dep.computed) {\n triggerComputed(dep.computed);\n if (this._dirtyLevel >= 4) {\n break;\n }\n }\n }\n if (this._dirtyLevel === 1) {\n this._dirtyLevel = 0;\n }\n resetTracking();\n }\n return this._dirtyLevel >= 4;\n }\n set dirty(v) {\n this._dirtyLevel = v ? 4 : 0;\n }\n run() {\n this._dirtyLevel = 0;\n if (!this.active) {\n return this.fn();\n }\n let lastShouldTrack = shouldTrack;\n let lastEffect = activeEffect;\n try {\n shouldTrack = true;\n activeEffect = this;\n this._runnings++;\n preCleanupEffect(this);\n return this.fn();\n } finally {\n postCleanupEffect(this);\n this._runnings--;\n activeEffect = lastEffect;\n shouldTrack = lastShouldTrack;\n }\n }\n stop() {\n if (this.active) {\n preCleanupEffect(this);\n postCleanupEffect(this);\n this.onStop && this.onStop();\n this.active = false;\n }\n }\n}\nfunction triggerComputed(computed) {\n return computed.value;\n}\nfunction preCleanupEffect(effect2) {\n effect2._trackId++;\n effect2._depsLength = 0;\n}\nfunction postCleanupEffect(effect2) {\n if (effect2.deps.length > effect2._depsLength) {\n for (let i = effect2._depsLength; i < effect2.deps.length; i++) {\n cleanupDepEffect(effect2.deps[i], effect2);\n }\n effect2.deps.length = effect2._depsLength;\n }\n}\nfunction cleanupDepEffect(dep, effect2) {\n const trackId = dep.get(effect2);\n if (trackId !== void 0 && effect2._trackId !== trackId) {\n dep.delete(effect2);\n if (dep.size === 0) {\n dep.cleanup();\n }\n }\n}\nfunction effect(fn, options) {\n if (fn.effect instanceof ReactiveEffect) {\n fn = fn.effect.fn;\n }\n const _effect = new ReactiveEffect(fn, NOOP, () => {\n if (_effect.dirty) {\n _effect.run();\n }\n });\n if (options) {\n extend(_effect, options);\n if (options.scope) recordEffectScope(_effect, options.scope);\n }\n if (!options || !options.lazy) {\n _effect.run();\n }\n const runner = _effect.run.bind(_effect);\n runner.effect = _effect;\n return runner;\n}\nfunction stop(runner) {\n runner.effect.stop();\n}\nlet shouldTrack = true;\nlet pauseScheduleStack = 0;\nconst trackStack = [];\nfunction pauseTracking() {\n trackStack.push(shouldTrack);\n shouldTrack = false;\n}\nfunction resetTracking() {\n const last = trackStack.pop();\n shouldTrack = last === void 0 ? true : last;\n}\nfunction pauseScheduling() {\n pauseScheduleStack++;\n}\nfunction resetScheduling() {\n pauseScheduleStack--;\n while (!pauseScheduleStack && queueEffectSchedulers.length) {\n queueEffectSchedulers.shift()();\n }\n}\nfunction trackEffect(effect2, dep, debuggerEventExtraInfo) {\n var _a;\n if (dep.get(effect2) !== effect2._trackId) {\n dep.set(effect2, effect2._trackId);\n const oldDep = effect2.deps[effect2._depsLength];\n if (oldDep !== dep) {\n if (oldDep) {\n cleanupDepEffect(oldDep, effect2);\n }\n effect2.deps[effect2._depsLength++] = dep;\n } else {\n effect2._depsLength++;\n }\n {\n (_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));\n }\n }\n}\nconst queueEffectSchedulers = [];\nfunction triggerEffects(dep, dirtyLevel, debuggerEventExtraInfo) {\n var _a;\n pauseScheduling();\n for (const effect2 of dep.keys()) {\n let tracking;\n if (effect2._dirtyLevel < dirtyLevel && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {\n effect2._shouldSchedule || (effect2._shouldSchedule = effect2._dirtyLevel === 0);\n effect2._dirtyLevel = dirtyLevel;\n }\n if (effect2._shouldSchedule && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {\n {\n (_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));\n }\n effect2.trigger();\n if ((!effect2._runnings || effect2.allowRecurse) && effect2._dirtyLevel !== 2) {\n effect2._shouldSchedule = false;\n if (effect2.scheduler) {\n queueEffectSchedulers.push(effect2.scheduler);\n }\n }\n }\n }\n resetScheduling();\n}\n\nconst createDep = (cleanup, computed) => {\n const dep = /* @__PURE__ */ new Map();\n dep.cleanup = cleanup;\n dep.computed = computed;\n return dep;\n};\n\nconst targetMap = /* @__PURE__ */ new WeakMap();\nconst ITERATE_KEY = Symbol(\"iterate\" );\nconst MAP_KEY_ITERATE_KEY = Symbol(\"Map key iterate\" );\nfunction track(target, type, key) {\n if (shouldTrack && activeEffect) {\n let depsMap = targetMap.get(target);\n if (!depsMap) {\n targetMap.set(target, depsMap = /* @__PURE__ */ new Map());\n }\n let dep = depsMap.get(key);\n if (!dep) {\n depsMap.set(key, dep = createDep(() => depsMap.delete(key)));\n }\n trackEffect(\n activeEffect,\n dep,\n {\n target,\n type,\n key\n } \n );\n }\n}\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\n const depsMap = targetMap.get(target);\n if (!depsMap) {\n return;\n }\n let deps = [];\n if (type === \"clear\") {\n deps = [...depsMap.values()];\n } else if (key === \"length\" && isArray(target)) {\n const newLength = Number(newValue);\n depsMap.forEach((dep, key2) => {\n if (key2 === \"length\" || !isSymbol(key2) && key2 >= newLength) {\n deps.push(dep);\n }\n });\n } else {\n if (key !== void 0) {\n deps.push(depsMap.get(key));\n }\n switch (type) {\n case \"add\":\n if (!isArray(target)) {\n deps.push(depsMap.get(ITERATE_KEY));\n if (isMap(target)) {\n deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));\n }\n } else if (isIntegerKey(key)) {\n deps.push(depsMap.get(\"length\"));\n }\n break;\n case \"delete\":\n if (!isArray(target)) {\n deps.push(depsMap.get(ITERATE_KEY));\n if (isMap(target)) {\n deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));\n }\n }\n break;\n case \"set\":\n if (isMap(target)) {\n deps.push(depsMap.get(ITERATE_KEY));\n }\n break;\n }\n }\n pauseScheduling();\n for (const dep of deps) {\n if (dep) {\n triggerEffects(\n dep,\n 4,\n {\n target,\n type,\n key,\n newValue,\n oldValue,\n oldTarget\n } \n );\n }\n }\n resetScheduling();\n}\nfunction getDepFromReactive(object, key) {\n const depsMap = targetMap.get(object);\n return depsMap && depsMap.get(key);\n}\n\nconst isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);\nconst builtInSymbols = new Set(\n /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== \"arguments\" && key !== \"caller\").map((key) => Symbol[key]).filter(isSymbol)\n);\nconst arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();\nfunction createArrayInstrumentations() {\n const instrumentations = {};\n [\"includes\", \"indexOf\", \"lastIndexOf\"].forEach((key) => {\n instrumentations[key] = function(...args) {\n const arr = toRaw(this);\n for (let i = 0, l = this.length; i < l; i++) {\n track(arr, \"get\", i + \"\");\n }\n const res = arr[key](...args);\n if (res === -1 || res === false) {\n return arr[key](...args.map(toRaw));\n } else {\n return res;\n }\n };\n });\n [\"push\", \"pop\", \"shift\", \"unshift\", \"splice\"].forEach((key) => {\n instrumentations[key] = function(...args) {\n pauseTracking();\n pauseScheduling();\n const res = toRaw(this)[key].apply(this, args);\n resetScheduling();\n resetTracking();\n return res;\n };\n });\n return instrumentations;\n}\nfunction hasOwnProperty(key) {\n if (!isSymbol(key)) key = String(key);\n const obj = toRaw(this);\n track(obj, \"has\", key);\n return obj.hasOwnProperty(key);\n}\nclass BaseReactiveHandler {\n constructor(_isReadonly = false, _isShallow = false) {\n this._isReadonly = _isReadonly;\n this._isShallow = _isShallow;\n }\n get(target, key, receiver) {\n const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;\n if (key === \"__v_isReactive\") {\n return !isReadonly2;\n } else if (key === \"__v_isReadonly\") {\n return isReadonly2;\n } else if (key === \"__v_isShallow\") {\n return isShallow2;\n } else if (key === \"__v_raw\") {\n if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype\n // this means the reciever is a user proxy of the reactive proxy\n Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {\n return target;\n }\n return;\n }\n const targetIsArray = isArray(target);\n if (!isReadonly2) {\n if (targetIsArray && hasOwn(arrayInstrumentations, key)) {\n return Reflect.get(arrayInstrumentations, key, receiver);\n }\n if (key === \"hasOwnProperty\") {\n return hasOwnProperty;\n }\n }\n const res = Reflect.get(target, key, receiver);\n if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {\n return res;\n }\n if (!isReadonly2) {\n track(target, \"get\", key);\n }\n if (isShallow2) {\n return res;\n }\n if (isRef(res)) {\n return targetIsArray && isIntegerKey(key) ? res : res.value;\n }\n if (isObject(res)) {\n return isReadonly2 ? readonly(res) : reactive(res);\n }\n return res;\n }\n}\nclass MutableReactiveHandler extends BaseReactiveHandler {\n constructor(isShallow2 = false) {\n super(false, isShallow2);\n }\n set(target, key, value, receiver) {\n let oldValue = target[key];\n if (!this._isShallow) {\n const isOldValueReadonly = isReadonly(oldValue);\n if (!isShallow(value) && !isReadonly(value)) {\n oldValue = toRaw(oldValue);\n value = toRaw(value);\n }\n if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\n if (isOldValueReadonly) {\n return false;\n } else {\n oldValue.value = value;\n return true;\n }\n }\n }\n const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);\n const result = Reflect.set(target, key, value, receiver);\n if (target === toRaw(receiver)) {\n if (!hadKey) {\n trigger(target, \"add\", key, value);\n } else if (hasChanged(value, oldValue)) {\n trigger(target, \"set\", key, value, oldValue);\n }\n }\n return result;\n }\n deleteProperty(target, key) {\n const hadKey = hasOwn(target, key);\n const oldValue = target[key];\n const result = Reflect.deleteProperty(target, key);\n if (result && hadKey) {\n trigger(target, \"delete\", key, void 0, oldValue);\n }\n return result;\n }\n has(target, key) {\n const result = Reflect.has(target, key);\n if (!isSymbol(key) || !builtInSymbols.has(key)) {\n track(target, \"has\", key);\n }\n return result;\n }\n ownKeys(target) {\n track(\n target,\n \"iterate\",\n isArray(target) ? \"length\" : ITERATE_KEY\n );\n return Reflect.ownKeys(target);\n }\n}\nclass ReadonlyReactiveHandler extends BaseReactiveHandler {\n constructor(isShallow2 = false) {\n super(true, isShallow2);\n }\n set(target, key) {\n {\n warn$2(\n `Set operation on key \"${String(key)}\" failed: target is readonly.`,\n target\n );\n }\n return true;\n }\n deleteProperty(target, key) {\n {\n warn$2(\n `Delete operation on key \"${String(key)}\" failed: target is readonly.`,\n target\n );\n }\n return true;\n }\n}\nconst mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();\nconst readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();\nconst shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(\n true\n);\nconst shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);\n\nconst toShallow = (value) => value;\nconst getProto = (v) => Reflect.getPrototypeOf(v);\nfunction get(target, key, isReadonly2 = false, isShallow2 = false) {\n target = target[\"__v_raw\"];\n const rawTarget = toRaw(target);\n const rawKey = toRaw(key);\n if (!isReadonly2) {\n if (hasChanged(key, rawKey)) {\n track(rawTarget, \"get\", key);\n }\n track(rawTarget, \"get\", rawKey);\n }\n const { has: has2 } = getProto(rawTarget);\n const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;\n if (has2.call(rawTarget, key)) {\n return wrap(target.get(key));\n } else if (has2.call(rawTarget, rawKey)) {\n return wrap(target.get(rawKey));\n } else if (target !== rawTarget) {\n target.get(key);\n }\n}\nfunction has(key, isReadonly2 = false) {\n const target = this[\"__v_raw\"];\n const rawTarget = toRaw(target);\n const rawKey = toRaw(key);\n if (!isReadonly2) {\n if (hasChanged(key, rawKey)) {\n track(rawTarget, \"has\", key);\n }\n track(rawTarget, \"has\", rawKey);\n }\n return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);\n}\nfunction size(target, isReadonly2 = false) {\n target = target[\"__v_raw\"];\n !isReadonly2 && track(toRaw(target), \"iterate\", ITERATE_KEY);\n return Reflect.get(target, \"size\", target);\n}\nfunction add(value, _isShallow = false) {\n if (!_isShallow && !isShallow(value) && !isReadonly(value)) {\n value = toRaw(value);\n }\n const target = toRaw(this);\n const proto = getProto(target);\n const hadKey = proto.has.call(target, value);\n if (!hadKey) {\n target.add(value);\n trigger(target, \"add\", value, value);\n }\n return this;\n}\nfunction set(key, value, _isShallow = false) {\n if (!_isShallow && !isShallow(value) && !isReadonly(value)) {\n value = toRaw(value);\n }\n const target = toRaw(this);\n const { has: has2, get: get2 } = getProto(target);\n let hadKey = has2.call(target, key);\n if (!hadKey) {\n key = toRaw(key);\n hadKey = has2.call(target, key);\n } else {\n checkIdentityKeys(target, has2, key);\n }\n const oldValue = get2.call(target, key);\n target.set(key, value);\n if (!hadKey) {\n trigger(target, \"add\", key, value);\n } else if (hasChanged(value, oldValue)) {\n trigger(target, \"set\", key, value, oldValue);\n }\n return this;\n}\nfunction deleteEntry(key) {\n const target = toRaw(this);\n const { has: has2, get: get2 } = getProto(target);\n let hadKey = has2.call(target, key);\n if (!hadKey) {\n key = toRaw(key);\n hadKey = has2.call(target, key);\n } else {\n checkIdentityKeys(target, has2, key);\n }\n const oldValue = get2 ? get2.call(target, key) : void 0;\n const result = target.delete(key);\n if (hadKey) {\n trigger(target, \"delete\", key, void 0, oldValue);\n }\n return result;\n}\nfunction clear() {\n const target = toRaw(this);\n const hadItems = target.size !== 0;\n const oldTarget = isMap(target) ? new Map(target) : new Set(target) ;\n const result = target.clear();\n if (hadItems) {\n trigger(target, \"clear\", void 0, void 0, oldTarget);\n }\n return result;\n}\nfunction createForEach(isReadonly2, isShallow2) {\n return function forEach(callback, thisArg) {\n const observed = this;\n const target = observed[\"__v_raw\"];\n const rawTarget = toRaw(target);\n const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;\n !isReadonly2 && track(rawTarget, \"iterate\", ITERATE_KEY);\n return target.forEach((value, key) => {\n return callback.call(thisArg, wrap(value), wrap(key), observed);\n });\n };\n}\nfunction createIterableMethod(method, isReadonly2, isShallow2) {\n return function(...args) {\n const target = this[\"__v_raw\"];\n const rawTarget = toRaw(target);\n const targetIsMap = isMap(rawTarget);\n const isPair = method === \"entries\" || method === Symbol.iterator && targetIsMap;\n const isKeyOnly = method === \"keys\" && targetIsMap;\n const innerIterator = target[method](...args);\n const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;\n !isReadonly2 && track(\n rawTarget,\n \"iterate\",\n isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY\n );\n return {\n // iterator protocol\n next() {\n const { value, done } = innerIterator.next();\n return done ? { value, done } : {\n value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\n done\n };\n },\n // iterable protocol\n [Symbol.iterator]() {\n return this;\n }\n };\n };\n}\nfunction createReadonlyMethod(type) {\n return function(...args) {\n {\n const key = args[0] ? `on key \"${args[0]}\" ` : ``;\n warn$2(\n `${capitalize(type)} operation ${key}failed: target is readonly.`,\n toRaw(this)\n );\n }\n return type === \"delete\" ? false : type === \"clear\" ? void 0 : this;\n };\n}\nfunction createInstrumentations() {\n const mutableInstrumentations2 = {\n get(key) {\n return get(this, key);\n },\n get size() {\n return size(this);\n },\n has,\n add,\n set,\n delete: deleteEntry,\n clear,\n forEach: createForEach(false, false)\n };\n const shallowInstrumentations2 = {\n get(key) {\n return get(this, key, false, true);\n },\n get size() {\n return size(this);\n },\n has,\n add(value) {\n return add.call(this, value, true);\n },\n set(key, value) {\n return set.call(this, key, value, true);\n },\n delete: deleteEntry,\n clear,\n forEach: createForEach(false, true)\n };\n const readonlyInstrumentations2 = {\n get(key) {\n return get(this, key, true);\n },\n get size() {\n return size(this, true);\n },\n has(key) {\n return has.call(this, key, true);\n },\n add: createReadonlyMethod(\"add\"),\n set: createReadonlyMethod(\"set\"),\n delete: createReadonlyMethod(\"delete\"),\n clear: createReadonlyMethod(\"clear\"),\n forEach: createForEach(true, false)\n };\n const shallowReadonlyInstrumentations2 = {\n get(key) {\n return get(this, key, true, true);\n },\n get size() {\n return size(this, true);\n },\n has(key) {\n return has.call(this, key, true);\n },\n add: createReadonlyMethod(\"add\"),\n set: createReadonlyMethod(\"set\"),\n delete: createReadonlyMethod(\"delete\"),\n clear: createReadonlyMethod(\"clear\"),\n forEach: createForEach(true, true)\n };\n const iteratorMethods = [\n \"keys\",\n \"values\",\n \"entries\",\n Symbol.iterator\n ];\n iteratorMethods.forEach((method) => {\n mutableInstrumentations2[method] = createIterableMethod(method, false, false);\n readonlyInstrumentations2[method] = createIterableMethod(method, true, false);\n shallowInstrumentations2[method] = createIterableMethod(method, false, true);\n shallowReadonlyInstrumentations2[method] = createIterableMethod(\n method,\n true,\n true\n );\n });\n return [\n mutableInstrumentations2,\n readonlyInstrumentations2,\n shallowInstrumentations2,\n shallowReadonlyInstrumentations2\n ];\n}\nconst [\n mutableInstrumentations,\n readonlyInstrumentations,\n shallowInstrumentations,\n shallowReadonlyInstrumentations\n] = /* @__PURE__ */ createInstrumentations();\nfunction createInstrumentationGetter(isReadonly2, shallow) {\n const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;\n return (target, key, receiver) => {\n if (key === \"__v_isReactive\") {\n return !isReadonly2;\n } else if (key === \"__v_isReadonly\") {\n return isReadonly2;\n } else if (key === \"__v_raw\") {\n return target;\n }\n return Reflect.get(\n hasOwn(instrumentations, key) && key in target ? instrumentations : target,\n key,\n receiver\n );\n };\n}\nconst mutableCollectionHandlers = {\n get: /* @__PURE__ */ createInstrumentationGetter(false, false)\n};\nconst shallowCollectionHandlers = {\n get: /* @__PURE__ */ createInstrumentationGetter(false, true)\n};\nconst readonlyCollectionHandlers = {\n get: /* @__PURE__ */ createInstrumentationGetter(true, false)\n};\nconst shallowReadonlyCollectionHandlers = {\n get: /* @__PURE__ */ createInstrumentationGetter(true, true)\n};\nfunction checkIdentityKeys(target, has2, key) {\n const rawKey = toRaw(key);\n if (rawKey !== key && has2.call(target, rawKey)) {\n const type = toRawType(target);\n warn$2(\n `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`\n );\n }\n}\n\nconst reactiveMap = /* @__PURE__ */ new WeakMap();\nconst shallowReactiveMap = /* @__PURE__ */ new WeakMap();\nconst readonlyMap = /* @__PURE__ */ new WeakMap();\nconst shallowReadonlyMap = /* @__PURE__ */ new WeakMap();\nfunction targetTypeMap(rawType) {\n switch (rawType) {\n case \"Object\":\n case \"Array\":\n return 1 /* COMMON */;\n case \"Map\":\n case \"Set\":\n case \"WeakMap\":\n case \"WeakSet\":\n return 2 /* COLLECTION */;\n default:\n return 0 /* INVALID */;\n }\n}\nfunction getTargetType(value) {\n return value[\"__v_skip\"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(toRawType(value));\n}\nfunction reactive(target) {\n if (isReadonly(target)) {\n return target;\n }\n return createReactiveObject(\n target,\n false,\n mutableHandlers,\n mutableCollectionHandlers,\n reactiveMap\n );\n}\nfunction shallowReactive(target) {\n return createReactiveObject(\n target,\n false,\n shallowReactiveHandlers,\n shallowCollectionHandlers,\n shallowReactiveMap\n );\n}\nfunction readonly(target) {\n return createReactiveObject(\n target,\n true,\n readonlyHandlers,\n readonlyCollectionHandlers,\n readonlyMap\n );\n}\nfunction shallowReadonly(target) {\n return createReactiveObject(\n target,\n true,\n shallowReadonlyHandlers,\n shallowReadonlyCollectionHandlers,\n shallowReadonlyMap\n );\n}\nfunction createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {\n if (!isObject(target)) {\n {\n warn$2(\n `value cannot be made ${isReadonly2 ? \"readonly\" : \"reactive\"}: ${String(\n target\n )}`\n );\n }\n return target;\n }\n if (target[\"__v_raw\"] && !(isReadonly2 && target[\"__v_isReactive\"])) {\n return target;\n }\n const existingProxy = proxyMap.get(target);\n if (existingProxy) {\n return existingProxy;\n }\n const targetType = getTargetType(target);\n if (targetType === 0 /* INVALID */) {\n return target;\n }\n const proxy = new Proxy(\n target,\n targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers\n );\n proxyMap.set(target, proxy);\n return proxy;\n}\nfunction isReactive(value) {\n if (isReadonly(value)) {\n return isReactive(value[\"__v_raw\"]);\n }\n return !!(value && value[\"__v_isReactive\"]);\n}\nfunction isReadonly(value) {\n return !!(value && value[\"__v_isReadonly\"]);\n}\nfunction isShallow(value) {\n return !!(value && value[\"__v_isShallow\"]);\n}\nfunction isProxy(value) {\n return value ? !!value[\"__v_raw\"] : false;\n}\nfunction toRaw(observed) {\n const raw = observed && observed[\"__v_raw\"];\n return raw ? toRaw(raw) : observed;\n}\nfunction markRaw(value) {\n if (Object.isExtensible(value)) {\n def(value, \"__v_skip\", true);\n }\n return value;\n}\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\n\nconst COMPUTED_SIDE_EFFECT_WARN = `Computed is still dirty after getter evaluation, likely because a computed is mutating its own dependency in its getter. State mutations in computed getters should be avoided. Check the docs for more details: https://vuejs.org/guide/essentials/computed.html#getters-should-be-side-effect-free`;\nclass ComputedRefImpl {\n constructor(getter, _setter, isReadonly, isSSR) {\n this.getter = getter;\n this._setter = _setter;\n this.dep = void 0;\n this.__v_isRef = true;\n this[\"__v_isReadonly\"] = false;\n this.effect = new ReactiveEffect(\n () => getter(this._value),\n () => triggerRefValue(\n this,\n this.effect._dirtyLevel === 2 ? 2 : 3\n )\n );\n this.effect.computed = this;\n this.effect.active = this._cacheable = !isSSR;\n this[\"__v_isReadonly\"] = isReadonly;\n }\n get value() {\n const self = toRaw(this);\n if ((!self._cacheable || self.effect.dirty) && hasChanged(self._value, self._value = self.effect.run())) {\n triggerRefValue(self, 4);\n }\n trackRefValue(self);\n if (self.effect._dirtyLevel >= 2) {\n if (this._warnRecursive) {\n warn$2(COMPUTED_SIDE_EFFECT_WARN, `\n\ngetter: `, this.getter);\n }\n triggerRefValue(self, 2);\n }\n return self._value;\n }\n set value(newValue) {\n this._setter(newValue);\n }\n // #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x\n get _dirty() {\n return this.effect.dirty;\n }\n set _dirty(v) {\n this.effect.dirty = v;\n }\n // #endregion\n}\nfunction computed$1(getterOrOptions, debugOptions, isSSR = false) {\n let getter;\n let setter;\n const onlyGetter = isFunction(getterOrOptions);\n if (onlyGetter) {\n getter = getterOrOptions;\n setter = () => {\n warn$2(\"Write operation failed: computed value is readonly\");\n } ;\n } else {\n getter = getterOrOptions.get;\n setter = getterOrOptions.set;\n }\n const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);\n if (debugOptions && !isSSR) {\n cRef.effect.onTrack = debugOptions.onTrack;\n cRef.effect.onTrigger = debugOptions.onTrigger;\n }\n return cRef;\n}\n\nfunction trackRefValue(ref2) {\n var _a;\n if (shouldTrack && activeEffect) {\n ref2 = toRaw(ref2);\n trackEffect(\n activeEffect,\n (_a = ref2.dep) != null ? _a : ref2.dep = createDep(\n () => ref2.dep = void 0,\n ref2 instanceof ComputedRefImpl ? ref2 : void 0\n ),\n {\n target: ref2,\n type: \"get\",\n key: \"value\"\n } \n );\n }\n}\nfunction triggerRefValue(ref2, dirtyLevel = 4, newVal, oldVal) {\n ref2 = toRaw(ref2);\n const dep = ref2.dep;\n if (dep) {\n triggerEffects(\n dep,\n dirtyLevel,\n {\n target: ref2,\n type: \"set\",\n key: \"value\",\n newValue: newVal,\n oldValue: oldVal\n } \n );\n }\n}\nfunction isRef(r) {\n return !!(r && r.__v_isRef === true);\n}\nfunction ref(value) {\n return createRef(value, false);\n}\nfunction shallowRef(value) {\n return createRef(value, true);\n}\nfunction createRef(rawValue, shallow) {\n if (isRef(rawValue)) {\n return rawValue;\n }\n return new RefImpl(rawValue, shallow);\n}\nclass RefImpl {\n constructor(value, __v_isShallow) {\n this.__v_isShallow = __v_isShallow;\n this.dep = void 0;\n this.__v_isRef = true;\n this._rawValue = __v_isShallow ? value : toRaw(value);\n this._value = __v_isShallow ? value : toReactive(value);\n }\n get value() {\n trackRefValue(this);\n return this._value;\n }\n set value(newVal) {\n const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);\n newVal = useDirectValue ? newVal : toRaw(newVal);\n if (hasChanged(newVal, this._rawValue)) {\n const oldVal = this._rawValue;\n this._rawValue = newVal;\n this._value = useDirectValue ? newVal : toReactive(newVal);\n triggerRefValue(this, 4, newVal, oldVal);\n }\n }\n}\nfunction triggerRef(ref2) {\n triggerRefValue(ref2, 4, ref2.value );\n}\nfunction unref(ref2) {\n return isRef(ref2) ? ref2.value : ref2;\n}\nfunction toValue(source) {\n return isFunction(source) ? source() : unref(source);\n}\nconst shallowUnwrapHandlers = {\n get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),\n set: (target, key, value, receiver) => {\n const oldValue = target[key];\n if (isRef(oldValue) && !isRef(value)) {\n oldValue.value = value;\n return true;\n } else {\n return Reflect.set(target, key, value, receiver);\n }\n }\n};\nfunction proxyRefs(objectWithRefs) {\n return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);\n}\nclass CustomRefImpl {\n constructor(factory) {\n this.dep = void 0;\n this.__v_isRef = true;\n const { get, set } = factory(\n () => trackRefValue(this),\n () => triggerRefValue(this)\n );\n this._get = get;\n this._set = set;\n }\n get value() {\n return this._get();\n }\n set value(newVal) {\n this._set(newVal);\n }\n}\nfunction customRef(factory) {\n return new CustomRefImpl(factory);\n}\nfunction toRefs(object) {\n if (!isProxy(object)) {\n warn$2(`toRefs() expects a reactive object but received a plain one.`);\n }\n const ret = isArray(object) ? new Array(object.length) : {};\n for (const key in object) {\n ret[key] = propertyToRef(object, key);\n }\n return ret;\n}\nclass ObjectRefImpl {\n constructor(_object, _key, _defaultValue) {\n this._object = _object;\n this._key = _key;\n this._defaultValue = _defaultValue;\n this.__v_isRef = true;\n }\n get value() {\n const val = this._object[this._key];\n return val === void 0 ? this._defaultValue : val;\n }\n set value(newVal) {\n this._object[this._key] = newVal;\n }\n get dep() {\n return getDepFromReactive(toRaw(this._object), this._key);\n }\n}\nclass GetterRefImpl {\n constructor(_getter) {\n this._getter = _getter;\n this.__v_isRef = true;\n this.__v_isReadonly = true;\n }\n get value() {\n return this._getter();\n }\n}\nfunction toRef(source, key, defaultValue) {\n if (isRef(source)) {\n return source;\n } else if (isFunction(source)) {\n return new GetterRefImpl(source);\n } else if (isObject(source) && arguments.length > 1) {\n return propertyToRef(source, key, defaultValue);\n } else {\n return ref(source);\n }\n}\nfunction propertyToRef(source, key, defaultValue) {\n const val = source[key];\n return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);\n}\n\nconst TrackOpTypes = {\n \"GET\": \"get\",\n \"HAS\": \"has\",\n \"ITERATE\": \"iterate\"\n};\nconst TriggerOpTypes = {\n \"SET\": \"set\",\n \"ADD\": \"add\",\n \"DELETE\": \"delete\",\n \"CLEAR\": \"clear\"\n};\n\nconst stack$1 = [];\nfunction pushWarningContext(vnode) {\n stack$1.push(vnode);\n}\nfunction popWarningContext() {\n stack$1.pop();\n}\nlet isWarning = false;\nfunction warn$1(msg, ...args) {\n if (isWarning) return;\n isWarning = true;\n pauseTracking();\n const instance = stack$1.length ? stack$1[stack$1.length - 1].component : null;\n const appWarnHandler = instance && instance.appContext.config.warnHandler;\n const trace = getComponentTrace();\n if (appWarnHandler) {\n callWithErrorHandling(\n appWarnHandler,\n instance,\n 11,\n [\n // eslint-disable-next-line no-restricted-syntax\n msg + args.map((a) => {\n var _a, _b;\n return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);\n }).join(\"\"),\n instance && instance.proxy,\n trace.map(\n ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`\n ).join(\"\\n\"),\n trace\n ]\n );\n } else {\n const warnArgs = [`[Vue warn]: ${msg}`, ...args];\n if (trace.length && // avoid spamming console during tests\n true) {\n warnArgs.push(`\n`, ...formatTrace(trace));\n }\n console.warn(...warnArgs);\n }\n resetTracking();\n isWarning = false;\n}\nfunction getComponentTrace() {\n let currentVNode = stack$1[stack$1.length - 1];\n if (!currentVNode) {\n return [];\n }\n const normalizedStack = [];\n while (currentVNode) {\n const last = normalizedStack[0];\n if (last && last.vnode === currentVNode) {\n last.recurseCount++;\n } else {\n normalizedStack.push({\n vnode: currentVNode,\n recurseCount: 0\n });\n }\n const parentInstance = currentVNode.component && currentVNode.component.parent;\n currentVNode = parentInstance && parentInstance.vnode;\n }\n return normalizedStack;\n}\nfunction formatTrace(trace) {\n const logs = [];\n trace.forEach((entry, i) => {\n logs.push(...i === 0 ? [] : [`\n`], ...formatTraceEntry(entry));\n });\n return logs;\n}\nfunction formatTraceEntry({ vnode, recurseCount }) {\n const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\n const isRoot = vnode.component ? vnode.component.parent == null : false;\n const open = ` at <${formatComponentName(\n vnode.component,\n vnode.type,\n isRoot\n )}`;\n const close = `>` + postfix;\n return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];\n}\nfunction formatProps(props) {\n const res = [];\n const keys = Object.keys(props);\n keys.slice(0, 3).forEach((key) => {\n res.push(...formatProp(key, props[key]));\n });\n if (keys.length > 3) {\n res.push(` ...`);\n }\n return res;\n}\nfunction formatProp(key, value, raw) {\n if (isString(value)) {\n value = JSON.stringify(value);\n return raw ? value : [`${key}=${value}`];\n } else if (typeof value === \"number\" || typeof value === \"boolean\" || value == null) {\n return raw ? value : [`${key}=${value}`];\n } else if (isRef(value)) {\n value = formatProp(key, toRaw(value.value), true);\n return raw ? value : [`${key}=Ref<`, value, `>`];\n } else if (isFunction(value)) {\n return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\n } else {\n value = toRaw(value);\n return raw ? value : [`${key}=`, value];\n }\n}\nfunction assertNumber(val, type) {\n if (val === void 0) {\n return;\n } else if (typeof val !== \"number\") {\n warn$1(`${type} is not a valid number - got ${JSON.stringify(val)}.`);\n } else if (isNaN(val)) {\n warn$1(`${type} is NaN - the duration expression might be incorrect.`);\n }\n}\n\nconst ErrorCodes = {\n \"SETUP_FUNCTION\": 0,\n \"0\": \"SETUP_FUNCTION\",\n \"RENDER_FUNCTION\": 1,\n \"1\": \"RENDER_FUNCTION\",\n \"WATCH_GETTER\": 2,\n \"2\": \"WATCH_GETTER\",\n \"WATCH_CALLBACK\": 3,\n \"3\": \"WATCH_CALLBACK\",\n \"WATCH_CLEANUP\": 4,\n \"4\": \"WATCH_CLEANUP\",\n \"NATIVE_EVENT_HANDLER\": 5,\n \"5\": \"NATIVE_EVENT_HANDLER\",\n \"COMPONENT_EVENT_HANDLER\": 6,\n \"6\": \"COMPONENT_EVENT_HANDLER\",\n \"VNODE_HOOK\": 7,\n \"7\": \"VNODE_HOOK\",\n \"DIRECTIVE_HOOK\": 8,\n \"8\": \"DIRECTIVE_HOOK\",\n \"TRANSITION_HOOK\": 9,\n \"9\": \"TRANSITION_HOOK\",\n \"APP_ERROR_HANDLER\": 10,\n \"10\": \"APP_ERROR_HANDLER\",\n \"APP_WARN_HANDLER\": 11,\n \"11\": \"APP_WARN_HANDLER\",\n \"FUNCTION_REF\": 12,\n \"12\": \"FUNCTION_REF\",\n \"ASYNC_COMPONENT_LOADER\": 13,\n \"13\": \"ASYNC_COMPONENT_LOADER\",\n \"SCHEDULER\": 14,\n \"14\": \"SCHEDULER\",\n \"COMPONENT_UPDATE\": 15,\n \"15\": \"COMPONENT_UPDATE\"\n};\nconst ErrorTypeStrings$1 = {\n [\"sp\"]: \"serverPrefetch hook\",\n [\"bc\"]: \"beforeCreate hook\",\n [\"c\"]: \"created hook\",\n [\"bm\"]: \"beforeMount hook\",\n [\"m\"]: \"mounted hook\",\n [\"bu\"]: \"beforeUpdate hook\",\n [\"u\"]: \"updated\",\n [\"bum\"]: \"beforeUnmount hook\",\n [\"um\"]: \"unmounted hook\",\n [\"a\"]: \"activated hook\",\n [\"da\"]: \"deactivated hook\",\n [\"ec\"]: \"errorCaptured hook\",\n [\"rtc\"]: \"renderTracked hook\",\n [\"rtg\"]: \"renderTriggered hook\",\n [0]: \"setup function\",\n [1]: \"render function\",\n [2]: \"watcher getter\",\n [3]: \"watcher callback\",\n [4]: \"watcher cleanup function\",\n [5]: \"native event handler\",\n [6]: \"component event handler\",\n [7]: \"vnode hook\",\n [8]: \"directive hook\",\n [9]: \"transition hook\",\n [10]: \"app errorHandler\",\n [11]: \"app warnHandler\",\n [12]: \"ref function\",\n [13]: \"async component loader\",\n [14]: \"scheduler flush\",\n [15]: \"component update\"\n};\nfunction callWithErrorHandling(fn, instance, type, args) {\n try {\n return args ? fn(...args) : fn();\n } catch (err) {\n handleError(err, instance, type);\n }\n}\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\n if (isFunction(fn)) {\n const res = callWithErrorHandling(fn, instance, type, args);\n if (res && isPromise(res)) {\n res.catch((err) => {\n handleError(err, instance, type);\n });\n }\n return res;\n }\n if (isArray(fn)) {\n const values = [];\n for (let i = 0; i < fn.length; i++) {\n values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\n }\n return values;\n } else {\n warn$1(\n `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`\n );\n }\n}\nfunction handleError(err, instance, type, throwInDev = true) {\n const contextVNode = instance ? instance.vnode : null;\n if (instance) {\n let cur = instance.parent;\n const exposedInstance = instance.proxy;\n const errorInfo = ErrorTypeStrings$1[type] ;\n while (cur) {\n const errorCapturedHooks = cur.ec;\n if (errorCapturedHooks) {\n for (let i = 0; i < errorCapturedHooks.length; i++) {\n if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {\n return;\n }\n }\n }\n cur = cur.parent;\n }\n const appErrorHandler = instance.appContext.config.errorHandler;\n if (appErrorHandler) {\n pauseTracking();\n callWithErrorHandling(\n appErrorHandler,\n null,\n 10,\n [err, exposedInstance, errorInfo]\n );\n resetTracking();\n return;\n }\n }\n logError(err, type, contextVNode, throwInDev);\n}\nfunction logError(err, type, contextVNode, throwInDev = true) {\n {\n const info = ErrorTypeStrings$1[type];\n if (contextVNode) {\n pushWarningContext(contextVNode);\n }\n warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\n if (contextVNode) {\n popWarningContext();\n }\n if (throwInDev) {\n throw err;\n } else {\n console.error(err);\n }\n }\n}\n\nlet isFlushing = false;\nlet isFlushPending = false;\nconst queue = [];\nlet flushIndex = 0;\nconst pendingPostFlushCbs = [];\nlet activePostFlushCbs = null;\nlet postFlushIndex = 0;\nconst resolvedPromise = /* @__PURE__ */ Promise.resolve();\nlet currentFlushPromise = null;\nconst RECURSION_LIMIT = 100;\nfunction nextTick(fn) {\n const p = currentFlushPromise || resolvedPromise;\n return fn ? p.then(this ? fn.bind(this) : fn) : p;\n}\nfunction findInsertionIndex(id) {\n let start = flushIndex + 1;\n let end = queue.length;\n while (start < end) {\n const middle = start + end >>> 1;\n const middleJob = queue[middle];\n const middleJobId = getId(middleJob);\n if (middleJobId < id || middleJobId === id && middleJob.pre) {\n start = middle + 1;\n } else {\n end = middle;\n }\n }\n return start;\n}\nfunction queueJob(job) {\n if (!queue.length || !queue.includes(\n job,\n isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex\n )) {\n if (job.id == null) {\n queue.push(job);\n } else {\n queue.splice(findInsertionIndex(job.id), 0, job);\n }\n queueFlush();\n }\n}\nfunction queueFlush() {\n if (!isFlushing && !isFlushPending) {\n isFlushPending = true;\n currentFlushPromise = resolvedPromise.then(flushJobs);\n }\n}\nfunction invalidateJob(job) {\n const i = queue.indexOf(job);\n if (i > flushIndex) {\n queue.splice(i, 1);\n }\n}\nfunction queuePostFlushCb(cb) {\n if (!isArray(cb)) {\n if (!activePostFlushCbs || !activePostFlushCbs.includes(\n cb,\n cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex\n )) {\n pendingPostFlushCbs.push(cb);\n }\n } else {\n pendingPostFlushCbs.push(...cb);\n }\n queueFlush();\n}\nfunction flushPreFlushCbs(instance, seen, i = isFlushing ? flushIndex + 1 : 0) {\n {\n seen = seen || /* @__PURE__ */ new Map();\n }\n for (; i < queue.length; i++) {\n const cb = queue[i];\n if (cb && cb.pre) {\n if (instance && cb.id !== instance.uid) {\n continue;\n }\n if (checkRecursiveUpdates(seen, cb)) {\n continue;\n }\n queue.splice(i, 1);\n i--;\n cb();\n }\n }\n}\nfunction flushPostFlushCbs(seen) {\n if (pendingPostFlushCbs.length) {\n const deduped = [...new Set(pendingPostFlushCbs)].sort(\n (a, b) => getId(a) - getId(b)\n );\n pendingPostFlushCbs.length = 0;\n if (activePostFlushCbs) {\n activePostFlushCbs.push(...deduped);\n return;\n }\n activePostFlushCbs = deduped;\n {\n seen = seen || /* @__PURE__ */ new Map();\n }\n for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\n const cb = activePostFlushCbs[postFlushIndex];\n if (checkRecursiveUpdates(seen, cb)) {\n continue;\n }\n if (cb.active !== false) cb();\n }\n activePostFlushCbs = null;\n postFlushIndex = 0;\n }\n}\nconst getId = (job) => job.id == null ? Infinity : job.id;\nconst comparator = (a, b) => {\n const diff = getId(a) - getId(b);\n if (diff === 0) {\n if (a.pre && !b.pre) return -1;\n if (b.pre && !a.pre) return 1;\n }\n return diff;\n};\nfunction flushJobs(seen) {\n isFlushPending = false;\n isFlushing = true;\n {\n seen = seen || /* @__PURE__ */ new Map();\n }\n queue.sort(comparator);\n const check = (job) => checkRecursiveUpdates(seen, job) ;\n try {\n for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\n const job = queue[flushIndex];\n if (job && job.active !== false) {\n if (check(job)) {\n continue;\n }\n callWithErrorHandling(\n job,\n job.i,\n job.i ? 15 : 14\n );\n }\n }\n } finally {\n flushIndex = 0;\n queue.length = 0;\n flushPostFlushCbs(seen);\n isFlushing = false;\n currentFlushPromise = null;\n if (queue.length || pendingPostFlushCbs.length) {\n flushJobs(seen);\n }\n }\n}\nfunction checkRecursiveUpdates(seen, fn) {\n if (!seen.has(fn)) {\n seen.set(fn, 1);\n } else {\n const count = seen.get(fn);\n if (count > RECURSION_LIMIT) {\n const instance = fn.i;\n const componentName = instance && getComponentName(instance.type);\n handleError(\n `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,\n null,\n 10\n );\n return true;\n } else {\n seen.set(fn, count + 1);\n }\n }\n}\n\nlet isHmrUpdating = false;\nconst hmrDirtyComponents = /* @__PURE__ */ new Map();\n{\n getGlobalThis().__VUE_HMR_RUNTIME__ = {\n createRecord: tryWrap(createRecord),\n rerender: tryWrap(rerender),\n reload: tryWrap(reload)\n };\n}\nconst map = /* @__PURE__ */ new Map();\nfunction registerHMR(instance) {\n const id = instance.type.__hmrId;\n let record = map.get(id);\n if (!record) {\n createRecord(id, instance.type);\n record = map.get(id);\n }\n record.instances.add(instance);\n}\nfunction unregisterHMR(instance) {\n map.get(instance.type.__hmrId).instances.delete(instance);\n}\nfunction createRecord(id, initialDef) {\n if (map.has(id)) {\n return false;\n }\n map.set(id, {\n initialDef: normalizeClassComponent(initialDef),\n instances: /* @__PURE__ */ new Set()\n });\n return true;\n}\nfunction normalizeClassComponent(component) {\n return isClassComponent(component) ? component.__vccOpts : component;\n}\nfunction rerender(id, newRender) {\n const record = map.get(id);\n if (!record) {\n return;\n }\n record.initialDef.render = newRender;\n [...record.instances].forEach((instance) => {\n if (newRender) {\n instance.render = newRender;\n normalizeClassComponent(instance.type).render = newRender;\n }\n instance.renderCache = [];\n isHmrUpdating = true;\n instance.effect.dirty = true;\n instance.update();\n isHmrUpdating = false;\n });\n}\nfunction reload(id, newComp) {\n const record = map.get(id);\n if (!record) return;\n newComp = normalizeClassComponent(newComp);\n updateComponentDef(record.initialDef, newComp);\n const instances = [...record.instances];\n for (let i = 0; i < instances.length; i++) {\n const instance = instances[i];\n const oldComp = normalizeClassComponent(instance.type);\n let dirtyInstances = hmrDirtyComponents.get(oldComp);\n if (!dirtyInstances) {\n if (oldComp !== record.initialDef) {\n updateComponentDef(oldComp, newComp);\n }\n hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());\n }\n dirtyInstances.add(instance);\n instance.appContext.propsCache.delete(instance.type);\n instance.appContext.emitsCache.delete(instance.type);\n instance.appContext.optionsCache.delete(instance.type);\n if (instance.ceReload) {\n dirtyInstances.add(instance);\n instance.ceReload(newComp.styles);\n dirtyInstances.delete(instance);\n } else if (instance.parent) {\n instance.parent.effect.dirty = true;\n queueJob(() => {\n instance.parent.update();\n dirtyInstances.delete(instance);\n });\n } else if (instance.appContext.reload) {\n instance.appContext.reload();\n } else if (typeof window !== \"undefined\") {\n window.location.reload();\n } else {\n console.warn(\n \"[HMR] Root or manually mounted instance modified. Full reload required.\"\n );\n }\n }\n queuePostFlushCb(() => {\n hmrDirtyComponents.clear();\n });\n}\nfunction updateComponentDef(oldComp, newComp) {\n extend(oldComp, newComp);\n for (const key in oldComp) {\n if (key !== \"__file\" && !(key in newComp)) {\n delete oldComp[key];\n }\n }\n}\nfunction tryWrap(fn) {\n return (id, arg) => {\n try {\n return fn(id, arg);\n } catch (e) {\n console.error(e);\n console.warn(\n `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`\n );\n }\n };\n}\n\nlet devtools$1;\nlet buffer = [];\nlet devtoolsNotInstalled = false;\nfunction emit$1(event, ...args) {\n if (devtools$1) {\n devtools$1.emit(event, ...args);\n } else if (!devtoolsNotInstalled) {\n buffer.push({ event, args });\n }\n}\nfunction setDevtoolsHook$1(hook, target) {\n var _a, _b;\n devtools$1 = hook;\n if (devtools$1) {\n devtools$1.enabled = true;\n buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args));\n buffer = [];\n } else if (\n // handle late devtools injection - only do this if we are in an actual\n // browser environment to avoid the timer handle stalling test runner exit\n // (#4815)\n typeof window !== \"undefined\" && // some envs mock window but not fully\n window.HTMLElement && // also exclude jsdom\n // eslint-disable-next-line no-restricted-syntax\n !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes(\"jsdom\"))\n ) {\n const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];\n replay.push((newHook) => {\n setDevtoolsHook$1(newHook, target);\n });\n setTimeout(() => {\n if (!devtools$1) {\n target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;\n devtoolsNotInstalled = true;\n buffer = [];\n }\n }, 3e3);\n } else {\n devtoolsNotInstalled = true;\n buffer = [];\n }\n}\nfunction devtoolsInitApp(app, version) {\n emit$1(\"app:init\" /* APP_INIT */, app, version, {\n Fragment,\n Text,\n Comment,\n Static\n });\n}\nfunction devtoolsUnmountApp(app) {\n emit$1(\"app:unmount\" /* APP_UNMOUNT */, app);\n}\nconst devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(\n \"component:added\" /* COMPONENT_ADDED */\n);\nconst devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook(\"component:updated\" /* COMPONENT_UPDATED */);\nconst _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(\n \"component:removed\" /* COMPONENT_REMOVED */\n);\nconst devtoolsComponentRemoved = (component) => {\n if (devtools$1 && typeof devtools$1.cleanupBuffer === \"function\" && // remove the component if it wasn't buffered\n !devtools$1.cleanupBuffer(component)) {\n _devtoolsComponentRemoved(component);\n }\n};\n/*! #__NO_SIDE_EFFECTS__ */\n// @__NO_SIDE_EFFECTS__\nfunction createDevtoolsComponentHook(hook) {\n return (component) => {\n emit$1(\n hook,\n component.appContext.app,\n component.uid,\n component.parent ? component.parent.uid : void 0,\n component\n );\n };\n}\nconst devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(\n \"perf:start\" /* PERFORMANCE_START */\n);\nconst devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(\n \"perf:end\" /* PERFORMANCE_END */\n);\nfunction createDevtoolsPerformanceHook(hook) {\n return (component, type, time) => {\n emit$1(hook, component.appContext.app, component.uid, component, type, time);\n };\n}\nfunction devtoolsComponentEmit(component, event, params) {\n emit$1(\n \"component:emit\" /* COMPONENT_EMIT */,\n component.appContext.app,\n component,\n event,\n params\n );\n}\n\nlet currentRenderingInstance = null;\nlet currentScopeId = null;\nfunction setCurrentRenderingInstance(instance) {\n const prev = currentRenderingInstance;\n currentRenderingInstance = instance;\n currentScopeId = instance && instance.type.__scopeId || null;\n return prev;\n}\nfunction pushScopeId(id) {\n currentScopeId = id;\n}\nfunction popScopeId() {\n currentScopeId = null;\n}\nconst withScopeId = (_id) => withCtx;\nfunction withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {\n if (!ctx) return fn;\n if (fn._n) {\n return fn;\n }\n const renderFnWithContext = (...args) => {\n if (renderFnWithContext._d) {\n setBlockTracking(-1);\n }\n const prevInstance = setCurrentRenderingInstance(ctx);\n let res;\n try {\n res = fn(...args);\n } finally {\n setCurrentRenderingInstance(prevInstance);\n if (renderFnWithContext._d) {\n setBlockTracking(1);\n }\n }\n {\n devtoolsComponentUpdated(ctx);\n }\n return res;\n };\n renderFnWithContext._n = true;\n renderFnWithContext._c = true;\n renderFnWithContext._d = true;\n return renderFnWithContext;\n}\n\nfunction validateDirectiveName(name) {\n if (isBuiltInDirective(name)) {\n warn$1(\"Do not use built-in directive ids as custom directive id: \" + name);\n }\n}\nfunction withDirectives(vnode, directives) {\n if (currentRenderingInstance === null) {\n warn$1(`withDirectives can only be used inside render functions.`);\n return vnode;\n }\n const instance = getComponentPublicInstance(currentRenderingInstance);\n const bindings = vnode.dirs || (vnode.dirs = []);\n for (let i = 0; i < directives.length; i++) {\n let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];\n if (dir) {\n if (isFunction(dir)) {\n dir = {\n mounted: dir,\n updated: dir\n };\n }\n if (dir.deep) {\n traverse(value);\n }\n bindings.push({\n dir,\n instance,\n value,\n oldValue: void 0,\n arg,\n modifiers\n });\n }\n }\n return vnode;\n}\nfunction invokeDirectiveHook(vnode, prevVNode, instance, name) {\n const bindings = vnode.dirs;\n const oldBindings = prevVNode && prevVNode.dirs;\n for (let i = 0; i < bindings.length; i++) {\n const binding = bindings[i];\n if (oldBindings) {\n binding.oldValue = oldBindings[i].value;\n }\n let hook = binding.dir[name];\n if (hook) {\n pauseTracking();\n callWithAsyncErrorHandling(hook, instance, 8, [\n vnode.el,\n binding,\n vnode,\n prevVNode\n ]);\n resetTracking();\n }\n }\n}\n\nconst leaveCbKey = Symbol(\"_leaveCb\");\nconst enterCbKey$1 = Symbol(\"_enterCb\");\nfunction useTransitionState() {\n const state = {\n isMounted: false,\n isLeaving: false,\n isUnmounting: false,\n leavingVNodes: /* @__PURE__ */ new Map()\n };\n onMounted(() => {\n state.isMounted = true;\n });\n onBeforeUnmount(() => {\n state.isUnmounting = true;\n });\n return state;\n}\nconst TransitionHookValidator = [Function, Array];\nconst BaseTransitionPropsValidators = {\n mode: String,\n appear: Boolean,\n persisted: Boolean,\n // enter\n onBeforeEnter: TransitionHookValidator,\n onEnter: TransitionHookValidator,\n onAfterEnter: TransitionHookValidator,\n onEnterCancelled: TransitionHookValidator,\n // leave\n onBeforeLeave: TransitionHookValidator,\n onLeave: TransitionHookValidator,\n onAfterLeave: TransitionHookValidator,\n onLeaveCancelled: TransitionHookValidator,\n // appear\n onBeforeAppear: TransitionHookValidator,\n onAppear: TransitionHookValidator,\n onAfterAppear: TransitionHookValidator,\n onAppearCancelled: TransitionHookValidator\n};\nconst recursiveGetSubtree = (instance) => {\n const subTree = instance.subTree;\n return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;\n};\nconst BaseTransitionImpl = {\n name: `BaseTransition`,\n props: BaseTransitionPropsValidators,\n setup(props, { slots }) {\n const instance = getCurrentInstance();\n const state = useTransitionState();\n return () => {\n const children = slots.default && getTransitionRawChildren(slots.default(), true);\n if (!children || !children.length) {\n return;\n }\n let child = children[0];\n if (children.length > 1) {\n let hasFound = false;\n for (const c of children) {\n if (c.type !== Comment) {\n if (hasFound) {\n warn$1(\n \" can only be used on a single element or component. Use for lists.\"\n );\n break;\n }\n child = c;\n hasFound = true;\n }\n }\n }\n const rawProps = toRaw(props);\n const { mode } = rawProps;\n if (mode && mode !== \"in-out\" && mode !== \"out-in\" && mode !== \"default\") {\n warn$1(`invalid mode: ${mode}`);\n }\n if (state.isLeaving) {\n return emptyPlaceholder(child);\n }\n const innerChild = getKeepAliveChild(child);\n if (!innerChild) {\n return emptyPlaceholder(child);\n }\n let enterHooks = resolveTransitionHooks(\n innerChild,\n rawProps,\n state,\n instance,\n // #11061, ensure enterHooks is fresh after clone\n (hooks) => enterHooks = hooks\n );\n setTransitionHooks(innerChild, enterHooks);\n const oldChild = instance.subTree;\n const oldInnerChild = oldChild && getKeepAliveChild(oldChild);\n if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) {\n const leavingHooks = resolveTransitionHooks(\n oldInnerChild,\n rawProps,\n state,\n instance\n );\n setTransitionHooks(oldInnerChild, leavingHooks);\n if (mode === \"out-in\" && innerChild.type !== Comment) {\n state.isLeaving = true;\n leavingHooks.afterLeave = () => {\n state.isLeaving = false;\n if (instance.update.active !== false) {\n instance.effect.dirty = true;\n instance.update();\n }\n };\n return emptyPlaceholder(child);\n } else if (mode === \"in-out\" && innerChild.type !== Comment) {\n leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {\n const leavingVNodesCache = getLeavingNodesForType(\n state,\n oldInnerChild\n );\n leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;\n el[leaveCbKey] = () => {\n earlyRemove();\n el[leaveCbKey] = void 0;\n delete enterHooks.delayedLeave;\n };\n enterHooks.delayedLeave = delayedLeave;\n };\n }\n }\n return child;\n };\n }\n};\nconst BaseTransition = BaseTransitionImpl;\nfunction getLeavingNodesForType(state, vnode) {\n const { leavingVNodes } = state;\n let leavingVNodesCache = leavingVNodes.get(vnode.type);\n if (!leavingVNodesCache) {\n leavingVNodesCache = /* @__PURE__ */ Object.create(null);\n leavingVNodes.set(vnode.type, leavingVNodesCache);\n }\n return leavingVNodesCache;\n}\nfunction resolveTransitionHooks(vnode, props, state, instance, postClone) {\n const {\n appear,\n mode,\n persisted = false,\n onBeforeEnter,\n onEnter,\n onAfterEnter,\n onEnterCancelled,\n onBeforeLeave,\n onLeave,\n onAfterLeave,\n onLeaveCancelled,\n onBeforeAppear,\n onAppear,\n onAfterAppear,\n onAppearCancelled\n } = props;\n const key = String(vnode.key);\n const leavingVNodesCache = getLeavingNodesForType(state, vnode);\n const callHook = (hook, args) => {\n hook && callWithAsyncErrorHandling(\n hook,\n instance,\n 9,\n args\n );\n };\n const callAsyncHook = (hook, args) => {\n const done = args[1];\n callHook(hook, args);\n if (isArray(hook)) {\n if (hook.every((hook2) => hook2.length <= 1)) done();\n } else if (hook.length <= 1) {\n done();\n }\n };\n const hooks = {\n mode,\n persisted,\n beforeEnter(el) {\n let hook = onBeforeEnter;\n if (!state.isMounted) {\n if (appear) {\n hook = onBeforeAppear || onBeforeEnter;\n } else {\n return;\n }\n }\n if (el[leaveCbKey]) {\n el[leaveCbKey](\n true\n /* cancelled */\n );\n }\n const leavingVNode = leavingVNodesCache[key];\n if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {\n leavingVNode.el[leaveCbKey]();\n }\n callHook(hook, [el]);\n },\n enter(el) {\n let hook = onEnter;\n let afterHook = onAfterEnter;\n let cancelHook = onEnterCancelled;\n if (!state.isMounted) {\n if (appear) {\n hook = onAppear || onEnter;\n afterHook = onAfterAppear || onAfterEnter;\n cancelHook = onAppearCancelled || onEnterCancelled;\n } else {\n return;\n }\n }\n let called = false;\n const done = el[enterCbKey$1] = (cancelled) => {\n if (called) return;\n called = true;\n if (cancelled) {\n callHook(cancelHook, [el]);\n } else {\n callHook(afterHook, [el]);\n }\n if (hooks.delayedLeave) {\n hooks.delayedLeave();\n }\n el[enterCbKey$1] = void 0;\n };\n if (hook) {\n callAsyncHook(hook, [el, done]);\n } else {\n done();\n }\n },\n leave(el, remove) {\n const key2 = String(vnode.key);\n if (el[enterCbKey$1]) {\n el[enterCbKey$1](\n true\n /* cancelled */\n );\n }\n if (state.isUnmounting) {\n return remove();\n }\n callHook(onBeforeLeave, [el]);\n let called = false;\n const done = el[leaveCbKey] = (cancelled) => {\n if (called) return;\n called = true;\n remove();\n if (cancelled) {\n callHook(onLeaveCancelled, [el]);\n } else {\n callHook(onAfterLeave, [el]);\n }\n el[leaveCbKey] = void 0;\n if (leavingVNodesCache[key2] === vnode) {\n delete leavingVNodesCache[key2];\n }\n };\n leavingVNodesCache[key2] = vnode;\n if (onLeave) {\n callAsyncHook(onLeave, [el, done]);\n } else {\n done();\n }\n },\n clone(vnode2) {\n const hooks2 = resolveTransitionHooks(\n vnode2,\n props,\n state,\n instance,\n postClone\n );\n if (postClone) postClone(hooks2);\n return hooks2;\n }\n };\n return hooks;\n}\nfunction emptyPlaceholder(vnode) {\n if (isKeepAlive(vnode)) {\n vnode = cloneVNode(vnode);\n vnode.children = null;\n return vnode;\n }\n}\nfunction getKeepAliveChild(vnode) {\n if (!isKeepAlive(vnode)) {\n return vnode;\n }\n if (vnode.component) {\n return vnode.component.subTree;\n }\n const { shapeFlag, children } = vnode;\n if (children) {\n if (shapeFlag & 16) {\n return children[0];\n }\n if (shapeFlag & 32 && isFunction(children.default)) {\n return children.default();\n }\n }\n}\nfunction setTransitionHooks(vnode, hooks) {\n if (vnode.shapeFlag & 6 && vnode.component) {\n setTransitionHooks(vnode.component.subTree, hooks);\n } else if (vnode.shapeFlag & 128) {\n vnode.ssContent.transition = hooks.clone(vnode.ssContent);\n vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);\n } else {\n vnode.transition = hooks;\n }\n}\nfunction getTransitionRawChildren(children, keepComment = false, parentKey) {\n let ret = [];\n let keyedFragmentCount = 0;\n for (let i = 0; i < children.length; i++) {\n let child = children[i];\n const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);\n if (child.type === Fragment) {\n if (child.patchFlag & 128) keyedFragmentCount++;\n ret = ret.concat(\n getTransitionRawChildren(child.children, keepComment, key)\n );\n } else if (keepComment || child.type !== Comment) {\n ret.push(key != null ? cloneVNode(child, { key }) : child);\n }\n }\n if (keyedFragmentCount > 1) {\n for (let i = 0; i < ret.length; i++) {\n ret[i].patchFlag = -2;\n }\n }\n return ret;\n}\n\n/*! #__NO_SIDE_EFFECTS__ */\n// @__NO_SIDE_EFFECTS__\nfunction defineComponent(options, extraOptions) {\n return isFunction(options) ? (\n // #8326: extend call and options.name access are considered side-effects\n // by Rollup, so we have to wrap it in a pure-annotated IIFE.\n /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()\n ) : options;\n}\n\nconst isAsyncWrapper = (i) => !!i.type.__asyncLoader;\n/*! #__NO_SIDE_EFFECTS__ */\n// @__NO_SIDE_EFFECTS__\nfunction defineAsyncComponent(source) {\n if (isFunction(source)) {\n source = { loader: source };\n }\n const {\n loader,\n loadingComponent,\n errorComponent,\n delay = 200,\n timeout,\n // undefined = never times out\n suspensible = true,\n onError: userOnError\n } = source;\n let pendingRequest = null;\n let resolvedComp;\n let retries = 0;\n const retry = () => {\n retries++;\n pendingRequest = null;\n return load();\n };\n const load = () => {\n let thisRequest;\n return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {\n err = err instanceof Error ? err : new Error(String(err));\n if (userOnError) {\n return new Promise((resolve, reject) => {\n const userRetry = () => resolve(retry());\n const userFail = () => reject(err);\n userOnError(err, userRetry, userFail, retries + 1);\n });\n } else {\n throw err;\n }\n }).then((comp) => {\n if (thisRequest !== pendingRequest && pendingRequest) {\n return pendingRequest;\n }\n if (!comp) {\n warn$1(\n `Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`\n );\n }\n if (comp && (comp.__esModule || comp[Symbol.toStringTag] === \"Module\")) {\n comp = comp.default;\n }\n if (comp && !isObject(comp) && !isFunction(comp)) {\n throw new Error(`Invalid async component load result: ${comp}`);\n }\n resolvedComp = comp;\n return comp;\n }));\n };\n return defineComponent({\n name: \"AsyncComponentWrapper\",\n __asyncLoader: load,\n get __asyncResolved() {\n return resolvedComp;\n },\n setup() {\n const instance = currentInstance;\n if (resolvedComp) {\n return () => createInnerComp(resolvedComp, instance);\n }\n const onError = (err) => {\n pendingRequest = null;\n handleError(\n err,\n instance,\n 13,\n !errorComponent\n );\n };\n if (suspensible && instance.suspense || false) {\n return load().then((comp) => {\n return () => createInnerComp(comp, instance);\n }).catch((err) => {\n onError(err);\n return () => errorComponent ? createVNode(errorComponent, {\n error: err\n }) : null;\n });\n }\n const loaded = ref(false);\n const error = ref();\n const delayed = ref(!!delay);\n if (delay) {\n setTimeout(() => {\n delayed.value = false;\n }, delay);\n }\n if (timeout != null) {\n setTimeout(() => {\n if (!loaded.value && !error.value) {\n const err = new Error(\n `Async component timed out after ${timeout}ms.`\n );\n onError(err);\n error.value = err;\n }\n }, timeout);\n }\n load().then(() => {\n loaded.value = true;\n if (instance.parent && isKeepAlive(instance.parent.vnode)) {\n instance.parent.effect.dirty = true;\n queueJob(instance.parent.update);\n }\n }).catch((err) => {\n onError(err);\n error.value = err;\n });\n return () => {\n if (loaded.value && resolvedComp) {\n return createInnerComp(resolvedComp, instance);\n } else if (error.value && errorComponent) {\n return createVNode(errorComponent, {\n error: error.value\n });\n } else if (loadingComponent && !delayed.value) {\n return createVNode(loadingComponent);\n }\n };\n }\n });\n}\nfunction createInnerComp(comp, parent) {\n const { ref: ref2, props, children, ce } = parent.vnode;\n const vnode = createVNode(comp, props, children);\n vnode.ref = ref2;\n vnode.ce = ce;\n delete parent.vnode.ce;\n return vnode;\n}\n\nconst isKeepAlive = (vnode) => vnode.type.__isKeepAlive;\nconst KeepAliveImpl = {\n name: `KeepAlive`,\n // Marker for special handling inside the renderer. We are not using a ===\n // check directly on KeepAlive in the renderer, because importing it directly\n // would prevent it from being tree-shaken.\n __isKeepAlive: true,\n props: {\n include: [String, RegExp, Array],\n exclude: [String, RegExp, Array],\n max: [String, Number]\n },\n setup(props, { slots }) {\n const instance = getCurrentInstance();\n const sharedContext = instance.ctx;\n const cache = /* @__PURE__ */ new Map();\n const keys = /* @__PURE__ */ new Set();\n let current = null;\n {\n instance.__v_cache = cache;\n }\n const parentSuspense = instance.suspense;\n const {\n renderer: {\n p: patch,\n m: move,\n um: _unmount,\n o: { createElement }\n }\n } = sharedContext;\n const storageContainer = createElement(\"div\");\n sharedContext.activate = (vnode, container, anchor, namespace, optimized) => {\n const instance2 = vnode.component;\n move(vnode, container, anchor, 0, parentSuspense);\n patch(\n instance2.vnode,\n vnode,\n container,\n anchor,\n instance2,\n parentSuspense,\n namespace,\n vnode.slotScopeIds,\n optimized\n );\n queuePostRenderEffect(() => {\n instance2.isDeactivated = false;\n if (instance2.a) {\n invokeArrayFns(instance2.a);\n }\n const vnodeHook = vnode.props && vnode.props.onVnodeMounted;\n if (vnodeHook) {\n invokeVNodeHook(vnodeHook, instance2.parent, vnode);\n }\n }, parentSuspense);\n {\n devtoolsComponentAdded(instance2);\n }\n };\n sharedContext.deactivate = (vnode) => {\n const instance2 = vnode.component;\n invalidateMount(instance2.m);\n invalidateMount(instance2.a);\n move(vnode, storageContainer, null, 1, parentSuspense);\n queuePostRenderEffect(() => {\n if (instance2.da) {\n invokeArrayFns(instance2.da);\n }\n const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;\n if (vnodeHook) {\n invokeVNodeHook(vnodeHook, instance2.parent, vnode);\n }\n instance2.isDeactivated = true;\n }, parentSuspense);\n {\n devtoolsComponentAdded(instance2);\n }\n };\n function unmount(vnode) {\n resetShapeFlag(vnode);\n _unmount(vnode, instance, parentSuspense, true);\n }\n function pruneCache(filter) {\n cache.forEach((vnode, key) => {\n const name = getComponentName(vnode.type);\n if (name && (!filter || !filter(name))) {\n pruneCacheEntry(key);\n }\n });\n }\n function pruneCacheEntry(key) {\n const cached = cache.get(key);\n if (!current || !isSameVNodeType(cached, current)) {\n unmount(cached);\n } else if (current) {\n resetShapeFlag(current);\n }\n cache.delete(key);\n keys.delete(key);\n }\n watch(\n () => [props.include, props.exclude],\n ([include, exclude]) => {\n include && pruneCache((name) => matches(include, name));\n exclude && pruneCache((name) => !matches(exclude, name));\n },\n // prune post-render after `current` has been updated\n { flush: \"post\", deep: true }\n );\n let pendingCacheKey = null;\n const cacheSubtree = () => {\n if (pendingCacheKey != null) {\n if (isSuspense(instance.subTree.type)) {\n queuePostRenderEffect(() => {\n cache.set(pendingCacheKey, getInnerChild(instance.subTree));\n }, instance.subTree.suspense);\n } else {\n cache.set(pendingCacheKey, getInnerChild(instance.subTree));\n }\n }\n };\n onMounted(cacheSubtree);\n onUpdated(cacheSubtree);\n onBeforeUnmount(() => {\n cache.forEach((cached) => {\n const { subTree, suspense } = instance;\n const vnode = getInnerChild(subTree);\n if (cached.type === vnode.type && cached.key === vnode.key) {\n resetShapeFlag(vnode);\n const da = vnode.component.da;\n da && queuePostRenderEffect(da, suspense);\n return;\n }\n unmount(cached);\n });\n });\n return () => {\n pendingCacheKey = null;\n if (!slots.default) {\n return null;\n }\n const children = slots.default();\n const rawVNode = children[0];\n if (children.length > 1) {\n {\n warn$1(`KeepAlive should contain exactly one component child.`);\n }\n current = null;\n return children;\n } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {\n current = null;\n return rawVNode;\n }\n let vnode = getInnerChild(rawVNode);\n const comp = vnode.type;\n const name = getComponentName(\n isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp\n );\n const { include, exclude, max } = props;\n if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {\n current = vnode;\n return rawVNode;\n }\n const key = vnode.key == null ? comp : vnode.key;\n const cachedVNode = cache.get(key);\n if (vnode.el) {\n vnode = cloneVNode(vnode);\n if (rawVNode.shapeFlag & 128) {\n rawVNode.ssContent = vnode;\n }\n }\n pendingCacheKey = key;\n if (cachedVNode) {\n vnode.el = cachedVNode.el;\n vnode.component = cachedVNode.component;\n if (vnode.transition) {\n setTransitionHooks(vnode, vnode.transition);\n }\n vnode.shapeFlag |= 512;\n keys.delete(key);\n keys.add(key);\n } else {\n keys.add(key);\n if (max && keys.size > parseInt(max, 10)) {\n pruneCacheEntry(keys.values().next().value);\n }\n }\n vnode.shapeFlag |= 256;\n current = vnode;\n return isSuspense(rawVNode.type) ? rawVNode : vnode;\n };\n }\n};\nconst KeepAlive = KeepAliveImpl;\nfunction matches(pattern, name) {\n if (isArray(pattern)) {\n return pattern.some((p) => matches(p, name));\n } else if (isString(pattern)) {\n return pattern.split(\",\").includes(name);\n } else if (isRegExp(pattern)) {\n return pattern.test(name);\n }\n return false;\n}\nfunction onActivated(hook, target) {\n registerKeepAliveHook(hook, \"a\", target);\n}\nfunction onDeactivated(hook, target) {\n registerKeepAliveHook(hook, \"da\", target);\n}\nfunction registerKeepAliveHook(hook, type, target = currentInstance) {\n const wrappedHook = hook.__wdc || (hook.__wdc = () => {\n let current = target;\n while (current) {\n if (current.isDeactivated) {\n return;\n }\n current = current.parent;\n }\n return hook();\n });\n injectHook(type, wrappedHook, target);\n if (target) {\n let current = target.parent;\n while (current && current.parent) {\n if (isKeepAlive(current.parent.vnode)) {\n injectToKeepAliveRoot(wrappedHook, type, target, current);\n }\n current = current.parent;\n }\n }\n}\nfunction injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {\n const injected = injectHook(\n type,\n hook,\n keepAliveRoot,\n true\n /* prepend */\n );\n onUnmounted(() => {\n remove(keepAliveRoot[type], injected);\n }, target);\n}\nfunction resetShapeFlag(vnode) {\n vnode.shapeFlag &= ~256;\n vnode.shapeFlag &= ~512;\n}\nfunction getInnerChild(vnode) {\n return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;\n}\n\nfunction injectHook(type, hook, target = currentInstance, prepend = false) {\n if (target) {\n const hooks = target[type] || (target[type] = []);\n const wrappedHook = hook.__weh || (hook.__weh = (...args) => {\n pauseTracking();\n const reset = setCurrentInstance(target);\n const res = callWithAsyncErrorHandling(hook, target, type, args);\n reset();\n resetTracking();\n return res;\n });\n if (prepend) {\n hooks.unshift(wrappedHook);\n } else {\n hooks.push(wrappedHook);\n }\n return wrappedHook;\n } else {\n const apiName = toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, \"\"));\n warn$1(\n `${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().` + (` If you are using async setup(), make sure to register lifecycle hooks before the first await statement.` )\n );\n }\n}\nconst createHook = (lifecycle) => (hook, target = currentInstance) => {\n if (!isInSSRComponentSetup || lifecycle === \"sp\") {\n injectHook(lifecycle, (...args) => hook(...args), target);\n }\n};\nconst onBeforeMount = createHook(\"bm\");\nconst onMounted = createHook(\"m\");\nconst onBeforeUpdate = createHook(\"bu\");\nconst onUpdated = createHook(\"u\");\nconst onBeforeUnmount = createHook(\"bum\");\nconst onUnmounted = createHook(\"um\");\nconst onServerPrefetch = createHook(\"sp\");\nconst onRenderTriggered = createHook(\n \"rtg\"\n);\nconst onRenderTracked = createHook(\n \"rtc\"\n);\nfunction onErrorCaptured(hook, target = currentInstance) {\n injectHook(\"ec\", hook, target);\n}\n\nconst COMPONENTS = \"components\";\nconst DIRECTIVES = \"directives\";\nfunction resolveComponent(name, maybeSelfReference) {\n return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;\n}\nconst NULL_DYNAMIC_COMPONENT = Symbol.for(\"v-ndc\");\nfunction resolveDynamicComponent(component) {\n if (isString(component)) {\n return resolveAsset(COMPONENTS, component, false) || component;\n } else {\n return component || NULL_DYNAMIC_COMPONENT;\n }\n}\nfunction resolveDirective(name) {\n return resolveAsset(DIRECTIVES, name);\n}\nfunction resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {\n const instance = currentRenderingInstance || currentInstance;\n if (instance) {\n const Component = instance.type;\n if (type === COMPONENTS) {\n const selfName = getComponentName(\n Component,\n false\n );\n if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {\n return Component;\n }\n }\n const res = (\n // local registration\n // check instance[type] first which is resolved for options API\n resolve(instance[type] || Component[type], name) || // global registration\n resolve(instance.appContext[type], name)\n );\n if (!res && maybeSelfReference) {\n return Component;\n }\n if (warnMissing && !res) {\n const extra = type === COMPONENTS ? `\nIf this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;\n warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);\n }\n return res;\n } else {\n warn$1(\n `resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`\n );\n }\n}\nfunction resolve(registry, name) {\n return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);\n}\n\nfunction renderList(source, renderItem, cache, index) {\n let ret;\n const cached = cache && cache[index];\n if (isArray(source) || isString(source)) {\n ret = new Array(source.length);\n for (let i = 0, l = source.length; i < l; i++) {\n ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);\n }\n } else if (typeof source === \"number\") {\n if (!Number.isInteger(source)) {\n warn$1(`The v-for range expect an integer value but got ${source}.`);\n }\n ret = new Array(source);\n for (let i = 0; i < source; i++) {\n ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);\n }\n } else if (isObject(source)) {\n if (source[Symbol.iterator]) {\n ret = Array.from(\n source,\n (item, i) => renderItem(item, i, void 0, cached && cached[i])\n );\n } else {\n const keys = Object.keys(source);\n ret = new Array(keys.length);\n for (let i = 0, l = keys.length; i < l; i++) {\n const key = keys[i];\n ret[i] = renderItem(source[key], key, i, cached && cached[i]);\n }\n }\n } else {\n ret = [];\n }\n if (cache) {\n cache[index] = ret;\n }\n return ret;\n}\n\nfunction createSlots(slots, dynamicSlots) {\n for (let i = 0; i < dynamicSlots.length; i++) {\n const slot = dynamicSlots[i];\n if (isArray(slot)) {\n for (let j = 0; j < slot.length; j++) {\n slots[slot[j].name] = slot[j].fn;\n }\n } else if (slot) {\n slots[slot.name] = slot.key ? (...args) => {\n const res = slot.fn(...args);\n if (res) res.key = slot.key;\n return res;\n } : slot.fn;\n }\n }\n return slots;\n}\n\nfunction renderSlot(slots, name, props = {}, fallback, noSlotted) {\n if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {\n if (name !== \"default\") props.name = name;\n return createVNode(\"slot\", props, fallback && fallback());\n }\n let slot = slots[name];\n if (slot && slot.length > 1) {\n warn$1(\n `SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.`\n );\n slot = () => [];\n }\n if (slot && slot._c) {\n slot._d = false;\n }\n openBlock();\n const validSlotContent = slot && ensureValidVNode(slot(props));\n const rendered = createBlock(\n Fragment,\n {\n key: (props.key || // slot content array of a dynamic conditional slot may have a branch\n // key attached in the `createSlots` helper, respect that\n validSlotContent && validSlotContent.key || `_${name}`) + // #7256 force differentiate fallback content from actual content\n (!validSlotContent && fallback ? \"_fb\" : \"\")\n },\n validSlotContent || (fallback ? fallback() : []),\n validSlotContent && slots._ === 1 ? 64 : -2\n );\n if (!noSlotted && rendered.scopeId) {\n rendered.slotScopeIds = [rendered.scopeId + \"-s\"];\n }\n if (slot && slot._c) {\n slot._d = true;\n }\n return rendered;\n}\nfunction ensureValidVNode(vnodes) {\n return vnodes.some((child) => {\n if (!isVNode(child)) return true;\n if (child.type === Comment) return false;\n if (child.type === Fragment && !ensureValidVNode(child.children))\n return false;\n return true;\n }) ? vnodes : null;\n}\n\nfunction toHandlers(obj, preserveCaseIfNecessary) {\n const ret = {};\n if (!isObject(obj)) {\n warn$1(`v-on with no argument expects an object value.`);\n return ret;\n }\n for (const key in obj) {\n ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];\n }\n return ret;\n}\n\nconst getPublicInstance = (i) => {\n if (!i) return null;\n if (isStatefulComponent(i)) return getComponentPublicInstance(i);\n return getPublicInstance(i.parent);\n};\nconst publicPropertiesMap = (\n // Move PURE marker to new line to workaround compiler discarding it\n // due to type annotation\n /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {\n $: (i) => i,\n $el: (i) => i.vnode.el,\n $data: (i) => i.data,\n $props: (i) => shallowReadonly(i.props) ,\n $attrs: (i) => shallowReadonly(i.attrs) ,\n $slots: (i) => shallowReadonly(i.slots) ,\n $refs: (i) => shallowReadonly(i.refs) ,\n $parent: (i) => getPublicInstance(i.parent),\n $root: (i) => getPublicInstance(i.root),\n $emit: (i) => i.emit,\n $options: (i) => resolveMergedOptions(i) ,\n $forceUpdate: (i) => i.f || (i.f = () => {\n i.effect.dirty = true;\n queueJob(i.update);\n }),\n $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),\n $watch: (i) => instanceWatch.bind(i) \n })\n);\nconst isReservedPrefix = (key) => key === \"_\" || key === \"$\";\nconst hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);\nconst PublicInstanceProxyHandlers = {\n get({ _: instance }, key) {\n if (key === \"__v_skip\") {\n return true;\n }\n const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\n if (key === \"__isVue\") {\n return true;\n }\n let normalizedProps;\n if (key[0] !== \"$\") {\n const n = accessCache[key];\n if (n !== void 0) {\n switch (n) {\n case 1 /* SETUP */:\n return setupState[key];\n case 2 /* DATA */:\n return data[key];\n case 4 /* CONTEXT */:\n return ctx[key];\n case 3 /* PROPS */:\n return props[key];\n }\n } else if (hasSetupBinding(setupState, key)) {\n accessCache[key] = 1 /* SETUP */;\n return setupState[key];\n } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\n accessCache[key] = 2 /* DATA */;\n return data[key];\n } else if (\n // only cache other properties when instance has declared (thus stable)\n // props\n (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)\n ) {\n accessCache[key] = 3 /* PROPS */;\n return props[key];\n } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\n accessCache[key] = 4 /* CONTEXT */;\n return ctx[key];\n } else if (shouldCacheAccess) {\n accessCache[key] = 0 /* OTHER */;\n }\n }\n const publicGetter = publicPropertiesMap[key];\n let cssModule, globalProperties;\n if (publicGetter) {\n if (key === \"$attrs\") {\n track(instance.attrs, \"get\", \"\");\n markAttrsAccessed();\n } else if (key === \"$slots\") {\n track(instance, \"get\", key);\n }\n return publicGetter(instance);\n } else if (\n // css module (injected by vue-loader)\n (cssModule = type.__cssModules) && (cssModule = cssModule[key])\n ) {\n return cssModule;\n } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\n accessCache[key] = 4 /* CONTEXT */;\n return ctx[key];\n } else if (\n // global properties\n globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)\n ) {\n {\n return globalProperties[key];\n }\n } else if (currentRenderingInstance && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading\n // to infinite warning loop\n key.indexOf(\"__v\") !== 0)) {\n if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) {\n warn$1(\n `Property ${JSON.stringify(\n key\n )} must be accessed via $data because it starts with a reserved character (\"$\" or \"_\") and is not proxied on the render context.`\n );\n } else if (instance === currentRenderingInstance) {\n warn$1(\n `Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`\n );\n }\n }\n },\n set({ _: instance }, key, value) {\n const { data, setupState, ctx } = instance;\n if (hasSetupBinding(setupState, key)) {\n setupState[key] = value;\n return true;\n } else if (setupState.__isScriptSetup && hasOwn(setupState, key)) {\n warn$1(`Cannot mutate