diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml index 76ea14f1a3c..ce34d8f804a 100644 --- a/.github/ISSUE_TEMPLATE/bug_report.yml +++ b/.github/ISSUE_TEMPLATE/bug_report.yml @@ -7,25 +7,46 @@ body: - type: markdown attributes: value: | - ***Please note: No bug reports are currently being accepted for Wails v3*** - ***Please note: No bug reports are currently being accepted for Wails v3*** - ***Please note: No bug reports are currently being accepted for Wails v3*** Before submitting this issue, please do the following: - Do a web search for your error. This usually leads to a much better understanding of the issue. - - Prove that the error is indeed a Wails bug and not an application bug, with a specific set of steps to reproduce. + - Prove that the error is indeed a Wails bug and not an application bug, with a specific set of steps to reproduce. - Search the issue tracker using [this link](https://github.com/wailsapp/wails/issues?q=is%3Aissue+). - Search the [discussion forums](https://github.com/wailsapp/wails/discussions?discussions_q=type+your+issue+here). - - Read the [Troubleshooting Guide](https://wails.io/docs/next/guides/troubleshooting). + - For v3, check the [FAQ](https://v3.wails.io/faq/) and the [feedback guide](https://v3.wails.io/feedback/). For v2, read the [Troubleshooting Guide](https://wails.io/docs/guides/troubleshooting). - Create a [Minimal Reproducible Example](https://stackoverflow.com/help/minimal-reproducible-example) and link to it in the issue. - - If your issue is related to TypeScript generation, please open a ticket and create a PR with a failing test case. - TS tests can be found [here](https://github.com/wailsapp/wails/tree/master/v2/internal/binding/binding_test). Remember to add - your test to the `binding_test.go` file. - - Try to fix it yourself. Keep a list of things you have done to fix the problem. + - If your issue is related to the bindings or TypeScript generation, please open a ticket and create a PR with a failing test case. + For v3, the binding generator tests live [here](https://github.com/wailsapp/wails/tree/master/v3/internal/generator). + For v2 only, TS tests can be found [here](https://github.com/wailsapp/wails/tree/master/v2/internal/binding/binding_test). Remember to add your test to the `binding_test.go` file. + - Try to fix it yourself. Keep a list of things you have done to fix the problem. If after doing all the above, the problem remains, please continue with this ticket providing *all* the information requested. Bug reports that do not follow these steps will likely be closed, so please help us to help you. + - type: dropdown + id: version_family + attributes: + label: Wails version family + description: Which major version of Wails are you using? + options: + - v3 + - v2 + validations: + required: true + - type: dropdown + id: operating-system + attributes: + label: Operating System + description: Which operating system does the bug occur on? + options: + - Windows + - macOS + - Linux + - iOS (experimental) + - Android (experimental) + - Multiple / Other + validations: + required: true - type: textarea id: description attributes: @@ -75,7 +96,7 @@ body: id: systemdetails attributes: label: System Details - description: Please add the output of `wails doctor`. + description: Please add the output of `wails3 doctor` (for v2 projects, use `wails doctor`). render: shell validations: required: true diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml index e3632ecaae8..299ec7c4441 100644 --- a/.github/ISSUE_TEMPLATE/config.yml +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -1,7 +1,7 @@ -blank_issues_enabled: true +blank_issues_enabled: false contact_links: - name: Discord Chat - url: https://discord.gg/BrRSWTaxVK + url: https://discord.gg/JDdSxwjhGf about: Ask questions and discuss with other Wails users in real time. - name: GitHub Community Discussions diff --git a/.github/ISSUE_TEMPLATE/documentation.yml b/.github/ISSUE_TEMPLATE/documentation.yml index c1259587b66..997fb40f83d 100644 --- a/.github/ISSUE_TEMPLATE/documentation.yml +++ b/.github/ISSUE_TEMPLATE/documentation.yml @@ -20,7 +20,7 @@ body: attributes: label: Have you read the Documentation Contribution Guidelines? options: - - label: I have read the [Documentation Contribution Guidelines](https://wails.io/community-guide#ways-of-contributing). + - label: I have read the [Documentation Contribution Guidelines](https://v3.wails.io/contributing/). required: true - type: textarea diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml index b346c0bdc99..67d5ab0167e 100644 --- a/.github/ISSUE_TEMPLATE/feature_request.yml +++ b/.github/ISSUE_TEMPLATE/feature_request.yml @@ -8,7 +8,7 @@ body: attributes: value: | Before opening a feature request, please check the [Roadmap](https://github.com/wailsapp/wails/discussions/1484) to see if it has already been requested. - ***Please note: No new feature requests are being accepted for Wails v1*** + ***Please note: Enhancements should be discussed in [Ideas](https://github.com/wailsapp/wails/discussions/categories/ideas) on GitHub Discussions or on [Discord](https://discord.gg/JDdSxwjhGf) before opening a feature request. Substantial new functionality should be submitted as a [Wails Enhancement Proposal (WEP)](https://github.com/wailsapp/wails/blob/master/v3/wep/README.md). See the [feedback guide](https://v3.wails.io/feedback/) for details.*** - type: textarea attributes: diff --git a/.github/file-labeler.yml b/.github/file-labeler.yml index 69494cbae0d..d709c68139c 100644 --- a/.github/file-labeler.yml +++ b/.github/file-labeler.yml @@ -1,44 +1,63 @@ -# File path specific labels +# File path specific labels (actions/labeler v5 configuration format) v2-only: - - 'v2/**/*' + - changed-files: + - any-glob-to-any-file: + - 'v2/**/*' v3-alpha: - - 'v3/**/*' + - changed-files: + - any-glob-to-any-file: + - 'v3/**/*' windows: - - '**/*_windows.go' - - 'v2/internal/frontend/desktop/windows/**/*' + - changed-files: + - any-glob-to-any-file: + - '**/*_windows.go' + - 'v2/internal/frontend/desktop/windows/**/*' macos: - - '**/*_darwin.go' - - 'v2/internal/frontend/desktop/darwin/**/*' + - changed-files: + - any-glob-to-any-file: + - '**/*_darwin.go' + - 'v2/internal/frontend/desktop/darwin/**/*' linux: - - '**/*_linux.go' - - 'v2/internal/frontend/desktop/linux/**/*' + - changed-files: + - any-glob-to-any-file: + - '**/*_linux.go' + - 'v2/internal/frontend/desktop/linux/**/*' cli: - - 'v2/cmd/**/*' - - 'v3/cmd/**/*' - - '**/cli/**/*' - - '**/commands/**/*' - + - changed-files: + - any-glob-to-any-file: + - 'v2/cmd/**/*' + - 'v3/cmd/**/*' + - '**/cli/**/*' + - '**/commands/**/*' + documentation: - - '**/*.md' - - 'docs/**/*' - - 'website/**/*' - - 'mkdocs-website/**/*' + - changed-files: + - any-glob-to-any-file: + - '**/*.md' + - 'docs/**/*' + - 'website/**/*' + - 'mkdocs-website/**/*' templates: - - '**/templates/**/*' - - '**/template/**/*' + - changed-files: + - any-glob-to-any-file: + - '**/templates/**/*' + - '**/template/**/*' runtime: - - '**/runtime/**/*' - - 'v2/internal/runtime/**/*' - - 'v3/internal/runtime/**/*' - -bindings: - - 'v2/internal/binding/**/*' - - 'v3/internal/generator/**/*' + - changed-files: + - any-glob-to-any-file: + - '**/runtime/**/*' + - 'v2/internal/runtime/**/*' + - 'v3/internal/runtime/**/*' +bindings: + - changed-files: + - any-glob-to-any-file: + - 'v2/internal/binding/**/*' + - 'v3/internal/generator/**/*' diff --git a/.github/stale.yml b/.github/stale.yml deleted file mode 100644 index d8bcc83ec8c..00000000000 --- a/.github/stale.yml +++ /dev/null @@ -1,36 +0,0 @@ -# Number of days of inactivity before an issue becomes stale -daysUntilStale: 45 -# Number of days of inactivity before a stale issue is closed -daysUntilClose: 10 -# Issues with these labels will never be considered stale -exemptLabels: - - pinned - - security - - onhold - - inprogress - - "Selected For Development" - - bug - - enhancement - - v3-alpha - - high-priority -# Label to use when marking an issue as stale -staleLabel: "stale" -# Comment to post when marking an issue as stale. Set to `false` to disable -markComment: > - This issue has been automatically marked as stale because it has not had - recent activity. It will be closed if no further activity occurs within the next 10 days. - - If this issue is still relevant, please add a comment to keep it open. - Thank you for your contributions. -# Comment to post when closing a stale issue. Set to `false` to disable -closeComment: > - This issue has been automatically closed due to lack of activity. - Please feel free to reopen it if it's still relevant. -exemptMilestones: true -exemptAssignees: true -# Only mark issues (not PRs) -only: issues -# Exempt issues created before a certain date -exemptCreatedBefore: "2024-01-01T00:00:00Z" -# Starts checking issues only after the specified date -startDate: "2025-06-01T00:00:00Z" diff --git a/.github/workflows/auto-changelog-v3.yml b/.github/workflows/auto-changelog-v3.yml index 92ac295e83d..ef11f08a4b6 100644 --- a/.github/workflows/auto-changelog-v3.yml +++ b/.github/workflows/auto-changelog-v3.yml @@ -13,7 +13,7 @@ on: jobs: auto-changelog: - if: github.event.pull_request.merged == true || github.event_name == 'workflow_dispatch' + if: github.repository == 'wailsapp/wails' && (github.event.pull_request.merged == true || github.event_name == 'workflow_dispatch') runs-on: ubuntu-latest env: GOWORK: "off" diff --git a/.github/workflows/build-and-test-v3.yml b/.github/workflows/build-and-test-v3.yml index 14b2fb5f4a2..82dfa8d1bf8 100644 --- a/.github/workflows/build-and-test-v3.yml +++ b/.github/workflows/build-and-test-v3.yml @@ -7,9 +7,6 @@ on: - master paths: - 'v3/**' - - 'webview2/**' - - 'go.work' - - 'go.work.sum' - '.github/workflows/build-and-test-v3.yml' pull_request_review: types: [submitted] @@ -126,8 +123,6 @@ jobs: cache: true cache-dependency-path: | v3/go.sum - webview2/go.sum - go.work.sum - name: Install Task uses: arduino/setup-task@v2 @@ -237,8 +232,6 @@ jobs: cache: true cache-dependency-path: | v3/go.sum - webview2/go.sum - go.work.sum - name: Install Task uses: arduino/setup-task@v2 @@ -274,9 +267,6 @@ jobs: # Replace @wailsio/runtime version with local tarball npm pkg set dependencies.@wailsio/runtime="file://$RUNTIME_TGZ" cd .. - # Register the generated project in the workspace so Go 1.25 workspace - # mode does not reject packages in a module not listed in go.work. - go work use . wails3 build # GTK3 legacy template builds are covered by the Go example compilation tests above. diff --git a/.github/workflows/changelog-v3.yml b/.github/workflows/changelog-v3.yml index c6b1603d0a5..48c644c68d5 100644 --- a/.github/workflows/changelog-v3.yml +++ b/.github/workflows/changelog-v3.yml @@ -15,6 +15,7 @@ on: jobs: validate: runs-on: ubuntu-latest + if: github.repository == 'wailsapp/wails' env: GOWORK: "off" permissions: diff --git a/.github/workflows/cross-compile-test-v3.yml b/.github/workflows/cross-compile-test-v3.yml index fd774bef49b..bd2c42a0a3f 100644 --- a/.github/workflows/cross-compile-test-v3.yml +++ b/.github/workflows/cross-compile-test-v3.yml @@ -7,9 +7,6 @@ on: - master paths: - 'v3/**' - - 'webview2/**' - - 'go.work' - - 'go.work.sum' - '.github/workflows/cross-compile-test-v3.yml' workflow_dispatch: inputs: @@ -82,8 +79,6 @@ jobs: cache: true cache-dependency-path: | v3/go.sum - webview2/go.sum - go.work.sum - name: Install Task uses: arduino/setup-task@v2 diff --git a/.github/workflows/labeler.yml b/.github/workflows/labeler.yml new file mode 100644 index 00000000000..b402be4ef00 --- /dev/null +++ b/.github/workflows/labeler.yml @@ -0,0 +1,36 @@ +name: Auto Labeler + +on: + issues: + types: [opened, edited] + pull_request_target: + +jobs: + issue-labeler: + name: Label issues + if: github.event_name == 'issues' + runs-on: ubuntu-latest + permissions: + contents: read + issues: write + steps: + - uses: github/issue-labeler@v3.4 + with: + repo-token: ${{ secrets.GITHUB_TOKEN }} + configuration-path: .github/issue-labeler.yml + enable-versioned-regex: 0 + include-title: 1 + + pr-labeler: + name: Label pull requests + if: github.event_name == 'pull_request_target' + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write + steps: + - uses: actions/labeler@v5 + with: + repo-token: ${{ secrets.GITHUB_TOKEN }} + configuration-path: .github/file-labeler.yml + sync-labels: false diff --git a/.github/workflows/nightly-release-v3.yml b/.github/workflows/nightly-release-v3.yml index 13a17606e71..0cab4e525f5 100644 --- a/.github/workflows/nightly-release-v3.yml +++ b/.github/workflows/nightly-release-v3.yml @@ -19,6 +19,7 @@ on: jobs: nightly-release: runs-on: ubuntu-latest + if: github.repository == 'wailsapp/wails' env: GOWORK: "off" diff --git a/.github/workflows/publish-npm.yml b/.github/workflows/publish-npm.yml index 180b211d1fa..86b405ec61c 100644 --- a/.github/workflows/publish-npm.yml +++ b/.github/workflows/publish-npm.yml @@ -3,6 +3,9 @@ on: branches: ['master'] paths: - 'v3/internal/runtime/desktop/@wailsio/runtime/**' + # Self-heal: if bundle bytes ever change on master without a matching + # source change, this rebuild overwrites them with source-derived output. + - 'v3/internal/assetserver/bundledassets/**' - '.github/workflows/publish-npm.yml' workflow_dispatch: @@ -13,7 +16,7 @@ concurrency: jobs: detect: name: Detect committed changes - if: github.event_name != 'workflow_dispatch' + if: github.repository == 'wailsapp/wails' && github.event_name != 'workflow_dispatch' outputs: changed: ${{ steps.package-json-changes.outputs.any_modified == 'true' || steps.source-changes.outputs.any_modified == 'true' }} runs-on: ubuntu-latest @@ -43,6 +46,7 @@ jobs: v3/internal/runtime/desktop/@wailsio/compiled/main.js v3/internal/runtime/desktop/@wailsio/runtime/tsconfig.json v3/internal/runtime/desktop/@wailsio/runtime/src/** + v3/internal/assetserver/bundledassets/** v3/pkg/events/events.txt v3/tasks/events/** @@ -50,7 +54,8 @@ jobs: name: Rebuild and publish needs: [detect] if: >- - !failure() && !cancelled() + github.repository == 'wailsapp/wails' + && !failure() && !cancelled() && (github.event_name == 'workflow_dispatch' || needs.detect.outputs.changed == 'true') runs-on: ubuntu-latest permissions: @@ -147,7 +152,20 @@ jobs: echo "Files committed back to master:" git status --short git commit -m "[skip ci] Publish @wailsio/runtime ${{ steps.bump-version.outputs.version }}" - git push + # master moves while this job runs (nightly release, auto-changelog + # commits), so a bare push races and gets rejected — which aborts the + # job before `npm publish` and leaves npm stale. Rebase and retry; + # a real conflict still fails loudly without publishing. + for attempt in 1 2 3 4 5; do + if git push; then + exit 0 + fi + echo "push rejected (attempt ${attempt}); rebasing onto current master" + git pull --rebase origin master + sleep $(( attempt * 5 )) + done + echo "::error::could not push the version bump after 5 attempts" + exit 1 - name: Publish npm package (Trusted Publishing / OIDC) # No NODE_AUTH_TOKEN/NPM_TOKEN: npm exchanges the GitHub OIDC token for a diff --git a/.github/workflows/release-v3.yml b/.github/workflows/release-v3.yml index 586a808345b..f8dd3832053 100644 --- a/.github/workflows/release-v3.yml +++ b/.github/workflows/release-v3.yml @@ -15,6 +15,16 @@ on: required: false default: true type: boolean + allow_unsigned_macos: + description: 'Publish unsigned, un-notarized macOS binaries (only if the Apple secrets are not configured yet)' + required: false + default: false + type: boolean + draft: + description: 'Create the release as a draft (use this to rehearse the release without publishing anything)' + required: false + default: false + type: boolean env: GO_VERSION: '1.25' @@ -25,9 +35,90 @@ permissions: contents: read jobs: + # ── Preflight: fail in seconds, not ten minutes into a build ───────────────── + # + # Everything here is a condition that would otherwise surface late and + # confusingly: a missing Apple secret shows up as an opaque `security import` + # error after three platforms have already built, and a version.txt that + # disagrees with the tag ships a binary that misreports itself with no error + # at all. + preflight: + name: Preflight + runs-on: ubuntu-latest + outputs: + tag: ${{ steps.meta.outputs.tag }} + pre_release: ${{ steps.meta.outputs.pre_release }} + sign_macos: ${{ steps.signing.outputs.sign_macos }} + steps: + - name: Resolve tag and pre-release flag + id: meta + run: | + if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then + TAG="${{ inputs.tag }}" + PRE="${{ inputs.pre_release }}" + else + TAG="${{ github.ref_name }}" + # Tags with a hyphen suffix (v3.0.0-beta.1) are pre-releases. + if [[ "$TAG" == *"-"* ]]; then PRE=true; else PRE=false; fi + fi + echo "tag=$TAG" >> "$GITHUB_OUTPUT" + echo "pre_release=$PRE" >> "$GITHUB_OUTPUT" + echo "Releasing $TAG (pre-release: $PRE)" + + - uses: actions/checkout@v4 + with: + ref: ${{ steps.meta.outputs.tag }} + + - name: Version file agrees with the tag + run: | + TAG="${{ steps.meta.outputs.tag }}" + FILE_VERSION="$(tr -d '[:space:]' < v3/internal/version/version.txt)" + # version.txt is embedded into the binary, so it is what `wails3 + # version` reports. If it disagrees with the tag, the release ships a + # binary that lies about which version it is, silently. + if [[ "$FILE_VERSION" != "$TAG" ]]; then + echo "::error::v3/internal/version/version.txt says '$FILE_VERSION' but the tag is '$TAG'." + echo "::error::The tagged commit must carry the matching version. Re-tag after bumping it." + exit 1 + fi + echo "version.txt matches the tag: $FILE_VERSION" + + - name: Apple signing credentials present + id: signing + env: + APPLE_SIGNING_CERT: ${{ secrets.APPLE_SIGNING_CERT }} + APPLE_CERT_PASSWORD: ${{ secrets.APPLE_CERT_PASSWORD }} + APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }} + APPLE_NOTARIZE_USER: ${{ secrets.APPLE_NOTARIZE_USER }} + APPLE_NOTARIZE_PASSWORD: ${{ secrets.APPLE_NOTARIZE_PASSWORD }} + APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }} + run: | + MISSING=() + for name in APPLE_SIGNING_CERT APPLE_CERT_PASSWORD APPLE_SIGNING_IDENTITY \ + APPLE_NOTARIZE_USER APPLE_NOTARIZE_PASSWORD APPLE_TEAM_ID; do + [[ -z "${!name}" ]] && MISSING+=("$name") + done + + if [[ ${#MISSING[@]} -eq 0 ]]; then + echo "sign_macos=true" >> "$GITHUB_OUTPUT" + echo "All Apple signing secrets are configured." + exit 0 + fi + + if [[ "${{ inputs.allow_unsigned_macos }}" == "true" ]]; then + echo "sign_macos=false" >> "$GITHUB_OUTPUT" + echo "::warning::Missing Apple secrets (${MISSING[*]}). Publishing UNSIGNED macOS binaries because allow_unsigned_macos was set." + exit 0 + fi + + echo "::error::Missing repository secrets: ${MISSING[*]}" + echo "::error::macOS binaries cannot be signed or notarized without them. Configure them," + echo "::error::or re-run with allow_unsigned_macos=true to publish unsigned macOS binaries." + exit 1 # ── Linux binaries (native runners, CGO_ENABLED=0 for static binaries) ────── build-linux: name: Build Linux / ${{ matrix.arch }} + needs: preflight runs-on: ${{ matrix.runner }} strategy: fail-fast: false @@ -40,10 +131,9 @@ jobs: steps: - uses: actions/checkout@v4 with: - # On workflow_dispatch build the requested tag; on tag push inputs.tag - # is empty so github.ref (the tag) is used. Prevents building from the - # branch tip and publishing it under an unrelated tag. - ref: ${{ inputs.tag || github.ref }} + # Preflight resolved the tag for both trigger paths and proved it + # exists, so every job builds the same, verified source. + ref: ${{ needs.preflight.outputs.tag }} - uses: actions/setup-go@v5 with: @@ -73,14 +163,14 @@ jobs: # ── Windows binary ──────────────────────────────────────────────────────────── build-windows: name: Build Windows / amd64 + needs: preflight runs-on: windows-latest steps: - uses: actions/checkout@v4 with: - # On workflow_dispatch build the requested tag; on tag push inputs.tag - # is empty so github.ref (the tag) is used. Prevents building from the - # branch tip and publishing it under an unrelated tag. - ref: ${{ inputs.tag || github.ref }} + # Preflight resolved the tag for both trigger paths and proved it + # exists, so every job builds the same, verified source. + ref: ${{ needs.preflight.outputs.tag }} - uses: actions/setup-go@v5 with: @@ -105,14 +195,14 @@ jobs: # ── macOS: build amd64 + arm64, create universal binary, sign, notarize ────── build-sign-macos: name: Build, Sign & Notarize macOS + needs: preflight runs-on: macos-latest steps: - uses: actions/checkout@v4 with: - # On workflow_dispatch build the requested tag; on tag push inputs.tag - # is empty so github.ref (the tag) is used. Prevents building from the - # branch tip and publishing it under an unrelated tag. - ref: ${{ inputs.tag || github.ref }} + # Preflight resolved the tag for both trigger paths and proved it + # exists, so every job builds the same, verified source. + ref: ${{ needs.preflight.outputs.tag }} - uses: actions/setup-go@v5 with: @@ -141,6 +231,7 @@ jobs: run: lipo -create -output wails3-darwin-universal wails3-darwin-amd64 wails3-darwin-arm64 - name: Import signing certificate + if: needs.preflight.outputs.sign_macos == 'true' env: APPLE_SIGNING_CERT: ${{ secrets.APPLE_SIGNING_CERT }} APPLE_CERT_PASSWORD: ${{ secrets.APPLE_CERT_PASSWORD }} @@ -166,6 +257,7 @@ jobs: security list-keychain -d user -s "$KEYCHAIN_PATH" - name: Sign binaries + if: needs.preflight.outputs.sign_macos == 'true' env: APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }} run: | @@ -179,6 +271,7 @@ jobs: done - name: Notarize macOS binaries + if: needs.preflight.outputs.sign_macos == 'true' env: APPLE_NOTARIZE_USER: ${{ secrets.APPLE_NOTARIZE_USER }} APPLE_NOTARIZE_PASSWORD: ${{ secrets.APPLE_NOTARIZE_PASSWORD }} @@ -206,29 +299,13 @@ jobs: # ── Create GitHub Release and attach all binaries ──────────────────────────── release: name: Publish Release - needs: [build-linux, build-windows, build-sign-macos] + needs: [preflight, build-linux, build-windows, build-sign-macos] runs-on: ubuntu-latest permissions: contents: write + id-token: write # OIDC identity for the provenance attestation + attestations: write steps: - - name: Determine release tag and pre-release flag - id: meta - run: | - if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then - TAG="${{ github.event.inputs.tag }}" - PRE="${{ github.event.inputs.pre_release }}" - else - TAG="${{ github.ref_name }}" - # Treat tags with a hyphen suffix (e.g. v3.0.0-beta.1) as pre-releases - if [[ "$TAG" == *"-"* ]]; then - PRE=true - else - PRE=false - fi - fi - echo "tag=$TAG" >> "$GITHUB_OUTPUT" - echo "pre_release=$PRE" >> "$GITHUB_OUTPUT" - - name: Download all artifacts uses: actions/download-artifact@v4 with: @@ -238,11 +315,29 @@ jobs: - name: List artifacts run: ls -lh dist/ + - name: Generate checksums + working-directory: dist + run: | + # Users have no way to verify a download without these, and generating + # them anywhere other than the job that publishes the binaries defeats + # the point. + sha256sum -- * > SHA256SUMS + cat SHA256SUMS + + - name: Attest build provenance + uses: actions/attest-build-provenance@v4 + with: + # Signed statement of which source, builder and workflow produced each + # binary. The npm package already ships provenance; the binaries + # lagging behind it is an inconsistency users can see. + subject-path: 'dist/wails3-*' + - name: Create or update GitHub Release env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - TAG: ${{ steps.meta.outputs.tag }} - PRE: ${{ steps.meta.outputs.pre_release }} + TAG: ${{ needs.preflight.outputs.tag }} + PRE: ${{ needs.preflight.outputs.pre_release }} + DRAFT: ${{ inputs.draft }} run: | FLAGS=( --repo "${{ github.repository }}" @@ -250,6 +345,10 @@ jobs: --generate-notes ) [[ "$PRE" == "true" ]] && FLAGS+=(--prerelease) + # A draft release is visible only to maintainers and can be deleted, + # which is what makes rehearsing the whole path possible without + # publishing anything. + [[ "$DRAFT" == "true" ]] && FLAGS+=(--draft) # Fail fast if the tag does not exist. Otherwise `gh release create` # would create the tag at an arbitrary commit and publish a release diff --git a/.github/workflows/verify-runtime-assets.yml b/.github/workflows/verify-runtime-assets.yml new file mode 100644 index 00000000000..5832a3c6383 --- /dev/null +++ b/.github/workflows/verify-runtime-assets.yml @@ -0,0 +1,81 @@ +name: Verify Runtime Assets + +# The bundled runtime (v3/internal/assetserver/bundledassets) is go:embed'ed +# into every Wails v3 application, and minified JS cannot be reviewed by eye. +# This check treats those files as an internal build product: any PR that +# touches them, or the source they are built from, must contain exactly the +# bytes a clean rebuild of that PR's source produces. Runs with a read-only +# token and no secrets, so building untrusted PR source here is safe. +# +# The job runs on every PR (and self-skips when no runtime paths changed) so +# it can be marked as a required status check without wedging unrelated PRs. + +on: + pull_request: + branches: [master] + +permissions: + contents: read + +concurrency: + group: verify-runtime-assets-${{ github.event.pull_request.number }} + cancel-in-progress: true + +jobs: + verify: + name: Bundled runtime matches source + runs-on: ubuntu-latest + steps: + - name: Checkout PR merge result + uses: actions/checkout@v4 + with: + fetch-depth: 2 + + - name: Detect runtime asset or source changes + id: changed + run: | + # HEAD is the PR merge commit; HEAD^1 is the base branch tip. + if git diff --name-only HEAD^1 HEAD -- \ + 'v3/internal/assetserver/bundledassets' \ + 'v3/internal/runtime' | grep -q .; then + echo "relevant=true" >> "$GITHUB_OUTPUT" + else + echo "relevant=false" >> "$GITHUB_OUTPUT" + echo "No bundled-runtime or runtime-source changes; nothing to verify." + fi + + - name: Use Node.js 22 + if: steps.changed.outputs.relevant == 'true' + uses: actions/setup-node@v4 + with: + node-version: "22" + + - name: Install Task + if: steps.changed.outputs.relevant == 'true' + uses: arduino/setup-task@v2 + with: + version: 3.x + repo-token: ${{ secrets.GITHUB_TOKEN }} + + - name: Install runtime dependencies (lockfile-exact) + if: steps.changed.outputs.relevant == 'true' + working-directory: v3/internal/runtime/desktop/@wailsio/runtime + run: npm ci + + - name: Rebuild bundled runtime from PR source + if: steps.changed.outputs.relevant == 'true' + working-directory: v3 + run: task runtime:build:assets + + - name: Verify committed bundles match the rebuild + if: steps.changed.outputs.relevant == 'true' + run: | + if ! git diff --exit-code -- v3/internal/assetserver/bundledassets; then + echo "::error::Committed bundled runtime does not match a clean rebuild of this PR's source." + echo "::error::Never hand-edit v3/internal/assetserver/bundledassets. To regenerate:" + echo "::error:: cd v3/internal/runtime/desktop/@wailsio/runtime && npm ci" + echo "::error:: cd ../../../.. && task runtime:build:assets # from the v3 directory" + echo "::error::then commit the result." + exit 1 + fi + echo "Bundled runtime matches its source." diff --git a/.gitignore b/.gitignore index 61efe756b07..c1b4664c5dc 100644 --- a/.gitignore +++ b/.gitignore @@ -95,3 +95,7 @@ v2/cmd/wails/internal/commands/initialise/templates/testtemplates/ # Ignore local iOS test app /v3/testiosapp/ + +# Local Go workspaces are a per-developer concern, not part of the source +go.work +go.work.sum diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 00000000000..3259accfbc4 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,132 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socio-economic status, +nationality, personal appearance, race, caste, color, religion, or sexual +identity and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the overall + community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or advances + of any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email address, + without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official email address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement at +coc@wails.io. +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series of +actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or permanent +ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within the +community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 2.1, available at +[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. + +Community Impact Guidelines were inspired by +[Mozilla's code of conduct enforcement ladder][Mozilla CoC]. + +For answers to common questions about this code of conduct, see the FAQ at +[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at +[https://www.contributor-covenant.org/translations][translations]. + +[homepage]: https://www.contributor-covenant.org +[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html +[Mozilla CoC]: https://github.com/mozilla/diversity +[FAQ]: https://www.contributor-covenant.org/faq +[translations]: https://www.contributor-covenant.org/translations diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 97c95dbcdd6..816973ad4ef 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -15,7 +15,7 @@ Thanks for your interest in contributing! Wails has two active tracks. Pick the - Docs: [v3.wails.io](https://v3.wails.io/). - Detailed contributor guide: [v3.wails.io/contributing](https://v3.wails.io/contributing/). - Changelog: v3 entries are added automatically from your PR on merge. To control the wording, add your own entry to `v3/UNRELEASED_CHANGELOG.md` and the automation will use it instead. -- **Enhancements require prior discussion** on [Discord](https://discord.gg/JDdSxwjhGf) — see the [feedback guide](https://v3.wails.io/getting-started/feedback/). +- **Enhancements require prior discussion** in [Ideas](https://github.com/wailsapp/wails/discussions/categories/ideas) on GitHub Discussions (see the [feedback guide](https://v3.wails.io/feedback/)). Substantial new functionality goes through the [Wails Enhancement Proposal (WEP) process](v3/wep/README.md). ## Pull request checklist diff --git a/docs/src/assets/windows-native-non-client-regions/wails-app-region.mp4 b/docs/src/assets/windows-native-non-client-regions/wails-app-region.mp4 new file mode 100644 index 00000000000..c399b404ea4 Binary files /dev/null and b/docs/src/assets/windows-native-non-client-regions/wails-app-region.mp4 differ diff --git a/docs/src/content/docs/changelog.mdx b/docs/src/content/docs/changelog.mdx index 8d2d3f5dbc1..5425ac6628a 100644 --- a/docs/src/content/docs/changelog.mdx +++ b/docs/src/content/docs/changelog.mdx @@ -31,6 +31,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 */ ## [Unreleased] +## v3.0.0-alpha2.117 - 2026-07-08 + +## Added +- Implement custom hit-test logic for non-client regions on Windows in [PR](https://github.com/wailsapp/wails/pull/5462) by @savely-krasovsky + +## Changed +- Configure WebView2 monitor-scale detection based on UseVisualHosting in [PR](https://github.com/wailsapp/wails/pull/5761) by @wayneforrest + +## v3.0.0-alpha2.116 - 2026-07-07 + +## Added +- Update FAQ documentation to focus on Wails v3 features and guidance in [PR](https://github.com/wailsapp/wails/pull/5763) by @taliesin-ai + +## v3.0.0-alpha2.115 - 2026-07-06 + +## Fixed +- Fix `Menu.Update()` not rebuilding the native menu on GTK4 Linux (#5659, independently diagnosed and fixed by @puneetdixit200 in #5539) +- Fix crash enumerating macOS screens on display change by copying screen id/name strings and snapshotting the count (#5565, independently diagnosed and fixed by @x-haose in #5584) +- Fix crash on Windows when `WM_ERASEBKGND` paints a solid background during a minimise/restore transition where `GetClientRect` returns nil (guard reported by @sinspired in #5636) +- Fix frontend bindings error always parses as text by @mbaklor in #5690 +- Fix Windows build failure when using the `server` build tag, caused by Windows GUI files missing the `!server` build constraint that the macOS and Linux equivalents already have (#5680) + ## v3.0.0-alpha2.114 - 2026-07-05 ## Added diff --git a/docs/src/content/docs/contributing.mdx b/docs/src/content/docs/contributing.mdx index 841c3028298..607b24a1197 100644 --- a/docs/src/content/docs/contributing.mdx +++ b/docs/src/content/docs/contributing.mdx @@ -38,6 +38,18 @@ Contribute code through pull requests: - Performance improvements - Tests +### 4. Propose an Enhancement (WEP) + +Substantial new functionality goes through the Wails Enhancement Proposal (WEP) process. It keeps feature development transparent and ensures every accepted proposal has community support and an implementor. In short: + +1. Optionally float your idea in the [Ideas](https://github.com/wailsapp/wails/discussions/categories/ideas) category on GitHub Discussions or on [Discord](https://discord.gg/JDdSxwjhGf) to gauge interest. +2. Copy [`v3/wep/WEP_TEMPLATE.md`](https://github.com/wailsapp/wails/blob/master/v3/wep/WEP_TEMPLATE.md) to `v3/wep/proposals//proposal.md` and fill in every section. +3. Open a draft pull request titled `[WEP] ` containing only the proposal. The PR is the official place to discuss it. +4. Gather feedback and support (comments and thumbs-up reactions on the PR). Allow at least two weeks for discussion, and agree on who will implement the proposal. +5. Mark the PR ready for review. The maintainers make the final decision: accepted proposals are assigned a WEP number and merged. + +The full process is documented in [`v3/wep/README.md`](https://github.com/wailsapp/wails/blob/master/v3/wep/README.md). + ## Getting Started ### Fork and Clone @@ -241,7 +253,7 @@ npm run dev ### Code of Conduct -Be respectful, inclusive, and professional. We're all here to build great software together. +Be respectful, inclusive, and professional. We're all here to build great software together. See the [Code of Conduct](https://github.com/wailsapp/wails/blob/master/CODE_OF_CONDUCT.md) for details. ## Recognition diff --git a/docs/src/content/docs/features/bindings/methods.mdx b/docs/src/content/docs/features/bindings/methods.mdx index 986f9847dfe..1997a6ae78b 100644 --- a/docs/src/content/docs/features/bindings/methods.mdx +++ b/docs/src/content/docs/features/bindings/methods.mdx @@ -400,6 +400,8 @@ func (d *DatabaseService) GetUser(id int) (*User, error) { ### JavaScript Side +When a bound method fails, the returned promise rejects with a JavaScript `Error` object: + ```javascript import { GetUser } from './bindings/changeme/databaseservice' @@ -407,15 +409,104 @@ try { const user = await GetUser(123) console.log("User:", user) } catch (error) { - console.error("Error:", error) - // Error: "user 123 not found" + console.error(error.message) + // "user 123 not found" +} +``` + +The runtime throws a different error type depending on what went wrong: + +| Error type | Thrown when | +|----------------|------------------------------------------------------------------------------------------------| +| `TypeError` | The call has the wrong number of arguments, or an argument cannot be converted to the Go type | +| `RuntimeError` | The method returned an error, or panicked while running | +| `Error` | Any other failure, for example a call to a method that does not exist | + +Every error provides: +- `name`: the error type from the table above +- `message`: the message of the Go error +- `cause`: the Go error serialised as JSON, where available. If the method returned multiple errors, `cause` is an array with one entry per error. + +The `RuntimeError` class is exported by the `@wailsio/runtime` package, so you can distinguish errors returned by your Go code from other failures: + +```javascript +import { Call } from '@wailsio/runtime' +import { GetUser } from './bindings/changeme/databaseservice' + +try { + const user = await GetUser(123) +} catch (error) { + if (error instanceof Call.RuntimeError) { + // GetUser returned an error + } else { + // The call itself failed + } +} +``` + +:::note +In earlier versions of the runtime, every failed call rejected with a plain `Error` whose message contained the raw JSON of the underlying error. +::: + +### Structured Error Data + +Returning a custom error type from Go makes its JSON form available on the `cause` property of the thrown error: + +```go +type ValidationError struct { + Field string `json:"field"` + Reason string `json:"reason"` +} + +func (e *ValidationError) Error() string { + return fmt.Sprintf("%s: %s", e.Field, e.Reason) +} + +func (s *UserService) UpdateEmail(id int, email string) error { + if !strings.Contains(email, "@") { + return &ValidationError{Field: "email", Reason: "invalid email address"} + } + // ... + return nil +} +``` + +```javascript +import { UpdateEmail } from './bindings/changeme/userservice' + +try { + await UpdateEmail(1, "not-an-email") +} catch (error) { + console.log(error.message) // "email: invalid email address" + console.log(error.cause) // { field: "email", reason: "invalid email address" } } ``` -**Error types:** -- Go `error` → JavaScript exception -- Error message preserved -- Stack trace available +Errors are serialised with the standard `encoding/json` package, so only exported fields are included. Errors created with `errors.New` or `fmt.Errorf` have no exported fields and serialise as an empty object. + +For full control over how errors are serialised, provide a `MarshalError` function in the service options: + +```go +app := application.New(application.Options{ + Services: []application.Service{ + application.NewServiceWithOptions(&UserService{}, application.ServiceOptions{ + MarshalError: func(err error) []byte { + var validationErr *ValidationError + if errors.As(err, &validationErr) { + data, _ := json.Marshal(map[string]string{ + "type": "validation", + "field": validationErr.Field, + }) + return data + } + return nil // fall back to the default serialisation + }, + }), + }, +}) +``` + +`MarshalError` must return valid JSON, or `nil` to fall back to the default serialisation. ## Performance diff --git a/docs/src/content/docs/features/windows/basics.mdx b/docs/src/content/docs/features/windows/basics.mdx index 55a3f623096..0d5bd935f2d 100644 --- a/docs/src/content/docs/features/windows/basics.mdx +++ b/docs/src/content/docs/features/windows/basics.mdx @@ -403,7 +403,7 @@ mainWindow.AttachModal(childWindow) There is no per-window `SetIcon` — the application icon is set on the app via `app.SetIcon([]byte)` (or for a Linux-specific window icon, the `application.LinuxWindow.Icon` field at window creation). **Snap Assist:** - Shows Windows 11 snap layout options for the window. + Shows Windows 11 snap layout options through the system shortcut path. For a custom HTML maximize button with native hover Snap Layouts, use [Native Non-Client Regions on Windows](/features/windows/frameless#native-non-client-regions-on-windows) instead. **Taskbar flashing:** Useful for notifications when window is minimised. diff --git a/docs/src/content/docs/features/windows/frameless.mdx b/docs/src/content/docs/features/windows/frameless.mdx index 0a22a7b763a..aadea7f314e 100644 --- a/docs/src/content/docs/features/windows/frameless.mdx +++ b/docs/src/content/docs/features/windows/frameless.mdx @@ -6,6 +6,7 @@ sidebar: --- import { Tabs, TabItem, Card, CardGrid } from "@astrojs/starlight/components"; +import wailsAppRegionVideo from "../../../../assets/windows-native-non-client-regions/wails-app-region.mp4"; ## Frameless Windows @@ -173,6 +174,156 @@ document.querySelector('.maximize').addEventListener('click', () => Window.Maxim document.querySelector('.close').addEventListener('click', () => Window.Close()) ``` +## Native Non-Client Regions on Windows + +Windows can treat parts of a custom title bar as native non-client areas. This lets you draw the title bar and caption buttons with any HTML/CSS design while keeping native Windows behavior: the caption area drags the window, the maximize button can show Windows 11 Snap Assist / Snap Layouts, and the minimize, maximize, and close buttons receive native hit testing and mouse state. + +The video below shows a custom HTML/CSS title bar using native Windows hit testing, including Windows 11 Snap Assist / Snap Layouts on a custom maximize button. + +<video src={wailsAppRegionVideo} controls muted playsInline></video> + +Wails supports two Windows-specific mechanisms: + +- `app-region` through WebView2's native non-client region support +- `--wails-non-client-region` through Wails runtime tracking for custom caption buttons + +### Choosing a Mode + +:::caution[Experimental] +`WebView2CompositionHosting` changes how the window hosts and interacts with WebView2 under the hood. Instead of the default HWND-hosted WebView2 controller, Wails uses composition controller hosting and forwards input explicitly. This mode may have rendering, input, focus, or WebView2 Runtime compatibility issues. Enable it only when you need native custom caption-button behavior, and test your app carefully on the Windows and WebView2 Runtime versions you support. +::: + +Choose based on what you need from Windows: + +- Use `NonClientRegionSupport` for simple native app dragging with WebView2's `app-region: drag` and `app-region: no-drag`. +- Use `WebView2CompositionHosting` when your custom minimize, maximize, and close buttons should behave like native Windows caption buttons. +- Enable both when the same window needs WebView2-native `app-region` support and Wails-managed custom caption-button regions. + +`NonClientRegionSupport` is the lightweight native alternative to Wails' `--wails-draggable` tracking. You mark draggable and non-draggable areas with CSS, WebView2 decides which pixels belong to the caption, and Wails asks WebView2 for the native region when hit testing. + +That is the full scope of this mode today. It does not make custom minimize, maximize, or close buttons behave like native Windows caption buttons, and it does not enable Windows 11 Snap Assist / Snap Layouts for a custom maximize button. Use it when you need simple native app dragging without the extra machinery of `--wails-draggable`. + +`WebView2CompositionHosting` is for custom caption buttons with native behavior. Wails tracks DOM rectangles marked with `--wails-non-client-region`, maps them to Windows hit-test values such as `HTMINBUTTON`, `HTMAXBUTTON`, and `HTCLOSE`, and forwards mouse input back into the composition-hosted WebView2 surface. That is what allows a custom maximize button to participate in Windows 11 Snap Assist / Snap Layouts while keeping any visual design you choose. + +Put another way: `NonClientRegionSupport` is WebView2-native CSS region support. `WebView2CompositionHosting` is Wails taking responsibility for host-owned composition and custom non-client hit testing. + +### WebView2 app-region + +Enable WebView2's native non-client region support for the window: + +```go +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ + Frameless: true, + Windows: application.WindowsWindow{ + NonClientRegionSupport: true, + }, +}) +``` + +Then mark draggable areas with the CSS `app-region` property: + +```css +.titlebar { + app-region: drag; +} + +.titlebar button, +.titlebar input, +.titlebar select, +.titlebar textarea { + app-region: no-drag; +} +``` + +Use this when you only need native caption dragging and your title bar controls are handled with normal frontend clicks. + +The limitation of this mode is that it is constrained by WebView2's own non-client region support. In current WebView2 releases, that means drag and no-drag regions only. It is not intended to model fully custom frontend caption buttons with distinct native minimize, maximize, and close roles. + +### Custom Caption Buttons with Native Behavior + +For custom minimize, maximize, and close buttons that should behave like system caption buttons, enable composition hosting: + +:::caution[Experimental] +`WebView2CompositionHosting` uses WebView2 composition controller hosting with DirectComposition. See [Choosing a Mode](#choosing-a-mode) before enabling it. +::: + +```go +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ + Frameless: true, + Windows: application.WindowsWindow{ + WebView2CompositionHosting: true, + }, +}) +``` + +Then mark each frontend region with `--wails-non-client-region`: + +```html +<div class="titlebar"> + <div class="title">My Application</div> + <div class="window-controls"> + <button class="window-button minimize" aria-label="Minimize"></button> + <button class="window-button maximize" aria-label="Maximize"></button> + <button class="window-button close" aria-label="Close"></button> + </div> +</div> +``` + +```css +.titlebar { + --wails-non-client-region: caption; + height: 40px; +} + +.window-controls { + display: flex; + height: 100%; +} + +.window-button { + width: 46px; + border: 0; + background: transparent; +} + +.window-button.minimize { + --wails-non-client-region: minimize; +} + +.window-button.maximize { + --wails-non-client-region: maximize; +} + +.window-button.close { + --wails-non-client-region: close; +} +``` + +Supported `--wails-non-client-region` values: + +- `caption` - draggable caption area +- `minimize` - native minimize button hit target +- `maximize` - native maximize button hit target, including Windows 11 Snap Assist / Snap Layouts hover behavior +- `close` - native close button hit target + +The Wails runtime observes DOM, style, size, scroll, and viewport changes, then sends region snapshots to the native window. Region geometry is measured in CSS pixels and converted to physical pixels for Windows hit testing. + +The visual design remains entirely yours. The regions only tell Windows what each rectangle means; the button shape, icon, color, spacing, hover styling, and layout still come from your frontend. + +### Combining Both + +You can enable both options when you want WebView2 `app-region` support and Wails-managed caption button regions in the same window: + +```go +window := app.Window.NewWithOptions(application.WebviewWindowOptions{ + Frameless: true, + Windows: application.WindowsWindow{ + NonClientRegionSupport: true, + WebView2CompositionHosting: true, + }, +}) +``` + ## System Buttons ### Implementing Close/Minimise/Maximise @@ -358,6 +509,7 @@ body { // Trigger Windows 11 Snap Assist window.SnapAssist() ``` + This triggers Snap Layouts through the Windows hotkey path. For a custom HTML maximize button with native hover Snap Layouts, use [Native Non-Client Regions on Windows](#native-non-client-regions-on-windows) instead. **Custom title bar height:** Windows automatically detects drag regions from CSS. diff --git a/docs/src/content/docs/features/windows/options.mdx b/docs/src/content/docs/features/windows/options.mdx index 0595e951f00..9319acb5b8d 100644 --- a/docs/src/content/docs/features/windows/options.mdx +++ b/docs/src/content/docs/features/windows/options.mdx @@ -948,6 +948,8 @@ Windows: application.WindowsWindow{ BackdropType: application.Auto, CustomTheme: application.ThemeSettings{}, DisableFramelessWindowDecorations: false, + NonClientRegionSupport: false, + WebView2CompositionHosting: false, }, ``` @@ -973,6 +975,15 @@ There are no `WindowsBackdropTypeMica`-style constants — use `application.Mica **DisableFramelessWindowDecorations** (`bool`) - Disable default frameless decorations (Aero shadow, rounded corners). +**NonClientRegionSupport** (`bool`) +- Enables WebView2-native `app-region: drag` / `app-region: no-drag` support for frameless custom title bars. +- This is for simple native app dragging only. It does not provide native custom caption-button behavior or Windows 11 Snap Assist / Snap Layouts for custom maximize buttons. + +**WebView2CompositionHosting** (`bool`) +- Enables Wails-managed `--wails-non-client-region` support for custom caption buttons with native Windows behavior, including Windows 11 Snap Assist / Snap Layouts on custom maximize buttons. +- Experimental. This hosts WebView2 through `ICoreWebView2CompositionController` and DirectComposition instead of the default HWND-hosted controller. +- Can be combined with `NonClientRegionSupport` when a window needs both WebView2-native `app-region` support and Wails-managed custom caption-button regions. + **Example:** ```go @@ -982,6 +993,17 @@ Windows: application.WindowsWindow{ }, ``` +**Example - Custom Windows title bar regions:** + +```go +Windows: application.WindowsWindow{ + NonClientRegionSupport: true, + WebView2CompositionHosting: true, +}, +``` + +See [Frameless Windows](/features/windows/frameless#native-non-client-regions-on-windows) for the detailed behavior, tradeoffs, and matching CSS. + ### Linux Options (per-window) The per-window struct is `application.LinuxWindow` — **not** `LinuxOptions`. diff --git a/docs/src/content/docs/feedback.mdx b/docs/src/content/docs/feedback.mdx index c56de054982..6c426d759db 100644 --- a/docs/src/content/docs/feedback.mdx +++ b/docs/src/content/docs/feedback.mdx @@ -47,6 +47,7 @@ discussions before creating new ones. Here are the different ways to contribute: - Clearly describe the feature and the problem it solves. - Feel free to also discuss ideas in the [#v3](https://discord.gg/bdj28QNHmT) channel on Discord. + - Substantial new functionality goes through the [Wails Enhancement Proposal (WEP) process](https://github.com/wailsapp/wails/blob/master/v3/wep/README.md), a structured proposal that is discussed with the community on its pull request before being accepted for implementation. See the [contributing guide](/contributing/#4-propose-an-enhancement-wep) for a summary. </TabItem> diff --git a/go.work b/go.work deleted file mode 100644 index 1fbc5f094c4..00000000000 --- a/go.work +++ /dev/null @@ -1,5 +0,0 @@ -go 1.25.0 - -use ( - ./v3 -) diff --git a/go.work.sum b/go.work.sum deleted file mode 100644 index 91461c0a1f5..00000000000 --- a/go.work.sum +++ /dev/null @@ -1,41 +0,0 @@ -cyphar.com/go-pathrs v0.2.1/go.mod h1:y8f1EMG7r+hCuFf/rXsKqMJrJAUoADZGNh5/vZPKcGc= -github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg= -github.com/bits-and-blooms/bitset v1.24.4/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= -github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= -github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= -github.com/caarlos0/go-version v0.2.2/go.mod h1:X+rI5VAtJDpcjCjeEIXpxGa5+rTcgur1FK66wS0/944= -github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao= -github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= -github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= -github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= -github.com/google/renameio/v2 v2.0.0/go.mod h1:BtmJXm5YlszgC+TD4HOEEUFgkJP3nLxehU6hfe7jRt4= -github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= -github.com/invopop/jsonschema v0.13.0/go.mod h1:ffZ5Km5SWWRAIN6wbDXItl95euhFz2uON45H2qjYt+0= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= -github.com/muesli/mango v0.2.0/go.mod h1:5XFpbC8jY5UUv89YQciiXNlbi+iJgt29VDC5xbzrLL4= -github.com/muesli/mango-cobra v1.3.0/go.mod h1:Cj1ZrBu3806Qw7UjxnAUgE+7tllUBj1NCLQDwwGx19E= -github.com/muesli/mango-pflag v0.1.0/go.mod h1:YEQomTxaCUp8PrbhFh10UfbhbQrM/xJ4i2PB8VTLLW0= -github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig= -github.com/otiai10/copy v1.14.0/go.mod h1:ECfuL02W+/FkTWZWgQqXPWZgW9oeKCSQ5qVfSc4qc4w= -github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= -github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik= -github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y= -github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= -github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U= -github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg= -github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4= -github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY= -github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= -github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw= -golang.org/x/telemetry v0.0.0-20260409153401-be6f6cb8b1fa/go.mod h1:kHjTxDEnAu6/Nl9lDkzjWpR+bmKfxeiRuSDlsMb70gE= -golang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY= -golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated/go.mod h1:RVAQXBGNv1ib0J382/DPCRS/BPnsGebyM1Gj5VSDpG8= -google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= -mvdan.cc/editorconfig v0.3.0/go.mod h1:NcJHuDtNOTEJ6251indKiWuzK6+VcrMuLzGMLKBFupQ= diff --git a/v2/cmd/wails/internal/version.txt b/v2/cmd/wails/internal/version.txt index a5db00c8c11..311f78b667b 100644 --- a/v2/cmd/wails/internal/version.txt +++ b/v2/cmd/wails/internal/version.txt @@ -1 +1 @@ -v2.12.0 \ No newline at end of file +v2.13.0 \ No newline at end of file diff --git a/v3/examples/mac-window-tabs/Taskfile.yml b/v3/examples/mac-window-tabs/Taskfile.yml index bba79236acc..6a06761e83a 100644 --- a/v3/examples/mac-window-tabs/Taskfile.yml +++ b/v3/examples/mac-window-tabs/Taskfile.yml @@ -8,12 +8,12 @@ includes: # This example is a standalone Go module (its own go.mod, with a `replace` # pointing at the local Wails checkout because MacWindowTabbingMode is not in a -# published release yet). It physically lives under v3/, which is a member of -# the repo's root go.work. An active workspace would shadow this module: binding -# generation would find 0 services and `go mod tidy` would target v3 instead. -# Force workspace mode off so the example always builds as itself. This is -# inherited by the wails3 dev/build subprocess tree and is a harmless no-op -# outside the monorepo, where there is no go.work. +# published release yet). It physically lives under v3/, so any go.work that +# covers v3 would shadow this module: binding generation would find 0 services +# and `go mod tidy` would target v3 instead. The repo no longer ships a +# workspace file, but contributors often create one locally, so force workspace +# mode off and the example always builds as itself. This is inherited by the +# wails3 dev/build subprocess tree and is a harmless no-op everywhere else. env: GOWORK: "off" diff --git a/v3/examples/mac-window-tabs/build/Taskfile.yml b/v3/examples/mac-window-tabs/build/Taskfile.yml index 9322dc9c3be..b09e92f7560 100644 --- a/v3/examples/mac-window-tabs/build/Taskfile.yml +++ b/v3/examples/mac-window-tabs/build/Taskfile.yml @@ -1,9 +1,10 @@ version: '3' # See the note in ../Taskfile.yml: this example is a standalone module nested -# under v3/, so an active go.work would shadow it. Force workspace mode off here -# too, so the Go-tooling tasks (go mod tidy, generate bindings, go build) behave -# correctly even when invoked directly rather than via the root dev/build tasks. +# under v3/, so a local go.work covering v3 would shadow it. Force workspace +# mode off here too, so the Go-tooling tasks (go mod tidy, generate bindings, +# go build) behave correctly even when invoked directly rather than via the +# root dev/build tasks. env: GOWORK: "off" diff --git a/v3/internal/assetserver/bundledassets/runtime.debug.js b/v3/internal/assetserver/bundledassets/runtime.debug.js index 3b9b9b4918b..4cf80000d7d 100644 --- a/v3/internal/assetserver/bundledassets/runtime.debug.js +++ b/v3/internal/assetserver/bundledassets/runtime.debug.js @@ -82,6 +82,17 @@ function runtimeURL() { return window.location.origin + "/wails/runtime"; } var CHUNK_THRESHOLD = 512 * 1024; +var RuntimeError = class extends Error { + /** + * Constructs a new RuntimeError instance. + * @param message - The error message. + * @param options - Options to be forwarded to the Error constructor. + */ + constructor(message, options) { + super(message, options); + this.name = "RuntimeError"; + } +}; var objectNames = Object.freeze({ Call: 0, Clipboard: 1, @@ -138,6 +149,26 @@ async function runtimeCallWithID(objectID, method, windowName, args) { response = await fetch(url, { method: "POST", headers, body: bodyStr }); } if (!response.ok) { + const ct = response.headers.get("Content-Type"); + if (ct == null ? void 0 : ct.includes("application/json")) { + const json = await response.json(); + let err; + switch (json.kind) { + case "ReferenceError": + err = new ReferenceError(json.message); + break; + case "TypeError": + err = new TypeError(json.message); + break; + case "RuntimeError": + err = new RuntimeError(json.message); + break; + default: + err = new Error(json.message); + } + err.cause = json.cause; + throw err; + } throw new Error(await response.text()); } if (((_b = (_a3 = response.headers.get("Content-Type")) == null ? void 0 : _a3.indexOf("application/json")) != null ? _b : -1) !== -1) { @@ -322,6 +353,7 @@ __export(create_exports, { Any: () => Any, Array: () => Array2, ByteSlice: () => ByteSlice, + DateFromTime: () => DateFromTime, Events: () => Events, Map: () => Map2, Nullable: () => Nullable, @@ -387,6 +419,9 @@ function Struct(createField) { return source; }; } +function DateFromTime(source) { + return new Date(source); +} var Events = {}; // desktop/@wailsio/runtime/src/event_types.ts @@ -573,7 +608,8 @@ var Types = Object.freeze({ WindowWillUseStandardFrame: "mac:WindowWillUseStandardFrame", WindowZoomIn: "mac:WindowZoomIn", WindowZoomOut: "mac:WindowZoomOut", - WindowZoomReset: "mac:WindowZoomReset" + WindowZoomReset: "mac:WindowZoomReset", + WebViewWebContentProcessDidTerminate: "mac:WebViewWebContentProcessDidTerminate" }), Linux: Object.freeze({ ApplicationStartup: "linux:ApplicationStartup", @@ -1281,8 +1317,8 @@ var _Window = class _Window { * Gathers information about the drop target element and sends it back to the Go backend. * * @param filenames - An array of file paths (strings) that were dropped. - * @param x - The x-coordinate of the drop event (CSS pixels). - * @param y - The y-coordinate of the drop event (CSS pixels). + * @param x - The x-coordinate of the drop event, in logical (CSS) pixels relative to the webview. + * @param y - The y-coordinate of the drop event, in logical (CSS) pixels relative to the webview. */ HandlePlatformFileDrop(filenames, x, y) { var _a3, _b; @@ -1875,6 +1911,9 @@ function primaryDown(event) { } } if (resizeEdge) { + if (event.type !== "mousedown") { + return; + } canResize = true; return; } @@ -1955,6 +1994,164 @@ function onMouseMove(event) { else setResize(); } +// desktop/@wailsio/runtime/src/appregion.ts +var regionProperty = "--wails-non-client-region"; +var runtimeConfigReadyEvent = "wails:runtime-config-ready"; +var validRegions = /* @__PURE__ */ new Set(["caption", "minimize", "maximize", "close"]); +if (hasDOM) { + window._wails = window._wails || {}; +} +var updatePending = false; +var lastPayload = ""; +var observedElements = /* @__PURE__ */ new Set(); +var resizeObserver; +var trackingStarted = false; +function normaliseRegionKind(value) { + const region = value.trim().toLowerCase(); + if (validRegions.has(region)) { + return region; + } + return void 0; +} +function nonClientRegionForElement(element) { + if (!(element instanceof HTMLElement)) { + return void 0; + } + const style = window.getComputedStyle(element); + const region = normaliseRegionKind(style.getPropertyValue(regionProperty)); + if (!region) { + return void 0; + } + const parent = element.parentElement; + if (parent) { + const parentStyle = window.getComputedStyle(parent); + if (normaliseRegionKind(parentStyle.getPropertyValue(regionProperty)) === region) { + return void 0; + } + } + return region; +} +function isVisible(element) { + const style = window.getComputedStyle(element); + return style.display !== "none" && style.visibility !== "hidden" && style.contentVisibility !== "hidden"; +} +function elementRegion(element) { + if (!(element instanceof HTMLElement)) { + return void 0; + } + const kind = nonClientRegionForElement(element); + if (!kind || !isVisible(element)) { + return void 0; + } + const rect = element.getBoundingClientRect(); + if (rect.width <= 0 || rect.height <= 0) { + return void 0; + } + const scale = window.devicePixelRatio || 1; + const left = Math.floor(rect.left * scale); + const top = Math.floor(rect.top * scale); + const right = Math.ceil(rect.right * scale); + const bottom = Math.ceil(rect.bottom * scale); + if (right <= left || bottom <= top) { + return void 0; + } + return { kind, left, top, right, bottom }; +} +function regionElements() { + const elements = []; + if (document.documentElement) { + elements.push(document.documentElement); + } + if (document.body) { + elements.push(document.body); + for (const element of document.body.querySelectorAll("*")) { + elements.push(element); + } + } + return elements; +} +function observeRegionElements(elements) { + if (typeof ResizeObserver === "undefined") { + return; + } + resizeObserver != null ? resizeObserver : resizeObserver = new ResizeObserver(scheduleUpdate); + const nextElements = new Set(elements); + for (const element of observedElements) { + if (!nextElements.has(element)) { + resizeObserver.unobserve(element); + } + } + for (const element of nextElements) { + if (!observedElements.has(element)) { + resizeObserver.observe(element); + } + } + observedElements = nextElements; +} +function updateNonClientRegions() { + updatePending = false; + const elements = regionElements(); + const regions = []; + const activeElements = []; + for (const element of elements) { + const region = elementRegion(element); + if (region) { + regions.push(region); + activeElements.push(element); + } + } + observeRegionElements(activeElements); + const payload = JSON.stringify({ version: 1, regions }); + if (payload === lastPayload) { + return; + } + lastPayload = payload; + invoke("wails:non-client-region:" + payload); +} +function scheduleUpdate() { + if (updatePending) { + return; + } + updatePending = true; + window.requestAnimationFrame(updateNonClientRegions); +} +function startNonClientRegionTracking() { + var _a3, _b; + if (trackingStarted) { + return; + } + trackingStarted = true; + scheduleUpdate(); + const mutationObserver = new MutationObserver(scheduleUpdate); + mutationObserver.observe(document.documentElement, { + attributes: true, + childList: true, + subtree: true + }); + window.addEventListener("resize", scheduleUpdate); + window.addEventListener("scroll", scheduleUpdate, true); + (_a3 = window.visualViewport) == null ? void 0 : _a3.addEventListener("resize", scheduleUpdate); + (_b = window.visualViewport) == null ? void 0 : _b.addEventListener("scroll", scheduleUpdate); +} +function tryStartNonClientRegionTracking() { + var _a3, _b; + const os = (_a3 = window._wails.environment) == null ? void 0 : _a3.OS; + if (os === void 0) { + return false; + } + const enabled = (_b = window._wails.flags) == null ? void 0 : _b.nonClientRegionTracking; + if (os === "windows") { + if (enabled === true) { + whenReady(startNonClientRegionTracking); + } + return true; + } + return true; +} +if (hasDOM && !tryStartNonClientRegionTracking()) { + window.addEventListener(runtimeConfigReadyEvent, tryStartNonClientRegionTracking, { once: true }); +} + // desktop/@wailsio/runtime/src/application.ts var application_exports = {}; __export(application_exports, { @@ -2788,17 +2985,6 @@ var cancelCall = newRuntimeCaller(objectNames.CancelCall); var callResponses = /* @__PURE__ */ new Map(); var CallBinding = 0; var CancelMethod = 0; -var RuntimeError = class extends Error { - /** - * Constructs a new RuntimeError instance. - * @param message - The error message. - * @param options - Options to be forwarded to the Error constructor. - */ - constructor(message, options) { - super(message, options); - this.name = "RuntimeError"; - } -}; function generateID() { let result; do { @@ -3056,4 +3242,4 @@ export { objectNames, setTransport }; -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../runtime/desktop/@wailsio/runtime/src/index.ts", "../../runtime/desktop/@wailsio/runtime/src/wml.ts", "../../runtime/desktop/@wailsio/runtime/src/browser.ts", "../../runtime/desktop/@wailsio/runtime/src/nanoid.ts", "../../runtime/desktop/@wailsio/runtime/src/environment.ts", "../../runtime/desktop/@wailsio/runtime/src/runtime.ts", "../../runtime/desktop/@wailsio/runtime/src/dialogs.ts", "../../runtime/desktop/@wailsio/runtime/src/events.ts", "../../runtime/desktop/@wailsio/runtime/src/listener.ts", "../../runtime/desktop/@wailsio/runtime/src/create.ts", "../../runtime/desktop/@wailsio/runtime/src/event_types.ts", "../../runtime/desktop/@wailsio/runtime/src/utils.ts", "../../runtime/desktop/@wailsio/runtime/src/window.ts", "../../runtime/desktop/compiled/main.js", "../../runtime/desktop/@wailsio/runtime/src/system.ts", "../../runtime/desktop/@wailsio/runtime/src/contextmenu.ts", "../../runtime/desktop/@wailsio/runtime/src/flags.ts", "../../runtime/desktop/@wailsio/runtime/src/drag.ts", "../../runtime/desktop/@wailsio/runtime/src/application.ts", "../../runtime/desktop/@wailsio/runtime/src/calls.ts", "../../runtime/desktop/@wailsio/runtime/src/callable.ts", "../../runtime/desktop/@wailsio/runtime/src/cancellable.ts", "../../runtime/desktop/@wailsio/runtime/src/clipboard.ts", "../../runtime/desktop/@wailsio/runtime/src/screens.ts", "../../runtime/desktop/@wailsio/runtime/src/ios.ts", "../../runtime/desktop/@wailsio/runtime/src/android.ts", "../../runtime/desktop/@wailsio/runtime/src/updater.ts"],
  "sourcesContent": ["/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Setup\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    window._wails = window._wails || {};\n}\n\nimport \"./contextmenu.js\";\nimport \"./drag.js\";\n\n// Re-export public API\nimport * as Application from \"./application.js\";\nimport * as Browser from \"./browser.js\";\nimport * as Call from \"./calls.js\";\nimport * as Clipboard from \"./clipboard.js\";\nimport * as Create from \"./create.js\";\nimport * as Dialogs from \"./dialogs.js\";\nimport * as Events from \"./events.js\";\nimport * as Flags from \"./flags.js\";\nimport * as Screens from \"./screens.js\";\nimport * as System from \"./system.js\";\nimport * as IOS from \"./ios.js\";\nimport * as Android from \"./android.js\";\nimport * as Updater from \"./updater.js\";\nimport Window, { handleDragEnter, handleDragLeave, handleDragOver } from \"./window.js\";\nimport * as WML from \"./wml.js\";\n\nexport {\n    Application,\n    Browser,\n    Call,\n    Clipboard,\n    Dialogs,\n    Events,\n    Flags,\n    Screens,\n    System,\n    IOS,\n    Android,\n    Updater,\n    Window,\n    WML\n};\n\n/**\n * An internal utility consumed by the binding generator.\n *\n * @ignore\n */\nexport { Create };\n\nexport * from \"./cancellable.js\";\n\n// Export transport interfaces and utilities\nexport {\n    setTransport,\n    getTransport,\n    type RuntimeTransport,\n    objectNames,\n    clientId,\n} from \"./runtime.js\";\n\nimport { clientId } from \"./runtime.js\";\n\n// Notify backend\nif (hasDOM) {\n    window._wails.invoke = System.invoke;\n    window._wails.clientId = clientId;\n}\n\n// Register platform handlers (internal API)\n// Note: Window is the thisWindow instance (default export from window.ts)\n// Binding ensures 'this' correctly refers to the current window instance\nif (hasDOM) {\n    window._wails.handlePlatformFileDrop = Window.HandlePlatformFileDrop.bind(Window);\n}\n\n// Linux-specific drag handlers (GTK intercepts DOM drag events)\nif (hasDOM) {\n    window._wails.handleDragEnter = handleDragEnter;\n    window._wails.handleDragLeave = handleDragLeave;\n    window._wails.handleDragOver = handleDragOver;\n}\n\nif (hasDOM) {\n    System.invoke(\"wails:runtime:ready\");\n}\n\n/**\n * Loads a script from the given URL if it exists.\n * Uses HEAD request to check existence, then injects a script tag.\n * Silently ignores if the script doesn't exist.\n */\nexport function loadOptionalScript(url: string): Promise<void> {\n    return fetch(url, { method: 'HEAD' })\n        .then(response => {\n            if (response.ok) {\n                // Verify the response is actually JavaScript and not an HTML fallback\n                // (e.g. Vite dev server returns index.html for unknown routes)\n                const contentType = (response.headers.get('content-type') || '').toLowerCase();\n                if (contentType.includes('javascript')) {\n                    const script = document.createElement('script');\n                    script.src = url;\n                    document.head.appendChild(script);\n                }\n            }\n        })\n        .catch(() => {}); // Silently ignore - script is optional\n}\n\n// Load custom.js if available (used by server mode for WebSocket events, etc.)\nif (hasDOM) {\n    loadOptionalScript('/wails/custom.js');\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { OpenURL } from \"./browser.js\";\nimport { Question } from \"./dialogs.js\";\nimport { Emit } from \"./events.js\";\nimport { canAbortListeners, whenReady } from \"./utils.js\";\nimport Window from \"./window.js\";\n\n/**\n * Sends an event with the given name and optional data.\n *\n * @param eventName - - The name of the event to send.\n * @param [data=null] - - Optional data to send along with the event.\n */\nfunction sendEvent(eventName: string, data: any = null): void {\n    Emit(eventName, data);\n}\n\n/**\n * Calls a method on a specified window.\n *\n * @param windowName - The name of the window to call the method on.\n * @param methodName - The name of the method to call.\n */\nfunction callWindowMethod(windowName: string, methodName: string) {\n    const targetWindow = Window.Get(windowName);\n    const method = (targetWindow as any)[methodName];\n\n    if (typeof method !== \"function\") {\n        console.error(`Window method '${methodName}' not found`);\n        return;\n    }\n\n    try {\n        method.call(targetWindow);\n    } catch (e) {\n        console.error(`Error calling window method '${methodName}': `, e);\n    }\n}\n\n/**\n * Responds to a triggering event by running appropriate WML actions for the current target.\n */\nfunction onWMLTriggered(ev: Event): void {\n    const element = ev.currentTarget as Element;\n\n    function runEffect(choice = \"Yes\") {\n        if (choice !== \"Yes\")\n            return;\n\n        const eventType = element.getAttribute('wml-event') || element.getAttribute('data-wml-event');\n        const targetWindow = element.getAttribute('wml-target-window') || element.getAttribute('data-wml-target-window') || \"\";\n        const windowMethod = element.getAttribute('wml-window') || element.getAttribute('data-wml-window');\n        const url = element.getAttribute('wml-openurl') || element.getAttribute('data-wml-openurl');\n\n        if (eventType !== null)\n            sendEvent(eventType);\n        if (windowMethod !== null)\n            callWindowMethod(targetWindow, windowMethod);\n        if (url !== null)\n            void OpenURL(url);\n    }\n\n    const confirm = element.getAttribute('wml-confirm') || element.getAttribute('data-wml-confirm');\n\n    if (confirm) {\n        Question({\n            Title: \"Confirm\",\n            Message: confirm,\n            Detached: false,\n            Buttons: [\n                { Label: \"Yes\" },\n                { Label: \"No\", IsDefault: true }\n            ]\n        }).then(runEffect);\n    } else {\n        runEffect();\n    }\n}\n\n// Private field names.\nconst controllerSym = Symbol(\"controller\");\nconst triggerMapSym = Symbol(\"triggerMap\");\nconst elementCountSym = Symbol(\"elementCount\");\n\n/**\n * AbortControllerRegistry does not actually remember active event listeners: instead\n * it ties them to an AbortSignal and uses an AbortController to remove them all at once.\n */\nclass AbortControllerRegistry {\n    // Private fields.\n    [controllerSym]: AbortController;\n\n    constructor() {\n        this[controllerSym] = new AbortController();\n    }\n\n    /**\n     * Returns an options object for addEventListener that ties the listener\n     * to the AbortSignal from the current AbortController.\n     *\n     * @param element - An HTML element\n     * @param triggers - The list of active WML trigger events for the specified elements\n     */\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\n        return { signal: this[controllerSym].signal };\n    }\n\n    /**\n     * Removes all registered event listeners and resets the registry.\n     */\n    reset(): void {\n        this[controllerSym].abort();\n        this[controllerSym] = new AbortController();\n    }\n}\n\n/**\n * WeakMapRegistry maps active trigger events to each DOM element through a WeakMap.\n * This ensures that the mapping remains private to this module, while still allowing garbage\n * collection of the involved elements.\n */\nclass WeakMapRegistry {\n    /** Stores the current element-to-trigger mapping. */\n    [triggerMapSym]: WeakMap<Element, string[]>;\n    /** Counts the number of elements with active WML triggers. */\n    [elementCountSym]: number;\n\n    constructor() {\n        this[triggerMapSym] = new WeakMap();\n        this[elementCountSym] = 0;\n    }\n\n    /**\n     * Sets active triggers for the specified element.\n     *\n     * @param element - An HTML element\n     * @param triggers - The list of active WML trigger events for the specified element\n     */\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\n        if (!this[triggerMapSym].has(element)) { this[elementCountSym]++; }\n        this[triggerMapSym].set(element, triggers);\n        return {};\n    }\n\n    /**\n     * Removes all registered event listeners.\n     */\n    reset(): void {\n        if (this[elementCountSym] <= 0)\n            return;\n\n        for (const element of document.body.querySelectorAll('*')) {\n            if (this[elementCountSym] <= 0)\n                break;\n\n            const triggers = this[triggerMapSym].get(element);\n            if (triggers != null) { this[elementCountSym]--; }\n\n            for (const trigger of triggers || [])\n                element.removeEventListener(trigger, onWMLTriggered);\n        }\n\n        this[triggerMapSym] = new WeakMap();\n        this[elementCountSym] = 0;\n    }\n}\n\nconst triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();\n\n/**\n * Adds event listeners to the specified element.\n */\nfunction addWMLListeners(element: Element): void {\n    const triggerRegExp = /\\S+/g;\n    const triggerAttr = (element.getAttribute('wml-trigger') || element.getAttribute('data-wml-trigger') || \"click\");\n    const triggers: string[] = [];\n\n    let match;\n    while ((match = triggerRegExp.exec(triggerAttr)) !== null)\n        triggers.push(match[0]);\n\n    const options = triggerRegistry.set(element, triggers);\n    for (const trigger of triggers)\n        element.addEventListener(trigger, onWMLTriggered, options);\n}\n\n/**\n * Schedules an automatic reload of WML to be performed as soon as the document is fully loaded.\n */\nexport function Enable(): void {\n    whenReady(Reload);\n}\n\n/**\n * Reloads the WML page by adding necessary event listeners and browser listeners.\n */\nexport function Reload(): void {\n    triggerRegistry.reset();\n    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]').forEach(addWMLListeners);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Browser);\n\nconst BrowserOpenURL = 0;\n\n/**\n * Open a browser window to the given URL.\n *\n * @param url - The URL to open\n */\nexport function OpenURL(url: string | URL): Promise<void> {\n    return call(BrowserOpenURL, {url: url.toString()});\n}\n", "// Source: https://github.com/ai/nanoid\n\n// The MIT License (MIT)\n//\n// Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n//     subject to the following conditions:\n//\n//     The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n//     THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// This alphabet uses `A-Za-z0-9_-` symbols.\n// The order of characters is optimized for better gzip and brotli compression.\n// References to the same file (works both for gzip and brotli):\n// `'use`, `andom`, and `rict'`\n// References to the brotli default dictionary:\n// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`\nconst urlAlphabet =\n    'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\n\nexport function nanoid(size: number = 21): string {\n    let id = ''\n    // A compact alternative for `for (var i = 0; i < step; i++)`.\n    let i = size | 0\n    while (i--) {\n        // `| 0` is more compact and faster than `Math.floor()`.\n        id += urlAlphabet[(Math.random() * 64) | 0]\n    }\n    return id\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * True when running inside a browser/webview with a DOM available.\n * False under server-side rendering (e.g. `next build` prerendering),\n * where application code may import the runtime module even though no\n * Wails APIs can actually be used (#4679). Modules must not touch\n * `window`/`document` at import time except behind this guard.\n */\nexport const hasDOM = typeof window !== \"undefined\" && typeof document !== \"undefined\";\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { nanoid } from \"./nanoid.js\";\nimport { hasDOM } from \"./environment.js\";\n\n// Resolved lazily: window does not exist when the module is imported during\n// server-side rendering (#4679), and nothing can call the runtime there.\nfunction runtimeURL(): string {\n    return window.location.origin + \"/wails/runtime\";\n}\n\n// Stay under WebView2's ~2MB request body buffering limit in WebResourceRequested.\nconst CHUNK_THRESHOLD = 512 * 1024;\n\n// Re-export nanoid for custom transport implementations\nexport { nanoid };\n\n// Object Names\nexport const objectNames = Object.freeze({\n    Call: 0,\n    Clipboard: 1,\n    Application: 2,\n    Events: 3,\n    ContextMenu: 4,\n    Dialog: 5,\n    Window: 6,\n    Screens: 7,\n    System: 8,\n    Browser: 9,\n    CancelCall: 10,\n    IOS: 11,\n    Android: 12,\n});\nexport let clientId = nanoid();\n\n/**\n * RuntimeTransport defines the interface for custom IPC transport implementations.\n * Implement this interface to use WebSockets, custom protocols, or any other\n * transport mechanism instead of the default HTTP fetch.\n */\nexport interface RuntimeTransport {\n    /**\n     * Send a runtime call and return the response.\n     *\n     * @param objectID - The Wails object ID (0=Call, 1=Clipboard, etc.)\n     * @param method - The method ID to call\n     * @param windowName - Optional window name\n     * @param args - Arguments to pass (will be JSON stringified if present)\n     * @returns Promise that resolves with the response data\n     */\n    call(objectID: number, method: number, windowName: string, args: any): Promise<any>;\n}\n\n/**\n * Custom transport implementation (can be set by user)\n */\nlet customTransport: RuntimeTransport | null = null;\n\n/**\n * Set a custom transport for all Wails runtime calls.\n * This allows you to replace the default HTTP fetch transport with\n * WebSockets, custom protocols, or any other mechanism.\n *\n * @param transport - Your custom transport implementation\n *\n * @example\n * ```typescript\n * import { setTransport } from '/wails/runtime.js';\n *\n * const wsTransport = {\n *   call: async (objectID, method, windowName, args) => {\n *     // Your WebSocket implementation\n *   }\n * };\n *\n * setTransport(wsTransport);\n * ```\n */\nexport function setTransport(transport: RuntimeTransport | null): void {\n    customTransport = transport;\n}\n\n/**\n * Get the current transport (useful for extending/wrapping)\n */\nexport function getTransport(): RuntimeTransport | null {\n    return customTransport;\n}\n\n/**\n * Creates a new runtime caller with specified ID.\n *\n * @param object - The object to invoke the method on.\n * @param windowName - The name of the window.\n * @return The new runtime caller function.\n */\nexport function newRuntimeCaller(object: number, windowName: string = '') {\n    return function (method: number, args: any = null) {\n        return runtimeCallWithID(object, method, windowName, args);\n    };\n}\n\nasync function runtimeCallWithID(objectID: number, method: number, windowName: string, args: any): Promise<any> {\n    // Use custom transport if available\n    if (customTransport) {\n        return customTransport.call(objectID, method, windowName, args);\n    }\n\n    // Default HTTP fetch transport\n    let url = new URL(runtimeURL());\n\n    let body: { object: number; method: number, args?: any } = {\n      object: objectID,\n      method\n    }\n    if (args !== null && args !== undefined) {\n      body.args = args;\n    }\n\n    let headers: Record<string, string> = {\n        [\"x-wails-client-id\"]: clientId,\n        [\"Content-Type\"]: \"application/json\"\n    }\n    if (windowName) {\n        headers[\"x-wails-window-name\"] = windowName;\n    }\n\n    const bodyStr = JSON.stringify(body);\n    let response: Response;\n    if (bodyStr.length > CHUNK_THRESHOLD) {\n        response = await sendChunked(url, headers, bodyStr);\n    } else {\n        response = await fetch(url, { method: 'POST', headers, body: bodyStr });\n    }\n    if (!response.ok) {\n        throw new Error(await response.text());\n    }\n\n    if ((response.headers.get(\"Content-Type\")?.indexOf(\"application/json\") ?? -1) !== -1) {\n        return response.json();\n    } else {\n        return response.text();\n    }\n}\n\n// sendChunked splits a large serialised request body into CHUNK_THRESHOLD-sized\n// byte chunks and sends them serially.  Encoding to UTF-8 bytes before slicing\n// prevents corruption of non-BMP characters (surrogate pairs) that would occur\n// when splitting at JavaScript string indices.  The Go transport assembles the\n// raw bytes before processing.  Only the final chunk's response carries the RPC result.\nasync function sendChunked(url: URL, headers: Record<string, string>, bodyStr: string): Promise<Response> {\n    const chunkId = nanoid();\n    const bodyBytes = new TextEncoder().encode(bodyStr);\n    const totalChunks = Math.ceil(bodyBytes.length / CHUNK_THRESHOLD);\n\n    for (let i = 0; i < totalChunks - 1; i++) {\n        const chunk = bodyBytes.subarray(i * CHUNK_THRESHOLD, (i + 1) * CHUNK_THRESHOLD);\n        const resp = await fetch(url, {\n            method: 'POST',\n            headers: {\n                ...headers,\n                'x-wails-chunk-id': chunkId,\n                'x-wails-chunk-index': String(i),\n                'x-wails-chunk-total': String(totalChunks),\n            },\n            body: chunk,\n        });\n        if (!resp.ok) {\n            throw new Error(await resp.text());\n        }\n    }\n\n    return fetch(url, {\n        method: 'POST',\n        headers: {\n            ...headers,\n            'x-wails-chunk-id': chunkId,\n            'x-wails-chunk-index': String(totalChunks - 1),\n            'x-wails-chunk-total': String(totalChunks),\n        },\n        body: bodyBytes.subarray((totalChunks - 1) * CHUNK_THRESHOLD),\n    });\n}\n\n/**\n * Android WebView cannot deliver fetch() POST bodies to\n * shouldInterceptRequest, so the default HTTP transport cannot reach Go.\n * When the Android JavascriptInterface bridge (window.wails) is present,\n * route runtime calls through it instead. Responses arrive via\n * window._wailsAndroidCallback, invoked by the Java side.\n */\ninterface AndroidJSBridge {\n    invokeAsync(callbackID: string, payload: string): void;\n}\n\nconst androidBridge: AndroidJSBridge | null = hasDOM &&\n    typeof (window as any).wails?.invokeAsync === \"function\" ? (window as any).wails : null;\n\nif (androidBridge) {\n    const pending = new Map<string, { resolve: (value: any) => void; reject: (reason: any) => void }>();\n\n    (window as any)._wailsAndroidCallback = (id: string, response: string | null, error: string | null) => {\n        const promise = pending.get(id);\n        if (!promise) return;\n        pending.delete(id);\n        if (error) {\n            promise.reject(new Error(error));\n            return;\n        }\n        try {\n            const envelope = JSON.parse(response ?? \"{}\");\n            if (!envelope.ok) {\n                promise.reject(new Error(envelope.error ?? \"unknown runtime call error\"));\n                return;\n            }\n            promise.resolve(\"text\" in envelope ? envelope.text : envelope.data);\n        } catch (e) {\n            promise.reject(e);\n        }\n    };\n\n    customTransport = {\n        call(objectID: number, method: number, windowName: string, args: any): Promise<any> {\n            return new Promise((resolve, reject) => {\n                const id = nanoid();\n                pending.set(id, { resolve, reject });\n                try {\n                    androidBridge.invokeAsync(id, JSON.stringify({\n                        object: objectID,\n                        method: method,\n                        windowName: windowName,\n                        args: args ?? null,\n                        clientId: clientId,\n                    }));\n                } catch (e) {\n                    // Don't leak the pending entry if dispatch throws synchronously\n                    pending.delete(id);\n                    reject(e);\n                }\n            });\n        },\n    };\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\n\n// setup\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    window._wails = window._wails || {};\n}\n\nconst call = newRuntimeCaller(objectNames.Dialog);\n\n// Define constants from the `methods` object in Title Case\nconst DialogInfo = 0;\nconst DialogWarning = 1;\nconst DialogError = 2;\nconst DialogQuestion = 3;\nconst DialogOpenFile = 4;\nconst DialogSaveFile = 5;\n\nexport interface OpenFileDialogOptions {\n    /** Indicates if directories can be chosen. */\n    CanChooseDirectories?: boolean;\n    /** Indicates if files can be chosen. */\n    CanChooseFiles?: boolean;\n    /** Indicates if directories can be created. */\n    CanCreateDirectories?: boolean;\n    /** Indicates if hidden files should be shown. */\n    ShowHiddenFiles?: boolean;\n    /** Indicates if aliases should be resolved. */\n    ResolvesAliases?: boolean;\n    /** Indicates if multiple selection is allowed. */\n    AllowsMultipleSelection?: boolean;\n    /** Indicates if the extension should be hidden. */\n    HideExtension?: boolean;\n    /** Indicates if hidden extensions can be selected. */\n    CanSelectHiddenExtension?: boolean;\n    /** Indicates if file packages should be treated as directories. */\n    TreatsFilePackagesAsDirectories?: boolean;\n    /** Indicates if other file types are allowed. */\n    AllowsOtherFiletypes?: boolean;\n    /** Array of file filters. */\n    Filters?: FileFilter[];\n    /** Title of the dialog. */\n    Title?: string;\n    /** Message to show in the dialog. */\n    Message?: string;\n    /** Text to display on the button. */\n    ButtonText?: string;\n    /** Directory to open in the dialog. */\n    Directory?: string;\n    /** Indicates if the dialog should appear detached from the main window. */\n    Detached?: boolean;\n}\n\nexport interface SaveFileDialogOptions {\n    /** Default filename to use in the dialog. */\n    Filename?: string;\n    /** Indicates if directories can be chosen. */\n    CanChooseDirectories?: boolean;\n    /** Indicates if files can be chosen. */\n    CanChooseFiles?: boolean;\n    /** Indicates if directories can be created. */\n    CanCreateDirectories?: boolean;\n    /** Indicates if hidden files should be shown. */\n    ShowHiddenFiles?: boolean;\n    /** Indicates if aliases should be resolved. */\n    ResolvesAliases?: boolean;\n    /** Indicates if the extension should be hidden. */\n    HideExtension?: boolean;\n    /** Indicates if hidden extensions can be selected. */\n    CanSelectHiddenExtension?: boolean;\n    /** Indicates if file packages should be treated as directories. */\n    TreatsFilePackagesAsDirectories?: boolean;\n    /** Indicates if other file types are allowed. */\n    AllowsOtherFiletypes?: boolean;\n    /** Array of file filters. */\n    Filters?: FileFilter[];\n    /** Title of the dialog. */\n    Title?: string;\n    /** Message to show in the dialog. */\n    Message?: string;\n    /** Text to display on the button. */\n    ButtonText?: string;\n    /** Directory to open in the dialog. */\n    Directory?: string;\n    /** Indicates if the dialog should appear detached from the main window. */\n    Detached?: boolean;\n}\n\nexport interface MessageDialogOptions {\n    /** The title of the dialog window. */\n    Title?: string;\n    /** The main message to show in the dialog. */\n    Message?: string;\n    /** Array of button options to show in the dialog. */\n    Buttons?: Button[];\n    /** True if the dialog should appear detached from the main window (if applicable). */\n    Detached?: boolean;\n}\n\nexport interface Button {\n    /** Text that appears within the button. */\n    Label?: string;\n    /** True if the button should cancel an operation when clicked. */\n    IsCancel?: boolean;\n    /** True if the button should be the default action when the user presses enter. */\n    IsDefault?: boolean;\n}\n\nexport interface FileFilter {\n    /** Display name for the filter, it could be \"Text Files\", \"Images\" etc. */\n    DisplayName?: string;\n    /** Pattern to match for the filter, e.g. \"*.txt;*.md\" for text markdown files. */\n    Pattern?: string;\n}\n\n/**\n * Presents a dialog of specified type with the given options.\n *\n * @param type - Dialog type.\n * @param options - Options for the dialog.\n * @returns A promise that resolves with result of dialog.\n */\nfunction dialog(type: number, options: MessageDialogOptions | OpenFileDialogOptions | SaveFileDialogOptions = {}): Promise<any> {\n    return call(type, options);\n}\n\n/**\n * Presents an info dialog.\n *\n * @param options - Dialog options\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Info(options: MessageDialogOptions): Promise<string> { return dialog(DialogInfo, options); }\n\n/**\n * Presents a warning dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Warning(options: MessageDialogOptions): Promise<string> { return dialog(DialogWarning, options); }\n\n/**\n * Presents an error dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Error(options: MessageDialogOptions): Promise<string> { return dialog(DialogError, options); }\n\n/**\n * Presents a question dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Question(options: MessageDialogOptions): Promise<string> { return dialog(DialogQuestion, options); }\n\n/**\n * Presents a file selection dialog to pick one or more files to open.\n *\n * @param options - Dialog options.\n * @returns Selected file or list of files, or a blank string/empty list if no file has been selected.\n */\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection: true }): Promise<string[]>;\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection?: false | undefined }): Promise<string>;\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]>;\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]> { return dialog(DialogOpenFile, options) ?? []; }\n\n/**\n * Presents a file selection dialog to pick a file to save.\n *\n * @param options - Dialog options.\n * @returns Selected file, or a blank string if no file has been selected.\n */\nexport function SaveFile(options: SaveFileDialogOptions): Promise<string> { return dialog(DialogSaveFile, options); }\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { eventListeners, Listener, listenerOff } from \"./listener.js\";\nimport { Events as Create } from \"./create.js\";\nimport { Types } from \"./event_types.js\";\n\n// Setup\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    window._wails = window._wails || {};\n    window._wails.dispatchWailsEvent = dispatchWailsEvent;\n}\n\nconst call = newRuntimeCaller(objectNames.Events);\nconst EmitMethod = 0;\n\nexport * from \"./event_types.js\";\n\n/**\n * A table of data types for all known events.\n * Will be monkey-patched by the binding generator.\n */\nexport interface CustomEvents {}\n\n/**\n * Either a known event name or an arbitrary string.\n */\nexport type WailsEventName<E extends keyof CustomEvents = keyof CustomEvents> = E | (string & {});\n\n/**\n * Union of all known system event names.\n */\ntype SystemEventName = {\n    [K in keyof (typeof Types)]: (typeof Types)[K][keyof ((typeof Types)[K])]\n} extends (infer M) ? M[keyof M] : never;\n\n/**\n * The data type associated to a given event.\n */\nexport type WailsEventData<E extends WailsEventName = WailsEventName> =\n    E extends keyof CustomEvents ? CustomEvents[E] : (E extends SystemEventName ? void : any);\n\n/**\n * The type of handlers for a given event.\n */\nexport type WailsEventCallback<E extends WailsEventName = WailsEventName> = (ev: WailsEvent<E>) => void;\n\n/**\n * Represents a system event or a custom event emitted through wails-provided facilities.\n */\nexport class WailsEvent<E extends WailsEventName = WailsEventName> {\n    /**\n     * The name of the event.\n     */\n    name: E;\n\n    /**\n     * Optional data associated with the emitted event.\n     */\n    data: WailsEventData<E>;\n\n    /**\n     * Name of the originating window. Omitted for application events.\n     * Will be overridden if set manually.\n     */\n    sender?: string;\n\n    constructor(name: E, data: WailsEventData<E>);\n    constructor(name: WailsEventData<E> extends null | void ? E : never)\n    constructor(name: E, data?: any) {\n        this.name = name;\n        this.data = data ?? null;\n    }\n}\n\nfunction dispatchWailsEvent(event: any) {\n    let listeners = eventListeners.get(event.name);\n    if (!listeners) {\n        return;\n    }\n\n    let wailsEvent = new WailsEvent(\n        event.name,\n        (event.name in Create) ? Create[event.name](event.data) : event.data\n    );\n    if ('sender' in event) {\n        wailsEvent.sender = event.sender;\n    }\n\n    // Dispatch to a snapshot, then remove all expired listeners in a single\n    // post-dispatch filter of the live map.\n    // - Writing the snapshot back wholesale would undo subscription changes\n    //   made inside a handler (#4393).\n    // - Calling listenerOff() per expired listener inside the loop is O(n\u00B2)\n    //   when many listeners expire on the same event.\n    // Filtering the live array once after dispatch is O(n) and still honours\n    // any listeners added or removed by handlers during dispatch.\n    const expired = new Set<Listener>();\n    for (const listener of listeners.slice()) {\n        if (listener.dispatch(wailsEvent)) {\n            expired.add(listener);\n        }\n    }\n    if (expired.size > 0) {\n        const live = eventListeners.get(event.name);\n        if (live) {\n            const remaining = live.filter(l => !expired.has(l));\n            if (remaining.length === 0) {\n                eventListeners.delete(event.name);\n            } else {\n                eventListeners.set(event.name, remaining);\n            }\n        }\n    }\n}\n\n/**\n * Register a callback function to be called multiple times for a specific event.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @param maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function OnMultiple<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>, maxCallbacks: number) {\n    let listeners = eventListeners.get(eventName) || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    listeners.push(thisListener);\n    eventListeners.set(eventName, listeners);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers a callback function to be executed when the specified event occurs.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function On<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void {\n    return OnMultiple(eventName, callback, -1);\n}\n\n/**\n * Registers a callback function to be executed only once for the specified event.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function Once<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void {\n    return OnMultiple(eventName, callback, 1);\n}\n\n/**\n * Removes event listeners for the specified event names.\n *\n * @param eventNames - The name of the events to remove listeners for.\n */\nexport function Off(...eventNames: [WailsEventName, ...WailsEventName[]]): void {\n    eventNames.forEach(eventName => eventListeners.delete(eventName));\n}\n\n/**\n * Removes all event listeners.\n */\nexport function OffAll(): void {\n    eventListeners.clear();\n}\n\n/**\n * Emits an event.\n *\n * @returns A promise that will be fulfilled once the event has been emitted.  Resolves to true if the event was cancelled.\n * @param name - The name of the event to emit\n * @param data - The data that will be sent with the event\n */\nexport function Emit<E extends WailsEventName = WailsEventName>(name: E, data: WailsEventData<E>): Promise<boolean>\nexport function Emit<E extends WailsEventName = WailsEventName>(name: WailsEventData<E> extends null | void ? E : never): Promise<boolean>\nexport function Emit<E extends WailsEventName = WailsEventName>(name: WailsEventData<E>, data?: any): Promise<boolean> {\n    return call(EmitMethod,  new WailsEvent(name, data))\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// The following utilities have been factored out of ./events.ts\n// for testing purposes.\n\nexport const eventListeners = new Map<string, Listener[]>();\n\nexport class Listener {\n    eventName: string;\n    callback: (data: any) => void;\n    maxCallbacks: number;\n\n    constructor(eventName: string, callback: (data: any) => void, maxCallbacks: number) {\n        this.eventName = eventName;\n        this.callback = callback;\n        this.maxCallbacks = maxCallbacks || -1;\n    }\n\n    dispatch(data: any): boolean {\n        try {\n            this.callback(data);\n        } catch (err) {\n            console.error(err);\n        }\n\n        if (this.maxCallbacks === -1) return false;\n        this.maxCallbacks -= 1;\n        return this.maxCallbacks === 0;\n    }\n}\n\nexport function listenerOff(listener: Listener): void {\n    let listeners = eventListeners.get(listener.eventName);\n    if (!listeners) {\n        return;\n    }\n\n    listeners = listeners.filter(l => l !== listener);\n    if (listeners.length === 0) {\n        eventListeners.delete(listener.eventName);\n    } else {\n        eventListeners.set(listener.eventName, listeners);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Any is a dummy creation function for simple or unknown types.\n */\nexport function Any<T = any>(source: any): T {\n    return source;\n}\n\n/**\n * ByteSlice is a creation function that replaces\n * null strings with empty strings.\n */\nexport function ByteSlice(source: any): string {\n    return ((source == null) ? \"\" : source);\n}\n\n/**\n * Array takes a creation function for an arbitrary type\n * and returns an in-place creation function for an array\n * whose elements are of that type.\n */\nexport function Array<T = any>(element: (source: any) => T): (source: any) => T[] {\n    if (element === Any) {\n        return (source) => (source === null ? [] : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return [];\n        }\n        for (let i = 0; i < source.length; i++) {\n            source[i] = element(source[i]);\n        }\n        return source;\n    };\n}\n\n/**\n * Map takes creation functions for two arbitrary types\n * and returns an in-place creation function for an object\n * whose keys and values are of those types.\n */\nexport function Map<K extends PropertyKey = any, V = any>(key: (source: any) => K, value: (source: any) => V): (source: any) => Record<K, V> {\n    if (value === Any) {\n        return (source) => (source === null ? {} : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return {};\n        }\n        for (const key in source) {\n            source[key] = value(source[key]);\n        }\n        return source;\n    };\n}\n\n/**\n * Nullable takes a creation function for an arbitrary type\n * and returns a creation function for a nullable value of that type.\n */\nexport function Nullable<T = any>(element: (source: any) => T): (source: any) => (T | null) {\n    if (element === Any) {\n        return Any;\n    }\n\n    return (source) => (source === null ? null : element(source));\n}\n\n/**\n * Struct takes an object mapping field names to creation functions\n * and returns an in-place creation function for a struct.\n */\nexport function Struct(createField: Record<string, (source: any) => any>):\n    <U extends Record<string, any> = any>(source: any) => U\n{\n    let allAny = true;\n    for (const name in createField) {\n        if (createField[name] !== Any) {\n            allAny = false;\n            break;\n        }\n    }\n    if (allAny) {\n        return Any;\n    }\n\n    return (source) => {\n        for (const name in createField) {\n            if (name in source) {\n                source[name] = createField[name](source[name]);\n            }\n        }\n        return source;\n    };\n}\n\n/**\n * Maps known event names to creation functions for their data types.\n * Will be monkey-patched by the binding generator.\n */\nexport const Events: Record<string, (source: any) => any> = {};\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH \u00C2 MODIWL\n// This file is automatically generated. DO NOT EDIT\n\nexport const Types = Object.freeze({\n\tWindows: Object.freeze({\n\t\tAPMPowerSettingChange: \"windows:APMPowerSettingChange\",\n\t\tAPMPowerStatusChange: \"windows:APMPowerStatusChange\",\n\t\tAPMResumeAutomatic: \"windows:APMResumeAutomatic\",\n\t\tAPMResumeSuspend: \"windows:APMResumeSuspend\",\n\t\tAPMSuspend: \"windows:APMSuspend\",\n\t\tApplicationStarted: \"windows:ApplicationStarted\",\n\t\tSystemThemeChanged: \"windows:SystemThemeChanged\",\n\t\tWebViewNavigationCompleted: \"windows:WebViewNavigationCompleted\",\n\t\tWindowActive: \"windows:WindowActive\",\n\t\tWindowBackgroundErase: \"windows:WindowBackgroundErase\",\n\t\tWindowClickActive: \"windows:WindowClickActive\",\n\t\tWindowClosing: \"windows:WindowClosing\",\n\t\tWindowDidMove: \"windows:WindowDidMove\",\n\t\tWindowDidResize: \"windows:WindowDidResize\",\n\t\tWindowDPIChanged: \"windows:WindowDPIChanged\",\n\t\tWindowDragDrop: \"windows:WindowDragDrop\",\n\t\tWindowDragEnter: \"windows:WindowDragEnter\",\n\t\tWindowDragLeave: \"windows:WindowDragLeave\",\n\t\tWindowDragOver: \"windows:WindowDragOver\",\n\t\tWindowEndMove: \"windows:WindowEndMove\",\n\t\tWindowEndResize: \"windows:WindowEndResize\",\n\t\tWindowFullscreen: \"windows:WindowFullscreen\",\n\t\tWindowHide: \"windows:WindowHide\",\n\t\tWindowInactive: \"windows:WindowInactive\",\n\t\tWindowKeyDown: \"windows:WindowKeyDown\",\n\t\tWindowKeyUp: \"windows:WindowKeyUp\",\n\t\tWindowKillFocus: \"windows:WindowKillFocus\",\n\t\tWindowNonClientHit: \"windows:WindowNonClientHit\",\n\t\tWindowNonClientMouseDown: \"windows:WindowNonClientMouseDown\",\n\t\tWindowNonClientMouseLeave: \"windows:WindowNonClientMouseLeave\",\n\t\tWindowNonClientMouseMove: \"windows:WindowNonClientMouseMove\",\n\t\tWindowNonClientMouseUp: \"windows:WindowNonClientMouseUp\",\n\t\tWindowPaint: \"windows:WindowPaint\",\n\t\tWindowRestore: \"windows:WindowRestore\",\n\t\tWindowSetFocus: \"windows:WindowSetFocus\",\n\t\tWindowShow: \"windows:WindowShow\",\n\t\tWindowStartMove: \"windows:WindowStartMove\",\n\t\tWindowStartResize: \"windows:WindowStartResize\",\n\t\tWindowUnFullscreen: \"windows:WindowUnFullscreen\",\n\t\tWindowZOrderChanged: \"windows:WindowZOrderChanged\",\n\t\tWindowMinimise: \"windows:WindowMinimise\",\n\t\tWindowUnMinimise: \"windows:WindowUnMinimise\",\n\t\tWindowMaximise: \"windows:WindowMaximise\",\n\t\tWindowUnMaximise: \"windows:WindowUnMaximise\",\n\t}),\n\tMac: Object.freeze({\n\t\tApplicationDidBecomeActive: \"mac:ApplicationDidBecomeActive\",\n\t\tApplicationDidChangeBackingProperties: \"mac:ApplicationDidChangeBackingProperties\",\n\t\tApplicationDidChangeEffectiveAppearance: \"mac:ApplicationDidChangeEffectiveAppearance\",\n\t\tApplicationDidChangeIcon: \"mac:ApplicationDidChangeIcon\",\n\t\tApplicationDidChangeOcclusionState: \"mac:ApplicationDidChangeOcclusionState\",\n\t\tApplicationDidChangeScreenParameters: \"mac:ApplicationDidChangeScreenParameters\",\n\t\tApplicationDidChangeStatusBarFrame: \"mac:ApplicationDidChangeStatusBarFrame\",\n\t\tApplicationDidChangeStatusBarOrientation: \"mac:ApplicationDidChangeStatusBarOrientation\",\n\t\tApplicationDidChangeTheme: \"mac:ApplicationDidChangeTheme\",\n\t\tApplicationDidFinishLaunching: \"mac:ApplicationDidFinishLaunching\",\n\t\tApplicationDidHide: \"mac:ApplicationDidHide\",\n\t\tApplicationDidResignActive: \"mac:ApplicationDidResignActive\",\n\t\tApplicationDidUnhide: \"mac:ApplicationDidUnhide\",\n\t\tApplicationDidUpdate: \"mac:ApplicationDidUpdate\",\n\t\tApplicationDidWake: \"mac:ApplicationDidWake\",\n\t\tApplicationScreensDidSleep: \"mac:ApplicationScreensDidSleep\",\n\t\tApplicationScreensDidWake: \"mac:ApplicationScreensDidWake\",\n\t\tApplicationShouldHandleReopen: \"mac:ApplicationShouldHandleReopen\",\n\t\tApplicationWillBecomeActive: \"mac:ApplicationWillBecomeActive\",\n\t\tApplicationWillFinishLaunching: \"mac:ApplicationWillFinishLaunching\",\n\t\tApplicationWillHide: \"mac:ApplicationWillHide\",\n\t\tApplicationWillResignActive: \"mac:ApplicationWillResignActive\",\n\t\tApplicationWillSleep: \"mac:ApplicationWillSleep\",\n\t\tApplicationWillTerminate: \"mac:ApplicationWillTerminate\",\n\t\tApplicationWillUnhide: \"mac:ApplicationWillUnhide\",\n\t\tApplicationWillUpdate: \"mac:ApplicationWillUpdate\",\n\t\tMenuDidAddItem: \"mac:MenuDidAddItem\",\n\t\tMenuDidBeginTracking: \"mac:MenuDidBeginTracking\",\n\t\tMenuDidClose: \"mac:MenuDidClose\",\n\t\tMenuDidDisplayItem: \"mac:MenuDidDisplayItem\",\n\t\tMenuDidEndTracking: \"mac:MenuDidEndTracking\",\n\t\tMenuDidHighlightItem: \"mac:MenuDidHighlightItem\",\n\t\tMenuDidOpen: \"mac:MenuDidOpen\",\n\t\tMenuDidPopUp: \"mac:MenuDidPopUp\",\n\t\tMenuDidRemoveItem: \"mac:MenuDidRemoveItem\",\n\t\tMenuDidSendAction: \"mac:MenuDidSendAction\",\n\t\tMenuDidSendActionToItem: \"mac:MenuDidSendActionToItem\",\n\t\tMenuDidUpdate: \"mac:MenuDidUpdate\",\n\t\tMenuWillAddItem: \"mac:MenuWillAddItem\",\n\t\tMenuWillBeginTracking: \"mac:MenuWillBeginTracking\",\n\t\tMenuWillDisplayItem: \"mac:MenuWillDisplayItem\",\n\t\tMenuWillEndTracking: \"mac:MenuWillEndTracking\",\n\t\tMenuWillHighlightItem: \"mac:MenuWillHighlightItem\",\n\t\tMenuWillOpen: \"mac:MenuWillOpen\",\n\t\tMenuWillPopUp: \"mac:MenuWillPopUp\",\n\t\tMenuWillRemoveItem: \"mac:MenuWillRemoveItem\",\n\t\tMenuWillSendAction: \"mac:MenuWillSendAction\",\n\t\tMenuWillSendActionToItem: \"mac:MenuWillSendActionToItem\",\n\t\tMenuWillUpdate: \"mac:MenuWillUpdate\",\n\t\tWebViewDidCommitNavigation: \"mac:WebViewDidCommitNavigation\",\n\t\tWebViewDidFinishNavigation: \"mac:WebViewDidFinishNavigation\",\n\t\tWebViewDidReceiveServerRedirectForProvisionalNavigation: \"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation\",\n\t\tWebViewDidStartProvisionalNavigation: \"mac:WebViewDidStartProvisionalNavigation\",\n\t\tWindowDidBecomeKey: \"mac:WindowDidBecomeKey\",\n\t\tWindowDidBecomeMain: \"mac:WindowDidBecomeMain\",\n\t\tWindowDidBeginSheet: \"mac:WindowDidBeginSheet\",\n\t\tWindowDidChangeAlpha: \"mac:WindowDidChangeAlpha\",\n\t\tWindowDidChangeBackingLocation: \"mac:WindowDidChangeBackingLocation\",\n\t\tWindowDidChangeBackingProperties: \"mac:WindowDidChangeBackingProperties\",\n\t\tWindowDidChangeCollectionBehavior: \"mac:WindowDidChangeCollectionBehavior\",\n\t\tWindowDidChangeEffectiveAppearance: \"mac:WindowDidChangeEffectiveAppearance\",\n\t\tWindowDidChangeOcclusionState: \"mac:WindowDidChangeOcclusionState\",\n\t\tWindowDidChangeOrderingMode: \"mac:WindowDidChangeOrderingMode\",\n\t\tWindowDidChangeScreen: \"mac:WindowDidChangeScreen\",\n\t\tWindowDidChangeScreenParameters: \"mac:WindowDidChangeScreenParameters\",\n\t\tWindowDidChangeScreenProfile: \"mac:WindowDidChangeScreenProfile\",\n\t\tWindowDidChangeScreenSpace: \"mac:WindowDidChangeScreenSpace\",\n\t\tWindowDidChangeScreenSpaceProperties: \"mac:WindowDidChangeScreenSpaceProperties\",\n\t\tWindowDidChangeSharingType: \"mac:WindowDidChangeSharingType\",\n\t\tWindowDidChangeSpace: \"mac:WindowDidChangeSpace\",\n\t\tWindowDidChangeSpaceOrderingMode: \"mac:WindowDidChangeSpaceOrderingMode\",\n\t\tWindowDidChangeTitle: \"mac:WindowDidChangeTitle\",\n\t\tWindowDidChangeToolbar: \"mac:WindowDidChangeToolbar\",\n\t\tWindowDidDeminiaturize: \"mac:WindowDidDeminiaturize\",\n\t\tWindowDidEndSheet: \"mac:WindowDidEndSheet\",\n\t\tWindowDidEnterFullScreen: \"mac:WindowDidEnterFullScreen\",\n\t\tWindowDidEnterVersionBrowser: \"mac:WindowDidEnterVersionBrowser\",\n\t\tWindowDidExitFullScreen: \"mac:WindowDidExitFullScreen\",\n\t\tWindowDidExitVersionBrowser: \"mac:WindowDidExitVersionBrowser\",\n\t\tWindowDidExpose: \"mac:WindowDidExpose\",\n\t\tWindowDidFocus: \"mac:WindowDidFocus\",\n\t\tWindowDidMiniaturize: \"mac:WindowDidMiniaturize\",\n\t\tWindowDidMove: \"mac:WindowDidMove\",\n\t\tWindowDidOrderOffScreen: \"mac:WindowDidOrderOffScreen\",\n\t\tWindowDidOrderOnScreen: \"mac:WindowDidOrderOnScreen\",\n\t\tWindowDidResignKey: \"mac:WindowDidResignKey\",\n\t\tWindowDidResignMain: \"mac:WindowDidResignMain\",\n\t\tWindowDidResize: \"mac:WindowDidResize\",\n\t\tWindowDidUpdate: \"mac:WindowDidUpdate\",\n\t\tWindowDidUpdateAlpha: \"mac:WindowDidUpdateAlpha\",\n\t\tWindowDidUpdateCollectionBehavior: \"mac:WindowDidUpdateCollectionBehavior\",\n\t\tWindowDidUpdateCollectionProperties: \"mac:WindowDidUpdateCollectionProperties\",\n\t\tWindowDidUpdateShadow: \"mac:WindowDidUpdateShadow\",\n\t\tWindowDidUpdateTitle: \"mac:WindowDidUpdateTitle\",\n\t\tWindowDidUpdateToolbar: \"mac:WindowDidUpdateToolbar\",\n\t\tWindowDidZoom: \"mac:WindowDidZoom\",\n\t\tWindowFileDraggingEntered: \"mac:WindowFileDraggingEntered\",\n\t\tWindowFileDraggingExited: \"mac:WindowFileDraggingExited\",\n\t\tWindowFileDraggingPerformed: \"mac:WindowFileDraggingPerformed\",\n\t\tWindowHide: \"mac:WindowHide\",\n\t\tWindowMaximise: \"mac:WindowMaximise\",\n\t\tWindowUnMaximise: \"mac:WindowUnMaximise\",\n\t\tWindowMinimise: \"mac:WindowMinimise\",\n\t\tWindowUnMinimise: \"mac:WindowUnMinimise\",\n\t\tWindowShouldClose: \"mac:WindowShouldClose\",\n\t\tWindowShow: \"mac:WindowShow\",\n\t\tWindowWillBecomeKey: \"mac:WindowWillBecomeKey\",\n\t\tWindowWillBecomeMain: \"mac:WindowWillBecomeMain\",\n\t\tWindowWillBeginSheet: \"mac:WindowWillBeginSheet\",\n\t\tWindowWillChangeOrderingMode: \"mac:WindowWillChangeOrderingMode\",\n\t\tWindowWillClose: \"mac:WindowWillClose\",\n\t\tWindowWillDeminiaturize: \"mac:WindowWillDeminiaturize\",\n\t\tWindowWillEnterFullScreen: \"mac:WindowWillEnterFullScreen\",\n\t\tWindowWillEnterVersionBrowser: \"mac:WindowWillEnterVersionBrowser\",\n\t\tWindowWillExitFullScreen: \"mac:WindowWillExitFullScreen\",\n\t\tWindowWillExitVersionBrowser: \"mac:WindowWillExitVersionBrowser\",\n\t\tWindowWillFocus: \"mac:WindowWillFocus\",\n\t\tWindowWillMiniaturize: \"mac:WindowWillMiniaturize\",\n\t\tWindowWillMove: \"mac:WindowWillMove\",\n\t\tWindowWillOrderOffScreen: \"mac:WindowWillOrderOffScreen\",\n\t\tWindowWillOrderOnScreen: \"mac:WindowWillOrderOnScreen\",\n\t\tWindowWillResignMain: \"mac:WindowWillResignMain\",\n\t\tWindowWillResize: \"mac:WindowWillResize\",\n\t\tWindowWillUnfocus: \"mac:WindowWillUnfocus\",\n\t\tWindowWillUpdate: \"mac:WindowWillUpdate\",\n\t\tWindowWillUpdateAlpha: \"mac:WindowWillUpdateAlpha\",\n\t\tWindowWillUpdateCollectionBehavior: \"mac:WindowWillUpdateCollectionBehavior\",\n\t\tWindowWillUpdateCollectionProperties: \"mac:WindowWillUpdateCollectionProperties\",\n\t\tWindowWillUpdateShadow: \"mac:WindowWillUpdateShadow\",\n\t\tWindowWillUpdateTitle: \"mac:WindowWillUpdateTitle\",\n\t\tWindowWillUpdateToolbar: \"mac:WindowWillUpdateToolbar\",\n\t\tWindowWillUpdateVisibility: \"mac:WindowWillUpdateVisibility\",\n\t\tWindowWillUseStandardFrame: \"mac:WindowWillUseStandardFrame\",\n\t\tWindowZoomIn: \"mac:WindowZoomIn\",\n\t\tWindowZoomOut: \"mac:WindowZoomOut\",\n\t\tWindowZoomReset: \"mac:WindowZoomReset\",\n\t}),\n\tLinux: Object.freeze({\n\t\tApplicationStartup: \"linux:ApplicationStartup\",\n\t\tSystemDidWake: \"linux:SystemDidWake\",\n\t\tSystemThemeChanged: \"linux:SystemThemeChanged\",\n\t\tSystemWillSleep: \"linux:SystemWillSleep\",\n\t\tWindowDeleteEvent: \"linux:WindowDeleteEvent\",\n\t\tWindowDidMove: \"linux:WindowDidMove\",\n\t\tWindowDidResize: \"linux:WindowDidResize\",\n\t\tWindowFocusIn: \"linux:WindowFocusIn\",\n\t\tWindowFocusOut: \"linux:WindowFocusOut\",\n\t\tWindowLoadStarted: \"linux:WindowLoadStarted\",\n\t\tWindowLoadRedirected: \"linux:WindowLoadRedirected\",\n\t\tWindowLoadCommitted: \"linux:WindowLoadCommitted\",\n\t\tWindowLoadFinished: \"linux:WindowLoadFinished\",\n\t}),\n\tiOS: Object.freeze({\n\t\tApplicationDidBecomeActive: \"ios:ApplicationDidBecomeActive\",\n\t\tApplicationDidEnterBackground: \"ios:ApplicationDidEnterBackground\",\n\t\tApplicationDidFinishLaunching: \"ios:ApplicationDidFinishLaunching\",\n\t\tApplicationDidReceiveMemoryWarning: \"ios:ApplicationDidReceiveMemoryWarning\",\n\t\tApplicationWillEnterForeground: \"ios:ApplicationWillEnterForeground\",\n\t\tApplicationWillResignActive: \"ios:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"ios:ApplicationWillTerminate\",\n\t\tWindowDidLoad: \"ios:WindowDidLoad\",\n\t\tWindowWillAppear: \"ios:WindowWillAppear\",\n\t\tWindowDidAppear: \"ios:WindowDidAppear\",\n\t\tWindowWillDisappear: \"ios:WindowWillDisappear\",\n\t\tWindowDidDisappear: \"ios:WindowDidDisappear\",\n\t\tWindowSafeAreaInsetsChanged: \"ios:WindowSafeAreaInsetsChanged\",\n\t\tWindowOrientationChanged: \"ios:WindowOrientationChanged\",\n\t\tWindowTouchBegan: \"ios:WindowTouchBegan\",\n\t\tWindowTouchMoved: \"ios:WindowTouchMoved\",\n\t\tWindowTouchEnded: \"ios:WindowTouchEnded\",\n\t\tWindowTouchCancelled: \"ios:WindowTouchCancelled\",\n\t\tWebViewDidStartNavigation: \"ios:WebViewDidStartNavigation\",\n\t\tWebViewDidFinishNavigation: \"ios:WebViewDidFinishNavigation\",\n\t\tWebViewDidFailNavigation: \"ios:WebViewDidFailNavigation\",\n\t\tWebViewDecidePolicyForNavigationAction: \"ios:WebViewDecidePolicyForNavigationAction\",\n\t\tBatteryChanged: \"ios:BatteryChanged\",\n\t\tNetworkChanged: \"ios:NetworkChanged\",\n\t\tThemeChanged: \"ios:ThemeChanged\",\n\t\tScreenLocked: \"ios:ScreenLocked\",\n\t\tScreenUnlocked: \"ios:ScreenUnlocked\",\n\t}),\n\tAndroid: Object.freeze({\n\t\tActivityCreated: \"android:ActivityCreated\",\n\t\tActivityStarted: \"android:ActivityStarted\",\n\t\tActivityResumed: \"android:ActivityResumed\",\n\t\tActivityPaused: \"android:ActivityPaused\",\n\t\tActivityStopped: \"android:ActivityStopped\",\n\t\tActivityDestroyed: \"android:ActivityDestroyed\",\n\t\tApplicationLowMemory: \"android:ApplicationLowMemory\",\n\t\tWebViewPageStarted: \"android:WebViewPageStarted\",\n\t\tWebViewPageFinished: \"android:WebViewPageFinished\",\n\t\tBatteryChanged: \"android:BatteryChanged\",\n\t\tNetworkChanged: \"android:NetworkChanged\",\n\t\tThemeChanged: \"android:ThemeChanged\",\n\t\tScreenLocked: \"android:ScreenLocked\",\n\t\tScreenUnlocked: \"android:ScreenUnlocked\",\n\t}),\n\tCommon: Object.freeze({\n\t\tApplicationOpenedWithFile: \"common:ApplicationOpenedWithFile\",\n\t\tApplicationStarted: \"common:ApplicationStarted\",\n\t\tApplicationLaunchedWithUrl: \"common:ApplicationLaunchedWithUrl\",\n\t\tThemeChanged: \"common:ThemeChanged\",\n\t\tSystemDidWake: \"common:SystemDidWake\",\n\t\tSystemWillSleep: \"common:SystemWillSleep\",\n\t\tWindowClosing: \"common:WindowClosing\",\n\t\tWindowDidMove: \"common:WindowDidMove\",\n\t\tWindowDidResize: \"common:WindowDidResize\",\n\t\tWindowDPIChanged: \"common:WindowDPIChanged\",\n\t\tWindowFilesDropped: \"common:WindowFilesDropped\",\n\t\tWindowFocus: \"common:WindowFocus\",\n\t\tWindowFullscreen: \"common:WindowFullscreen\",\n\t\tWindowHide: \"common:WindowHide\",\n\t\tWindowLostFocus: \"common:WindowLostFocus\",\n\t\tWindowMaximise: \"common:WindowMaximise\",\n\t\tWindowMinimise: \"common:WindowMinimise\",\n\t\tWindowToggleFrameless: \"common:WindowToggleFrameless\",\n\t\tWindowRestore: \"common:WindowRestore\",\n\t\tWindowRuntimeReady: \"common:WindowRuntimeReady\",\n\t\tWindowShow: \"common:WindowShow\",\n\t\tWindowUnFullscreen: \"common:WindowUnFullscreen\",\n\t\tWindowUnMaximise: \"common:WindowUnMaximise\",\n\t\tWindowUnMinimise: \"common:WindowUnMinimise\",\n\t\tWindowZoom: \"common:WindowZoom\",\n\t\tWindowZoomIn: \"common:WindowZoomIn\",\n\t\tWindowZoomOut: \"common:WindowZoomOut\",\n\t\tWindowZoomReset: \"common:WindowZoomReset\",\n\t\tBatteryChanged: \"common:BatteryChanged\",\n\t\tNetworkChanged: \"common:NetworkChanged\",\n\t\tScreenLocked: \"common:ScreenLocked\",\n\t\tScreenUnlocked: \"common:ScreenUnlocked\",\n\t\tLowMemory: \"common:LowMemory\",\n\t}),\n});\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Logs a message to the console with custom formatting.\n *\n * @param message - The message to be logged.\n */\nexport function debugLog(message: any) {\n    // eslint-disable-next-line\n    console.log(\n        '%c wails3 %c ' + message + ' ',\n        'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',\n        'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'\n    );\n}\n\n/**\n * Checks whether the webview supports the {@link MouseEvent#buttons} property.\n * Looking at you macOS High Sierra!\n */\nexport function canTrackButtons(): boolean {\n    return (new MouseEvent('mousedown')).buttons === 0;\n}\n\n/**\n * Checks whether the browser supports removing listeners by triggering an AbortSignal\n * (see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#signal).\n */\nexport function canAbortListeners() {\n    if (!EventTarget || !AbortSignal || !AbortController)\n        return false;\n\n    let result = true;\n\n    const target = new EventTarget();\n    const controller = new AbortController();\n    target.addEventListener('test', () => { result = false; }, { signal: controller.signal });\n    controller.abort();\n    target.dispatchEvent(new CustomEvent('test'));\n\n    return result;\n}\n\n/**\n * Resolves the closest HTMLElement ancestor of an event's target.\n */\nexport function eventTarget(event: Event): HTMLElement {\n    if (event.target instanceof HTMLElement) {\n        return event.target;\n    } else if (!(event.target instanceof HTMLElement) && event.target instanceof Node) {\n        return event.target.parentElement ?? document.body;\n    } else {\n        return document.body;\n    }\n}\n\n/***\n This technique for proper load detection is taken from HTMX:\n\n BSD 2-Clause License\n\n Copyright (c) 2020, Big Sky Software\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n 1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n ***/\n\nlet isReady = false;\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    document.addEventListener('DOMContentLoaded', () => { isReady = true });\n}\n\nexport function whenReady(callback: () => void) {\n    if (isReady || document.readyState === 'complete') {\n        callback();\n    } else {\n        document.addEventListener('DOMContentLoaded', callback);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\nimport type { Screen } from \"./screens.js\";\n\n// Drop target constants\nconst DROP_TARGET_ATTRIBUTE = 'data-file-drop-target';\nconst DROP_TARGET_ACTIVE_CLASS = 'file-drop-target-active';\nlet currentDropTarget: Element | null = null;\n\nconst PositionMethod                    = 0;\nconst CenterMethod                      = 1;\nconst CloseMethod                       = 2;\nconst DisableSizeConstraintsMethod      = 3;\nconst EnableSizeConstraintsMethod       = 4;\nconst FocusMethod                       = 5;\nconst ForceReloadMethod                 = 6;\nconst FullscreenMethod                  = 7;\nconst GetScreenMethod                   = 8;\nconst GetZoomMethod                     = 9;\nconst HeightMethod                      = 10;\nconst HideMethod                        = 11;\nconst IsFocusedMethod                   = 12;\nconst IsFullscreenMethod                = 13;\nconst IsMaximisedMethod                 = 14;\nconst IsMinimisedMethod                 = 15;\nconst MaximiseMethod                    = 16;\nconst MinimiseMethod                    = 17;\nconst NameMethod                        = 18;\nconst OpenDevToolsMethod                = 19;\nconst RelativePositionMethod            = 20;\nconst ReloadMethod                      = 21;\nconst ResizableMethod                   = 22;\nconst RestoreMethod                     = 23;\nconst SetPositionMethod                 = 24;\nconst SetAlwaysOnTopMethod              = 25;\nconst SetBackgroundColourMethod         = 26;\nconst SetFramelessMethod                = 27;\nconst SetFullscreenButtonEnabledMethod  = 28;\nconst SetMaxSizeMethod                  = 29;\nconst SetMinSizeMethod                  = 30;\nconst SetRelativePositionMethod         = 31;\nconst SetResizableMethod                = 32;\nconst SetSizeMethod                     = 33;\nconst SetTitleMethod                    = 34;\nconst SetZoomMethod                     = 35;\nconst ShowMethod                        = 36;\nconst SizeMethod                        = 37;\nconst ToggleFullscreenMethod            = 38;\nconst ToggleMaximiseMethod              = 39;\nconst ToggleFramelessMethod             = 40; \nconst UnFullscreenMethod                = 41;\nconst UnMaximiseMethod                  = 42;\nconst UnMinimiseMethod                  = 43;\nconst WidthMethod                       = 44;\nconst ZoomMethod                        = 45;\nconst ZoomInMethod                      = 46;\nconst ZoomOutMethod                     = 47;\nconst ZoomResetMethod                   = 48;\nconst SnapAssistMethod                  = 49;\nconst FilesDropped                      = 50;\nconst PrintMethod                       = 51;\nconst SetScreenMethod                   = 52;\n\n/**\n * Finds the nearest drop target element by walking up the DOM tree.\n */\nfunction getDropTargetElement(element: Element | null): Element | null {\n    if (!element) {\n        return null;\n    }\n    return element.closest(`[${DROP_TARGET_ATTRIBUTE}]`);\n}\n\n/**\n * Check if we can use WebView2's postMessageWithAdditionalObjects (Windows)\n * Also checks that EnableFileDrop is true for this window.\n */\nfunction canResolveFilePaths(): boolean {\n    // Must have WebView2's postMessageWithAdditionalObjects API (Windows only)\n    if ((window as any).chrome?.webview?.postMessageWithAdditionalObjects == null) {\n        return false;\n    }\n    // Must have EnableFileDrop set to true for this window\n    // This flag is set by the Go backend during runtime initialization\n    return (window as any)._wails?.flags?.enableFileDrop === true;\n}\n\n/**\n * Send file drop to backend via WebView2 (Windows only)\n */\nfunction resolveFilePaths(x: number, y: number, files: File[]): void {\n    if ((window as any).chrome?.webview?.postMessageWithAdditionalObjects) {\n        (window as any).chrome.webview.postMessageWithAdditionalObjects(`file:drop:${x}:${y}`, files);\n    }\n}\n\n// Native drag state (Linux/macOS intercept DOM drag events)\nlet nativeDragActive = false;\n\n/**\n * Cleans up native drag state and hover effects.\n * Called on drop or when drag leaves the window.\n */\nfunction cleanupNativeDrag(): void {\n    nativeDragActive = false;\n    if (currentDropTarget) {\n        currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n        currentDropTarget = null;\n    }\n}\n\n/**\n * Called from Go when a file drag enters the window on Linux/macOS.\n */\nfunction handleDragEnter(): void {\n    // Check if file drops are enabled for this window\n    if ((window as any)._wails?.flags?.enableFileDrop === false) {\n        return; // File drops disabled, don't activate drag state\n    }\n    nativeDragActive = true;\n}\n\n/**\n * Called from Go when a file drag leaves the window on Linux/macOS.\n */\nfunction handleDragLeave(): void {\n    cleanupNativeDrag();\n}\n\n/**\n * Called from Go during file drag to update hover state on Linux/macOS.\n * @param x - X coordinate in CSS pixels\n * @param y - Y coordinate in CSS pixels\n */\nfunction handleDragOver(x: number, y: number): void {\n    if (!nativeDragActive) return;\n    \n    // Check if file drops are enabled for this window\n    if ((window as any)._wails?.flags?.enableFileDrop === false) {\n        return; // File drops disabled, don't show hover effects\n    }\n    \n    const targetElement = document.elementFromPoint(x, y);\n    const dropTarget = getDropTargetElement(targetElement);\n    \n    if (currentDropTarget && currentDropTarget !== dropTarget) {\n        currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n    }\n    \n    if (dropTarget) {\n        dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);\n        currentDropTarget = dropTarget;\n    } else {\n        currentDropTarget = null;\n    }\n}\n\n\n\n// Export the handlers for use by Go via index.ts\nexport { handleDragEnter, handleDragLeave, handleDragOver };\n\n/**\n * A record describing the position of a window.\n */\ninterface Position {\n    /** The horizontal position of the window. */\n    x: number;\n    /** The vertical position of the window. */\n    y: number;\n}\n\n/**\n * A record describing the size of a window.\n */\ninterface Size {\n    /** The width of the window. */\n    width: number;\n    /** The height of the window. */\n    height: number;\n}\n\n// Private field names.\nconst callerSym = Symbol(\"caller\");\n\nclass Window {\n    // Private fields.\n    private [callerSym]: (message: number, args?: any) => Promise<any>;\n\n    /**\n     * Initialises a window object with the specified name.\n     *\n     * @private\n     * @param name - The name of the target window.\n     */\n    constructor(name: string = '') {\n        this[callerSym] = newRuntimeCaller(objectNames.Window, name)\n\n        // bind instance method to make them easily usable in event handlers\n        for (const method of Object.getOwnPropertyNames(Window.prototype)) {\n            if (\n                method !== \"constructor\"\n                && typeof (this as any)[method] === \"function\"\n            ) {\n                (this as any)[method] = (this as any)[method].bind(this);\n            }\n        }\n    }\n\n    /**\n     * Gets the specified window.\n     *\n     * @param name - The name of the window to get.\n     * @returns The corresponding window object.\n     */\n    Get(name: string): Window {\n        return new Window(name);\n    }\n\n    /**\n     * Returns the absolute position of the window.\n     *\n     * @returns The current absolute position of the window.\n     */\n    Position(): Promise<Position> {\n        return this[callerSym](PositionMethod);\n    }\n\n    /**\n     * Centers the window on the screen.\n     */\n    Center(): Promise<void> {\n        return this[callerSym](CenterMethod);\n    }\n\n    /**\n     * Closes the window.\n     */\n    Close(): Promise<void> {\n        return this[callerSym](CloseMethod);\n    }\n\n    /**\n     * Disables min/max size constraints.\n     */\n    DisableSizeConstraints(): Promise<void> {\n        return this[callerSym](DisableSizeConstraintsMethod);\n    }\n\n    /**\n     * Enables min/max size constraints.\n     */\n    EnableSizeConstraints(): Promise<void> {\n        return this[callerSym](EnableSizeConstraintsMethod);\n    }\n\n    /**\n     * Focuses the window.\n     */\n    Focus(): Promise<void> {\n        return this[callerSym](FocusMethod);\n    }\n\n    /**\n     * Forces the window to reload the page assets.\n     */\n    ForceReload(): Promise<void> {\n        return this[callerSym](ForceReloadMethod);\n    }\n\n    /**\n     * Switches the window to fullscreen mode.\n     */\n    Fullscreen(): Promise<void> {\n        return this[callerSym](FullscreenMethod);\n    }\n\n    /**\n     * Returns the screen that the window is on.\n     *\n     * @returns The screen the window is currently on.\n     */\n    GetScreen(): Promise<Screen> {\n        return this[callerSym](GetScreenMethod);\n    }\n\n    /**\n     * Returns the current zoom level of the window.\n     *\n     * @returns The current zoom level.\n     */\n    GetZoom(): Promise<number> {\n        return this[callerSym](GetZoomMethod);\n    }\n\n    /**\n     * Returns the height of the window.\n     *\n     * @returns The current height of the window.\n     */\n    Height(): Promise<number> {\n        return this[callerSym](HeightMethod);\n    }\n\n    /**\n     * Hides the window.\n     */\n    Hide(): Promise<void> {\n        return this[callerSym](HideMethod);\n    }\n\n    /**\n     * Returns true if the window is focused.\n     *\n     * @returns Whether the window is currently focused.\n     */\n    IsFocused(): Promise<boolean> {\n        return this[callerSym](IsFocusedMethod);\n    }\n\n    /**\n     * Returns true if the window is fullscreen.\n     *\n     * @returns Whether the window is currently fullscreen.\n     */\n    IsFullscreen(): Promise<boolean> {\n        return this[callerSym](IsFullscreenMethod);\n    }\n\n    /**\n     * Returns true if the window is maximised.\n     *\n     * @returns Whether the window is currently maximised.\n     */\n    IsMaximised(): Promise<boolean> {\n        return this[callerSym](IsMaximisedMethod);\n    }\n\n    /**\n     * Returns true if the window is minimised.\n     *\n     * @returns Whether the window is currently minimised.\n     */\n    IsMinimised(): Promise<boolean> {\n        return this[callerSym](IsMinimisedMethod);\n    }\n\n    /**\n     * Maximises the window.\n     */\n    Maximise(): Promise<void> {\n        return this[callerSym](MaximiseMethod);\n    }\n\n    /**\n     * Minimises the window.\n     */\n    Minimise(): Promise<void> {\n        return this[callerSym](MinimiseMethod);\n    }\n\n    /**\n     * Returns the name of the window.\n     *\n     * @returns The name of the window.\n     */\n    Name(): Promise<string> {\n        return this[callerSym](NameMethod);\n    }\n\n    /**\n     * Opens the development tools pane.\n     */\n    OpenDevTools(): Promise<void> {\n        return this[callerSym](OpenDevToolsMethod);\n    }\n\n    /**\n     * Returns the relative position of the window to the screen.\n     *\n     * @returns The current relative position of the window.\n     */\n    RelativePosition(): Promise<Position> {\n        return this[callerSym](RelativePositionMethod);\n    }\n\n    /**\n     * Reloads the page assets.\n     */\n    Reload(): Promise<void> {\n        return this[callerSym](ReloadMethod);\n    }\n\n    /**\n     * Returns true if the window is resizable.\n     *\n     * @returns Whether the window is currently resizable.\n     */\n    Resizable(): Promise<boolean> {\n        return this[callerSym](ResizableMethod);\n    }\n\n    /**\n     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.\n     */\n    Restore(): Promise<void> {\n        return this[callerSym](RestoreMethod);\n    }\n\n    /**\n     * Sets the absolute position of the window.\n     *\n     * @param x - The desired horizontal absolute position of the window.\n     * @param y - The desired vertical absolute position of the window.\n     */\n    SetPosition(x: number, y: number): Promise<void> {\n        return this[callerSym](SetPositionMethod, { x, y });\n    }\n\n    /**\n     * Sets the window to be always on top.\n     *\n     * @param alwaysOnTop - Whether the window should stay on top.\n     */\n    SetAlwaysOnTop(alwaysOnTop: boolean): Promise<void> {\n        return this[callerSym](SetAlwaysOnTopMethod, { alwaysOnTop });\n    }\n\n    /**\n     * Sets the background colour of the window.\n     *\n     * @param r - The desired red component of the window background.\n     * @param g - The desired green component of the window background.\n     * @param b - The desired blue component of the window background.\n     * @param a - The desired alpha component of the window background.\n     */\n    SetBackgroundColour(r: number, g: number, b: number, a: number): Promise<void> {\n        return this[callerSym](SetBackgroundColourMethod, { r, g, b, a });\n    }\n\n    /**\n     * Removes the window frame and title bar.\n     *\n     * @param frameless - Whether the window should be frameless.\n     */\n    SetFrameless(frameless: boolean): Promise<void> {\n        return this[callerSym](SetFramelessMethod, { frameless });\n    }\n\n    /**\n     * Disables the system fullscreen button.\n     *\n     * @param enabled - Whether the fullscreen button should be enabled.\n     */\n    SetFullscreenButtonEnabled(enabled: boolean): Promise<void> {\n        return this[callerSym](SetFullscreenButtonEnabledMethod, { enabled });\n    }\n\n    /**\n     * Sets the maximum size of the window.\n     *\n     * @param width - The desired maximum width of the window.\n     * @param height - The desired maximum height of the window.\n     */\n    SetMaxSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetMaxSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the minimum size of the window.\n     *\n     * @param width - The desired minimum width of the window.\n     * @param height - The desired minimum height of the window.\n     */\n    SetMinSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetMinSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the relative position of the window to the screen.\n     *\n     * @param x - The desired horizontal relative position of the window.\n     * @param y - The desired vertical relative position of the window.\n     */\n    SetRelativePosition(x: number, y: number): Promise<void> {\n        return this[callerSym](SetRelativePositionMethod, { x, y });\n    }\n\n    /**\n     * Sets whether the window is resizable.\n     *\n     * @param resizable - Whether the window should be resizable.\n     */\n    SetResizable(resizable: boolean): Promise<void> {\n        return this[callerSym](SetResizableMethod, { resizable });\n    }\n\n    /**\n     * Sets the size of the window.\n     *\n     * @param width - The desired width of the window.\n     * @param height - The desired height of the window.\n     */\n    SetSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the title of the window.\n     *\n     * @param title - The desired title of the window.\n     */\n    SetTitle(title: string): Promise<void> {\n        return this[callerSym](SetTitleMethod, { title });\n    }\n\n    /**\n     * Sets the zoom level of the window.\n     *\n     * @param zoom - The desired zoom level.\n     */\n    SetZoom(zoom: number): Promise<void> {\n        return this[callerSym](SetZoomMethod, { zoom });\n    }\n\n    /**\n     * Shows the window.\n     */\n    Show(): Promise<void> {\n        return this[callerSym](ShowMethod);\n    }\n\n    /**\n     * Returns the size of the window.\n     *\n     * @returns The current size of the window.\n     */\n    Size(): Promise<Size> {\n        return this[callerSym](SizeMethod);\n    }\n\n    /**\n     * Toggles the window between fullscreen and normal.\n     */\n    ToggleFullscreen(): Promise<void> {\n        return this[callerSym](ToggleFullscreenMethod);\n    }\n\n    /**\n     * Toggles the window between maximised and normal.\n     */\n    ToggleMaximise(): Promise<void> {\n        return this[callerSym](ToggleMaximiseMethod);\n    }\n\n    /**\n     * Toggles the window between frameless and normal.\n     */\n    ToggleFrameless(): Promise<void> {\n        return this[callerSym](ToggleFramelessMethod);\n    }\n\n    /**\n     * Un-fullscreens the window.\n     */\n    UnFullscreen(): Promise<void> {\n        return this[callerSym](UnFullscreenMethod);\n    }\n\n    /**\n     * Un-maximises the window.\n     */\n    UnMaximise(): Promise<void> {\n        return this[callerSym](UnMaximiseMethod);\n    }\n\n    /**\n     * Un-minimises the window.\n     */\n    UnMinimise(): Promise<void> {\n        return this[callerSym](UnMinimiseMethod);\n    }\n\n    /**\n     * Returns the width of the window.\n     *\n     * @returns The current width of the window.\n     */\n    Width(): Promise<number> {\n        return this[callerSym](WidthMethod);\n    }\n\n    /**\n     * Zooms the window.\n     */\n    Zoom(): Promise<void> {\n        return this[callerSym](ZoomMethod);\n    }\n\n    /**\n     * Increases the zoom level of the webview content.\n     */\n    ZoomIn(): Promise<void> {\n        return this[callerSym](ZoomInMethod);\n    }\n\n    /**\n     * Decreases the zoom level of the webview content.\n     */\n    ZoomOut(): Promise<void> {\n        return this[callerSym](ZoomOutMethod);\n    }\n\n    /**\n     * Resets the zoom level of the webview content.\n     */\n    ZoomReset(): Promise<void> {\n        return this[callerSym](ZoomResetMethod);\n    }\n\n    /**\n     * Handles file drops originating from platform-specific code (e.g., macOS/Linux native drag-and-drop).\n     * Gathers information about the drop target element and sends it back to the Go backend.\n     *\n     * @param filenames - An array of file paths (strings) that were dropped.\n     * @param x - The x-coordinate of the drop event (CSS pixels).\n     * @param y - The y-coordinate of the drop event (CSS pixels).\n     */\n    HandlePlatformFileDrop(filenames: string[], x: number, y: number): void {\n        // Check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            return; // File drops disabled, ignore the drop\n        }\n        \n        const element = document.elementFromPoint(x, y);\n        const dropTarget = getDropTargetElement(element);\n\n        if (!dropTarget) {\n            // Drop was not on a designated drop target - ignore\n            return;\n        }\n\n        const elementDetails = {\n            id: dropTarget.id,\n            classList: Array.from(dropTarget.classList),\n            attributes: {} as { [key: string]: string },\n        };\n        for (let i = 0; i < dropTarget.attributes.length; i++) {\n            const attr = dropTarget.attributes[i];\n            elementDetails.attributes[attr.name] = attr.value;\n        }\n\n        const payload = {\n            filenames,\n            x,\n            y,\n            elementDetails,\n        };\n\n        this[callerSym](FilesDropped, payload);\n        \n        // Clean up native drag state after drop\n        cleanupNativeDrag();\n    }\n  \n    /**\n     * Moves the window to the center of the specified screen's work area.\n     *\n     * @param screenID - The ID of the target screen.\n     */\n    SetScreen(screenID: string): Promise<void> {\n        return this[callerSym](SetScreenMethod, { screenID });\n    }\n\n    /* Triggers Windows 11 Snap Assist feature (Windows only).\n     * This is equivalent to pressing Win+Z and shows snap layout options.\n     */\n    SnapAssist(): Promise<void> {\n        return this[callerSym](SnapAssistMethod);\n    }\n\n    /**\n     * Opens the print dialog for the window.\n     */\n    Print(): Promise<void> {\n        return this[callerSym](PrintMethod);\n    }\n}\n\n/**\n * The window within which the script is running.\n */\nconst thisWindow = new Window('');\n\n/**\n * Sets up global drag and drop event listeners for file drops.\n * Handles visual feedback (hover state) and file drop processing.\n */\nfunction setupDropTargetListeners() {\n    const docElement = document.documentElement;\n    let dragEnterCounter = 0;\n\n    docElement.addEventListener('dragenter', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return; // Only handle file drags, let other drags pass through\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            event.dataTransfer.dropEffect = 'none'; // Show \"no drop\" cursor\n            return; // File drops disabled, don't show hover effects\n        }\n        dragEnterCounter++;\n        \n        const targetElement = document.elementFromPoint(event.clientX, event.clientY);\n        const dropTarget = getDropTargetElement(targetElement);\n\n        // Update hover state\n        if (currentDropTarget && currentDropTarget !== dropTarget) {\n            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n        }\n\n        if (dropTarget) {\n            dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);\n            event.dataTransfer.dropEffect = 'copy';\n            currentDropTarget = dropTarget;\n        } else {\n            event.dataTransfer.dropEffect = 'none';\n            currentDropTarget = null;\n        }\n    }, false);\n\n    docElement.addEventListener('dragover', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return; // Only handle file drags\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            event.dataTransfer.dropEffect = 'none'; // Show \"no drop\" cursor\n            return; // File drops disabled, don't show hover effects\n        }\n        \n        // Update drop target as cursor moves\n        const targetElement = document.elementFromPoint(event.clientX, event.clientY);\n        const dropTarget = getDropTargetElement(targetElement);\n        \n        if (currentDropTarget && currentDropTarget !== dropTarget) {\n            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n        }\n        \n        if (dropTarget) {\n            if (!dropTarget.classList.contains(DROP_TARGET_ACTIVE_CLASS)) {\n                dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);\n            }\n            event.dataTransfer.dropEffect = 'copy';\n            currentDropTarget = dropTarget;\n        } else {\n            event.dataTransfer.dropEffect = 'none';\n            currentDropTarget = null;\n        }\n    }, false);\n\n    docElement.addEventListener('dragleave', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return;\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            return;\n        }\n        \n        // On Linux/WebKitGTK and macOS, dragleave fires immediately with relatedTarget=null when native\n        // drag handling is involved. Ignore these spurious events - we'll clean up on drop instead.\n        if (event.relatedTarget === null) {\n            return;\n        }\n        \n        dragEnterCounter--;\n        \n        if (dragEnterCounter === 0 || \n            (currentDropTarget && !currentDropTarget.contains(event.relatedTarget as Node))) {\n            if (currentDropTarget) {\n                currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n                currentDropTarget = null;\n            }\n            dragEnterCounter = 0;\n        }\n    }, false);\n\n    docElement.addEventListener('drop', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return; // Only handle file drops\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            return;\n        }\n        dragEnterCounter = 0;\n        \n        if (currentDropTarget) {\n            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n            currentDropTarget = null;\n        }\n\n        // On Windows, handle file drops via JavaScript\n        // On macOS/Linux, native code will call HandlePlatformFileDrop\n        if (canResolveFilePaths()) {\n            const files: File[] = [];\n            if (event.dataTransfer.items) {\n                for (const item of event.dataTransfer.items) {\n                    if (item.kind === 'file') {\n                        const file = item.getAsFile();\n                        if (file) files.push(file);\n                    }\n                }\n            } else if (event.dataTransfer.files) {\n                for (const file of event.dataTransfer.files) {\n                    files.push(file);\n                }\n            }\n            \n            if (files.length > 0) {\n                resolveFilePaths(event.clientX, event.clientY, files);\n            }\n        }\n    }, false);\n}\n\n// Initialize listeners when the script loads\nif (typeof window !== \"undefined\" && typeof document !== \"undefined\") {\n    setupDropTargetListeners();\n}\n\nexport default thisWindow;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport * as Runtime from \"../@wailsio/runtime/src\";\n\n// NOTE: the following methods MUST be imported explicitly because of how esbuild injection works\nimport { Enable as EnableWML } from \"../@wailsio/runtime/src/wml\";\nimport { debugLog } from \"../@wailsio/runtime/src/utils\";\n\nwindow.wails = Runtime;\nEnableWML();\n\nif (DEBUG) {\n    debugLog(\"Wails Runtime Loaded\")\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.System);\n\nconst SystemIsDarkMode = 0;\nconst SystemEnvironment = 1;\nconst SystemCapabilities = 2;\n\nconst _invoke = (function () {\n    try {\n        // Windows WebView2\n        if ((window as any).chrome?.webview?.postMessage) {\n            return (window as any).chrome.webview.postMessage.bind((window as any).chrome.webview);\n        }\n        // macOS/iOS WKWebView\n        else if ((window as any).webkit?.messageHandlers?.['external']?.postMessage) {\n            return (window as any).webkit.messageHandlers['external'].postMessage.bind((window as any).webkit.messageHandlers['external']);\n        }\n        // Android WebView - uses addJavascriptInterface which exposes window.wails.invoke\n        else if ((window as any).wails?.invoke) {\n            return (msg: any) => (window as any).wails.invoke(typeof msg === 'string' ? msg : JSON.stringify(msg));\n        }\n    } catch(e) {}\n\n    console.warn('\\n%c\u26A0\uFE0F Browser Environment Detected %c\\n\\n%cOnly UI previews are available in the browser. For full functionality, please run the application in desktop mode.\\nMore information at: https://v3.wails.io/learn/build/#using-a-browser-for-development\\n',\n        'background: #ffffff; color: #000000; font-weight: bold; padding: 4px 8px; border-radius: 4px; border: 2px solid #000000;',\n        'background: transparent;',\n        'color: #ffffff; font-style: italic; font-weight: bold;');\n    return null;\n})();\n\nexport function invoke(msg: any): void {\n    _invoke?.(msg);\n}\n\n/**\n * Retrieves the system dark mode status.\n *\n * @returns A promise that resolves to a boolean value indicating if the system is in dark mode.\n */\nexport function IsDarkMode(): Promise<boolean> {\n    return call(SystemIsDarkMode);\n}\n\n/**\n * Fetches the capabilities of the application from the server.\n *\n * @returns A promise that resolves to an object containing the capabilities.\n */\nexport async function Capabilities(): Promise<Record<string, any>> {\n    return call(SystemCapabilities);\n}\n\nexport interface OSInfo {\n    /** The branding of the OS. */\n    Branding: string;\n    /** The ID of the OS. */\n    ID: string;\n    /** The name of the OS. */\n    Name: string;\n    /** The version of the OS. */\n    Version: string;\n}\n\nexport interface EnvironmentInfo {\n    /** The architecture of the system. */\n    Arch: string;\n    /** True if the application is running in debug mode, otherwise false. */\n    Debug: boolean;\n    /** The operating system in use. */\n    OS: string;\n    /** Details of the operating system. */\n    OSInfo: OSInfo;\n    /** Additional platform information. */\n    PlatformInfo: Record<string, any>;\n}\n\n/**\n * Retrieves environment details.\n *\n * @returns A promise that resolves to an object containing OS and system architecture.\n */\nexport function Environment(): Promise<EnvironmentInfo> {\n    return call(SystemEnvironment);\n}\n\n/**\n * Checks if the current operating system is Windows.\n *\n * @return True if the operating system is Windows, otherwise false.\n */\nexport function IsWindows(): boolean {\n    return (window as any)._wails?.environment?.OS === \"windows\";\n}\n\n/**\n * Checks if the current operating system is Linux.\n *\n * @returns Returns true if the current operating system is Linux, false otherwise.\n */\nexport function IsLinux(): boolean {\n    return (window as any)._wails?.environment?.OS === \"linux\";\n}\n\n/**\n * Checks if the current environment is a macOS operating system.\n *\n * @returns True if the environment is macOS, false otherwise.\n */\nexport function IsMac(): boolean {\n    return (window as any)._wails?.environment?.OS === \"darwin\";\n}\n\n/**\n * Checks if the current operating system is iOS.\n *\n * @returns True if the operating system is iOS, otherwise false.\n */\nexport function IsIOS(): boolean {\n    return (window as any)._wails?.environment?.OS === \"ios\";\n}\n\n/**\n * Checks if the current operating system is Android.\n *\n * @returns True if the operating system is Android, otherwise false.\n */\nexport function IsAndroid(): boolean {\n    return (window as any)._wails?.environment?.OS === \"android\";\n}\n\n/**\n * Checks if the app is running on a mobile OS (iOS or Android).\n *\n * @returns True on iOS or Android, otherwise false.\n */\nexport function IsMobile(): boolean {\n    return IsIOS() || IsAndroid();\n}\n\n/**\n * Checks if the app is running on a desktop OS (macOS, Windows or Linux).\n *\n * @returns True on macOS, Windows or Linux, otherwise false.\n */\nexport function IsDesktop(): boolean {\n    return IsMac() || IsWindows() || IsLinux();\n}\n\n/**\n * Checks if the current environment architecture is AMD64.\n *\n * @returns True if the current environment architecture is AMD64, false otherwise.\n */\nexport function IsAMD64(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"amd64\";\n}\n\n/**\n * Checks if the current architecture is ARM.\n *\n * @returns True if the current architecture is ARM, false otherwise.\n */\nexport function IsARM(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"arm\";\n}\n\n/**\n * Checks if the current environment is ARM64 architecture.\n *\n * @returns Returns true if the environment is ARM64 architecture, otherwise returns false.\n */\nexport function IsARM64(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"arm64\";\n}\n\n/**\n * Reports whether the app is being run in debug mode.\n *\n * @returns True if the app is being run in debug mode.\n */\nexport function IsDebug(): boolean {\n    return Boolean((window as any)._wails?.environment?.Debug);\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { IsDebug } from \"./system.js\";\nimport { eventTarget } from \"./utils.js\";\n\n// setup\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    window.addEventListener('contextmenu', contextMenuHandler);\n}\n\nconst call = newRuntimeCaller(objectNames.ContextMenu);\n\nconst ContextMenuOpen = 0;\n\nfunction openContextMenu(id: string, x: number, y: number, data: any): void {\n    void call(ContextMenuOpen, {id, x, y, data});\n}\n\nfunction contextMenuHandler(event: MouseEvent) {\n    const target = eventTarget(event);\n\n    // Check for custom context menu\n    const customContextMenu = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu\").trim();\n\n    if (customContextMenu) {\n        event.preventDefault();\n        const data = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu-data\");\n        openContextMenu(customContextMenu, event.clientX, event.clientY, data);\n    } else {\n        processDefaultContextMenu(event, target);\n    }\n}\n\n\n/*\n--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea\n--default-contextmenu: show; will always show the default context menu\n--default-contextmenu: hide; will always hide the default context menu\n\nThis rule is inherited like normal CSS rules, so nesting works as expected\n*/\nfunction processDefaultContextMenu(event: MouseEvent, target: HTMLElement) {\n    // Debug builds always show the menu\n    if (IsDebug()) {\n        return;\n    }\n\n    // Process default context menu\n    switch (window.getComputedStyle(target).getPropertyValue(\"--default-contextmenu\").trim()) {\n        case 'show':\n            return;\n        case 'hide':\n            event.preventDefault();\n            return;\n    }\n\n    // Check if contentEditable is true\n    if (target.isContentEditable) {\n        return;\n    }\n\n    // Check if text has been selected\n    const selection = window.getSelection();\n    const hasSelection = selection && selection.toString().length > 0;\n    if (hasSelection) {\n        for (let i = 0; i < selection.rangeCount; i++) {\n            const range = selection.getRangeAt(i);\n            const rects = range.getClientRects();\n            for (let j = 0; j < rects.length; j++) {\n                const rect = rects[j];\n                if (document.elementFromPoint(rect.left, rect.top) === target) {\n                    return;\n                }\n            }\n        }\n    }\n\n    // Check if tag is input or textarea.\n    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {\n        if (hasSelection || (!target.readOnly && !target.disabled)) {\n            return;\n        }\n    }\n\n    // hide default context menu\n    event.preventDefault();\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Retrieves the value associated with the specified key from the flag map.\n *\n * @param key - The key to retrieve the value for.\n * @return The value associated with the specified key.\n */\nexport function GetFlag(key: string): any {\n    try {\n        return window._wails.flags[key];\n    } catch (e) {\n        throw new Error(\"Unable to retrieve flag '\" + key + \"': \" + e, { cause: e });\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { invoke, IsWindows, IsLinux } from \"./system.js\";\nimport { GetFlag } from \"./flags.js\";\nimport { canTrackButtons, eventTarget } from \"./utils.js\";\n\n// Setup\nlet canDrag = false;\nlet dragging = false;\n\nlet resizable = false;\nlet canResize = false;\nlet resizing = false;\nlet resizeEdge: string = \"\";\nlet defaultCursor = \"auto\";\n\nlet buttons = 0;\nimport { hasDOM } from \"./environment.js\";\n\nlet buttonsTracked = false;\n\nif (hasDOM) {\n    buttonsTracked = canTrackButtons();\n    window._wails = window._wails || {};\n    window._wails.setResizable = (value: boolean): void => {\n        resizable = value;\n        if (!resizable) {\n            // Stop resizing if in progress.\n            canResize = resizing = false;\n            setResize();\n        }\n    };\n}\n\n// Defer attaching mouse listeners until we know we're not on mobile.\nlet dragInitDone = false;\nfunction isMobile(): boolean {\n    const os = (window as any)._wails?.environment?.OS;\n    if (os === \"ios\" || os === \"android\") return true;\n    // Fallback heuristic if environment not yet set\n    const ua = navigator.userAgent || navigator.vendor || (window as any).opera || \"\";\n    return /android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(ua);\n}\nfunction tryInitDragHandlers(): void {\n    if (dragInitDone) return;\n    if (isMobile()) return;\n    window.addEventListener('mousedown', update, { capture: true });\n    window.addEventListener('mousemove', update, { capture: true });\n    window.addEventListener('mouseup', update, { capture: true });\n    for (const ev of ['click', 'contextmenu', 'dblclick']) {\n        window.addEventListener(ev, suppressEvent, { capture: true });\n    }\n    dragInitDone = true;\n}\nif (hasDOM) {\n    // Attempt immediate init (in case environment already present)\n    tryInitDragHandlers();\n    // Also attempt on DOM ready\n    document.addEventListener('DOMContentLoaded', tryInitDragHandlers, { once: true });\n    // As a last resort, poll for environment for a short period\n    let dragEnvPolls = 0;\n    const dragEnvPoll = window.setInterval(() => {\n        if (dragInitDone) { window.clearInterval(dragEnvPoll); return; }\n        tryInitDragHandlers();\n        if (++dragEnvPolls > 100) { window.clearInterval(dragEnvPoll); }\n    }, 50);\n}\n\nfunction suppressEvent(event: Event) {\n    // Suppress click events while resizing or dragging.\n    if (dragging || resizing) {\n        event.stopImmediatePropagation();\n        event.stopPropagation();\n        event.preventDefault();\n    }\n}\n\n// Use constants to avoid comparing strings multiple times.\nconst MouseDown = 0;\nconst MouseUp   = 1;\nconst MouseMove = 2;\n\nfunction update(event: MouseEvent) {\n    // Windows suppresses mouse events at the end of dragging or resizing,\n    // so we need to be smart and synthesize button events.\n\n    let eventType: number, eventButtons = event.buttons;\n    switch (event.type) {\n        case 'mousedown':\n            eventType = MouseDown;\n            if (!buttonsTracked) { eventButtons = buttons | (1 << event.button); }\n            break;\n        case 'mouseup':\n            eventType = MouseUp;\n            if (!buttonsTracked) { eventButtons = buttons & ~(1 << event.button); }\n            break;\n        default:\n            eventType = MouseMove;\n            if (!buttonsTracked) { eventButtons = buttons; }\n            break;\n    }\n\n    let released = buttons & ~eventButtons;\n    let pressed = eventButtons & ~buttons;\n\n    buttons = eventButtons;\n\n    // Synthesize a release-press sequence if we detect a press of an already pressed button.\n    if (eventType === MouseDown && !(pressed & event.button)) {\n        released |= (1 << event.button);\n        pressed |= (1 << event.button);\n    }\n\n    // Suppress all button events during dragging and resizing,\n    // unless this is a mouseup event that is ending a drag action.\n    if (\n        eventType !== MouseMove // Fast path for mousemove\n        && resizing\n        || (\n            dragging\n            && (\n                eventType === MouseDown\n                || event.button !== 0\n            )\n        )\n    ) {\n        event.stopImmediatePropagation();\n        event.stopPropagation();\n        event.preventDefault();\n    }\n\n    // Handle releases\n    if (released & 1) { primaryUp(event); }\n    // Handle presses\n    if (pressed & 1) { primaryDown(event); }\n\n    // Handle mousemove\n    if (eventType === MouseMove) { onMouseMove(event); };\n}\n\nfunction primaryDown(event: MouseEvent): void {\n    // Reset readiness state.\n    canDrag = false;\n    canResize = false;\n\n    // Ignore repeated clicks on macOS and Linux.\n    if (!IsWindows()) {\n        if (event.type === 'mousedown' && event.button === 0 && event.detail !== 1) {\n            return;\n        }\n    }\n\n    if (resizeEdge) {\n        // Ready to resize if the primary button was pressed for the first time.\n        canResize = true;\n        // Do not start drag operations when on resize edges.\n        return;\n    }\n\n    // Retrieve target element\n    const target = eventTarget(event);\n\n    // Ready to drag if the primary button was pressed for the first time on a draggable element.\n    // Ignore clicks on the scrollbar.\n    const style = window.getComputedStyle(target);\n    canDrag = (\n        style.getPropertyValue(\"--wails-draggable\").trim() === \"drag\"\n        && (\n            event.offsetX - parseFloat(style.paddingLeft) < target.clientWidth\n            && event.offsetY - parseFloat(style.paddingTop) < target.clientHeight\n        )\n    );\n}\n\nfunction primaryUp(event: MouseEvent) {\n    // Stop dragging and resizing.\n    canDrag = false;\n    dragging = false;\n    canResize = false;\n    resizing = false;\n}\n\nconst cursorForEdge = Object.freeze({\n    \"se-resize\": \"nwse-resize\",\n    \"sw-resize\": \"nesw-resize\",\n    \"nw-resize\": \"nwse-resize\",\n    \"ne-resize\": \"nesw-resize\",\n    \"w-resize\": \"ew-resize\",\n    \"n-resize\": \"ns-resize\",\n    \"s-resize\": \"ns-resize\",\n    \"e-resize\": \"ew-resize\",\n})\n\nfunction setResize(edge?: keyof typeof cursorForEdge): void {\n    if (edge) {\n        if (!resizeEdge) { defaultCursor = document.body.style.cursor; }\n        document.body.style.cursor = cursorForEdge[edge];\n    } else if (!edge && resizeEdge) {\n        document.body.style.cursor = defaultCursor;\n    }\n\n    resizeEdge = edge || \"\";\n}\n\nfunction onMouseMove(event: MouseEvent): void {\n    if (canResize && resizeEdge) {\n        // Start resizing.\n        resizing = true;\n        invoke(\"wails:resize:\" + resizeEdge);\n    } else if (canDrag) {\n        // Start dragging.\n        dragging = true;\n        invoke(\"wails:drag\");\n    }\n\n    if (dragging || resizing) {\n        // Either drag or resize is ongoing,\n        // reset readiness and stop processing.\n        canDrag = canResize = false;\n        return;\n    }\n\n    if (!resizable || (!IsWindows() && !(IsLinux() && GetFlag(\"frameless\")))) {\n        if (resizeEdge) { setResize(); }\n        return;\n    }\n\n    const resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\n    const resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\n\n    // Extra pixels for the corner areas.\n    const cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\n\n    // When a scrollbar is present at the window edge it consumes mouse events in that strip.\n    // Shift the effective content edge inward so the resize zone sits just before the scrollbar.\n    const scrollbarWidth = Math.max(0, window.innerWidth - document.documentElement.clientWidth);\n    const scrollbarHeight = Math.max(0, window.innerHeight - document.documentElement.clientHeight);\n    const rightContentEdge = window.innerWidth - scrollbarWidth;\n    const bottomContentEdge = window.innerHeight - scrollbarHeight;\n\n    const rightBorder = event.clientX < rightContentEdge && (rightContentEdge - event.clientX) < resizeHandleWidth;\n    const leftBorder = event.clientX < resizeHandleWidth;\n    const topBorder = event.clientY < resizeHandleHeight;\n    const bottomBorder = event.clientY < bottomContentEdge && (bottomContentEdge - event.clientY) < resizeHandleHeight;\n\n    // Adjust for corner areas.\n    const rightCorner = event.clientX < rightContentEdge && (rightContentEdge - event.clientX) < (resizeHandleWidth + cornerExtra);\n    const leftCorner = event.clientX < (resizeHandleWidth + cornerExtra);\n    const topCorner = event.clientY < (resizeHandleHeight + cornerExtra);\n    const bottomCorner = event.clientY < bottomContentEdge && (bottomContentEdge - event.clientY) < (resizeHandleHeight + cornerExtra);\n\n    if (!leftCorner && !topCorner && !bottomCorner && !rightCorner) {\n        // Optimisation: out of all corner areas implies out of borders.\n        setResize();\n    }\n    // Detect corners.\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\n    // Detect borders.\n    else if (leftBorder) setResize(\"w-resize\");\n    else if (topBorder) setResize(\"n-resize\");\n    else if (bottomBorder) setResize(\"s-resize\");\n    else if (rightBorder) setResize(\"e-resize\");\n    // Out of border area.\n    else setResize();\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nconst call = newRuntimeCaller(objectNames.Application);\n\nconst HideMethod = 0;\nconst ShowMethod = 1;\nconst QuitMethod = 2;\n\n/**\n * Hides a certain method by calling the HideMethod function.\n */\nexport function Hide(): Promise<void> {\n    return call(HideMethod);\n}\n\n/**\n * Calls the ShowMethod and returns the result.\n */\nexport function Show(): Promise<void> {\n    return call(ShowMethod);\n}\n\n/**\n * Calls the QuitMethod to terminate the program.\n */\nexport function Quit(): Promise<void> {\n    return call(QuitMethod);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { CancellablePromise, type CancellablePromiseWithResolvers } from \"./cancellable.js\";\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { nanoid } from \"./nanoid.js\";\n\n// Setup\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    window._wails = window._wails || {};\n}\n\ntype PromiseResolvers = Omit<CancellablePromiseWithResolvers<any>, \"promise\" | \"oncancelled\">\n\nconst call = newRuntimeCaller(objectNames.Call);\nconst cancelCall = newRuntimeCaller(objectNames.CancelCall);\nconst callResponses = new Map<string, PromiseResolvers>();\n\nconst CallBinding = 0;\nconst CancelMethod = 0\n\n/**\n * Holds all required information for a binding call.\n * May provide either a method ID or a method name, but not both.\n */\nexport type CallOptions = {\n    /** The numeric ID of the bound method to call. */\n    methodID: number;\n    /** The fully qualified name of the bound method to call. */\n    methodName?: never;\n    /** Arguments to be passed into the bound method. */\n    args: any[];\n} | {\n    /** The numeric ID of the bound method to call. */\n    methodID?: never;\n    /** The fully qualified name of the bound method to call. */\n    methodName: string;\n    /** Arguments to be passed into the bound method. */\n    args: any[];\n};\n\n/**\n * Exception class that will be thrown in case the bound method returns an error.\n * The value of the {@link RuntimeError#name} property is \"RuntimeError\".\n */\nexport class RuntimeError extends Error {\n    /**\n     * Constructs a new RuntimeError instance.\n     * @param message - The error message.\n     * @param options - Options to be forwarded to the Error constructor.\n     */\n    constructor(message?: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"RuntimeError\";\n    }\n}\n\n/**\n * Generates a unique ID using the nanoid library.\n *\n * @returns A unique ID that does not exist in the callResponses set.\n */\nfunction generateID(): string {\n    let result;\n    do {\n        result = nanoid();\n    } while (callResponses.has(result));\n    return result;\n}\n\n/**\n * Call a bound method according to the given call options.\n *\n * In case of failure, the returned promise will reject with an exception\n * among ReferenceError (unknown method), TypeError (wrong argument count or type),\n * {@link RuntimeError} (method returned an error), or other (network or internal errors).\n * The exception might have a \"cause\" field with the value returned\n * by the application- or service-level error marshaling functions.\n *\n * @param options - A method call descriptor.\n * @returns The result of the call.\n */\nexport function Call(options: CallOptions): CancellablePromise<any> {\n    const id = generateID();\n\n    const result = CancellablePromise.withResolvers<any>();\n    callResponses.set(id, { resolve: result.resolve, reject: result.reject });\n\n    const request = call(CallBinding, Object.assign({ \"call-id\": id }, options));\n    let running = true;\n\n    request.then((res) => {\n        running = false;\n        callResponses.delete(id);\n        result.resolve(res);\n    }, (err) => {\n        running = false;\n        callResponses.delete(id);\n        result.reject(err);\n    });\n\n    const cancel = () => {\n        callResponses.delete(id);\n        return cancelCall(CancelMethod, {\"call-id\": id}).catch((err) => {\n            console.error(\"Error while requesting binding call cancellation:\", err);\n        });\n    };\n\n    result.oncancelled = () => {\n        if (running) {\n            return cancel();\n        } else {\n            return request.then(cancel);\n        }\n    };\n\n    return result.promise;\n}\n\n/**\n * Calls a bound method by name with the specified arguments.\n * See {@link Call} for details.\n *\n * @param methodName - The name of the method in the format 'package.struct.method'.\n * @param args - The arguments to pass to the method.\n * @returns The result of the method call.\n */\nexport function ByName(methodName: string, ...args: any[]): CancellablePromise<any> {\n    return Call({ methodName, args });\n}\n\n/**\n * Calls a method by its numeric ID with the specified arguments.\n * See {@link Call} for details.\n *\n * @param methodID - The ID of the method to call.\n * @param args - The arguments to pass to the method.\n * @return The result of the method call.\n */\nexport function ByID(methodID: number, ...args: any[]): CancellablePromise<any> {\n    return Call({ methodID, args });\n}\n", "// Source: https://github.com/inspect-js/is-callable\n\n// The MIT License (MIT)\n//\n// Copyright (c) 2015 Jordan Harband\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply: typeof Reflect.apply | false | null = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike: any;\nvar isCallableMarker: any;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n    try {\n        badArrayLike = Object.defineProperty({}, 'length', {\n            get: function () {\n                throw isCallableMarker;\n            }\n        });\n        isCallableMarker = {};\n        // eslint-disable-next-line no-throw-literal\n        reflectApply(function () { throw 42; }, null, badArrayLike);\n    } catch (_) {\n        if (_ !== isCallableMarker) {\n            reflectApply = null;\n        }\n    }\n} else {\n    reflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value: any): boolean {\n    try {\n        var fnStr = fnToStr.call(value);\n        return constructorRegex.test(fnStr);\n    } catch (e) {\n        return false; // not a function\n    }\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value: any): boolean {\n    try {\n        if (isES6ClassFn(value)) { return false; }\n        fnToStr.call(value);\n        return true;\n    } catch (e) {\n        return false;\n    }\n};\nvar toStr = Object.prototype.toString;\nvar objectClass = '[object Object]';\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\nvar ddaClass2 = '[object HTML document.all class]';\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\n\nvar isDDA: (value: any) => boolean = function isDocumentDotAll() { return false; };\nif (typeof document === 'object') {\n    // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\n    var all = document.all;\n    if (toStr.call(all) === toStr.call(document.all)) {\n        isDDA = function isDocumentDotAll(value) {\n            /* globals document: false */\n            // in IE 6-8, typeof document.all is \"object\" and it's truthy\n            if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\n                try {\n                    var str = toStr.call(value);\n                    return (\n                        str === ddaClass\n                        || str === ddaClass2\n                        || str === ddaClass3 // opera 12.16\n                        || str === objectClass // IE 6-8\n                    ) && value('') == null; // eslint-disable-line eqeqeq\n                } catch (e) { /**/ }\n            }\n            return false;\n        };\n    }\n}\n\nfunction isCallableRefApply<T>(value: T | unknown): value is (...args: any[]) => any  {\n    if (isDDA(value)) { return true; }\n    if (!value) { return false; }\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\n    try {\n        (reflectApply as any)(value, null, badArrayLike);\n    } catch (e) {\n        if (e !== isCallableMarker) { return false; }\n    }\n    return !isES6ClassFn(value) && tryFunctionObject(value);\n}\n\nfunction isCallableNoRefApply<T>(value: T | unknown): value is (...args: any[]) => any {\n    if (isDDA(value)) { return true; }\n    if (!value) { return false; }\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\n    if (hasToStringTag) { return tryFunctionObject(value); }\n    if (isES6ClassFn(value)) { return false; }\n    var strClass = toStr.call(value);\n    if (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\n    return tryFunctionObject(value);\n};\n\nexport default reflectApply ? isCallableRefApply : isCallableNoRefApply;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport isCallable from \"./callable.js\";\n\n/**\n * Exception class that will be used as rejection reason\n * in case a {@link CancellablePromise} is cancelled successfully.\n *\n * The value of the {@link name} property is the string `\"CancelError\"`.\n * The value of the {@link cause} property is the cause passed to the cancel method, if any.\n */\nexport class CancelError extends Error {\n    /**\n     * Constructs a new `CancelError` instance.\n     * @param message - The error message.\n     * @param options - Options to be forwarded to the Error constructor.\n     */\n    constructor(message?: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"CancelError\";\n    }\n}\n\n/**\n * Exception class that will be reported as an unhandled rejection\n * in case a {@link CancellablePromise} rejects after being cancelled,\n * or when the `oncancelled` callback throws or rejects.\n *\n * The value of the {@link name} property is the string `\"CancelledRejectionError\"`.\n * The value of the {@link cause} property is the reason the promise rejected with.\n *\n * Because the original promise was cancelled,\n * a wrapper promise will be passed to the unhandled rejection listener instead.\n * The {@link promise} property holds a reference to the original promise.\n */\nexport class CancelledRejectionError extends Error {\n    /**\n     * Holds a reference to the promise that was cancelled and then rejected.\n     */\n    promise: CancellablePromise<unknown>;\n\n    /**\n     * Constructs a new `CancelledRejectionError` instance.\n     * @param promise - The promise that caused the error originally.\n     * @param reason - The rejection reason.\n     * @param info - An optional informative message specifying the circumstances in which the error was thrown.\n     *               Defaults to the string `\"Unhandled rejection in cancelled promise.\"`.\n     */\n    constructor(promise: CancellablePromise<unknown>, reason?: any, info?: string) {\n        super((info ?? \"Unhandled rejection in cancelled promise.\") + \" Reason: \" + errorMessage(reason), { cause: reason });\n        this.promise = promise;\n        this.name = \"CancelledRejectionError\";\n    }\n}\n\ntype CancellablePromiseResolver<T> = (value: T | PromiseLike<T> | CancellablePromiseLike<T>) => void;\ntype CancellablePromiseRejector = (reason?: any) => void;\ntype CancellablePromiseCanceller = (cause?: any) => void | PromiseLike<void>;\ntype CancellablePromiseExecutor<T> = (resolve: CancellablePromiseResolver<T>, reject: CancellablePromiseRejector) => void;\n\nexport interface CancellablePromiseLike<T> {\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null): CancellablePromiseLike<TResult1 | TResult2>;\n    cancel(cause?: any): void | PromiseLike<void>;\n}\n\n/**\n * Wraps a cancellable promise along with its resolution methods.\n * The `oncancelled` field will be null initially but may be set to provide a custom cancellation function.\n */\nexport interface CancellablePromiseWithResolvers<T> {\n    promise: CancellablePromise<T>;\n    resolve: CancellablePromiseResolver<T>;\n    reject: CancellablePromiseRejector;\n    oncancelled: CancellablePromiseCanceller | null;\n}\n\ninterface CancellablePromiseState {\n    readonly root: CancellablePromiseState;\n    resolving: boolean;\n    settled: boolean;\n    reason?: CancelError;\n}\n\n// Private field names.\nconst barrierSym = Symbol(\"barrier\");\nconst cancelImplSym = Symbol(\"cancelImpl\");\nconst species: typeof Symbol.species = Symbol.species ?? Symbol(\"speciesPolyfill\");\n\n/**\n * A promise with an attached method for cancelling long-running operations (see {@link CancellablePromise#cancel}).\n * Cancellation can optionally be bound to an {@link AbortSignal}\n * for better composability (see {@link CancellablePromise#cancelOn}).\n *\n * Cancelling a pending promise will result in an immediate rejection\n * with an instance of {@link CancelError} as reason,\n * but whoever started the promise will be responsible\n * for actually aborting the underlying operation.\n * To this purpose, the constructor and all chaining methods\n * accept optional cancellation callbacks.\n *\n * If a `CancellablePromise` still resolves after having been cancelled,\n * the result will be discarded. If it rejects, the reason\n * will be reported as an unhandled rejection,\n * wrapped in a {@link CancelledRejectionError} instance.\n * To facilitate the handling of cancellation requests,\n * cancelled `CancellablePromise`s will _not_ report unhandled `CancelError`s\n * whose `cause` field is the same as the one with which the current promise was cancelled.\n *\n * All usual promise methods are defined and return a `CancellablePromise`\n * whose cancel method will cancel the parent operation as well, propagating the cancellation reason\n * upwards through promise chains.\n * Conversely, cancelling a promise will not automatically cancel dependent promises downstream:\n * ```ts\n * let root = new CancellablePromise((resolve, reject) => { ... });\n * let child1 = root.then(() => { ... });\n * let child2 = child1.then(() => { ... });\n * let child3 = root.catch(() => { ... });\n * child1.cancel(); // Cancels child1 and root, but not child2 or child3\n * ```\n * Cancelling a promise that has already settled is safe and has no consequence.\n *\n * The `cancel` method returns a promise that _always fulfills_\n * after the whole chain has processed the cancel request\n * and all attached callbacks up to that moment have run.\n *\n * All ES2024 promise methods (static and instance) are defined on CancellablePromise,\n * but actual availability may vary with OS/webview version.\n *\n * In line with the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing,\n * `CancellablePromise` does not support transparent subclassing.\n * Extenders should take care to provide their own method implementations.\n * This might be reconsidered in case the proposal is retired.\n *\n * CancellablePromise is a wrapper around the DOM Promise object\n * and is compliant with the [Promises/A+ specification](https://promisesaplus.com/)\n * (it passes the [compliance suite](https://github.com/promises-aplus/promises-tests))\n * if so is the underlying implementation.\n */\nexport class CancellablePromise<T> extends Promise<T> implements PromiseLike<T>, CancellablePromiseLike<T> {\n    // Private fields.\n    /** @internal */\n    private [barrierSym]!: Partial<PromiseWithResolvers<void>> | null;\n    /** @internal */\n    private readonly [cancelImplSym]!: (reason: CancelError) => void | PromiseLike<void>;\n\n    /**\n     * Creates a new `CancellablePromise`.\n     *\n     * @param executor - A callback used to initialize the promise. This callback is passed two arguments:\n     *                   a `resolve` callback used to resolve the promise with a value\n     *                   or the result of another promise (possibly cancellable),\n     *                   and a `reject` callback used to reject the promise with a provided reason or error.\n     *                   If the value provided to the `resolve` callback is a thenable _and_ cancellable object\n     *                   (it has a `then` _and_ a `cancel` method),\n     *                   cancellation requests will be forwarded to that object and the oncancelled will not be invoked anymore.\n     *                   If any one of the two callbacks is called _after_ the promise has been cancelled,\n     *                   the provided values will be cancelled and resolved as usual,\n     *                   but their results will be discarded.\n     *                   However, if the resolution process ultimately ends up in a rejection\n     *                   that is not due to cancellation, the rejection reason\n     *                   will be wrapped in a {@link CancelledRejectionError}\n     *                   and bubbled up as an unhandled rejection.\n     * @param oncancelled - It is the caller's responsibility to ensure that any operation\n     *                      started by the executor is properly halted upon cancellation.\n     *                      This optional callback can be used to that purpose.\n     *                      It will be called _synchronously_ with a cancellation cause\n     *                      when cancellation is requested, _after_ the promise has already rejected\n     *                      with a {@link CancelError}, but _before_\n     *                      any {@link then}/{@link catch}/{@link finally} callback runs.\n     *                      If the callback returns a thenable, the promise returned from {@link cancel}\n     *                      will only fulfill after the former has settled.\n     *                      Unhandled exceptions or rejections from the callback will be wrapped\n     *                      in a {@link CancelledRejectionError} and bubbled up as unhandled rejections.\n     *                      If the `resolve` callback is called before cancellation with a cancellable promise,\n     *                      cancellation requests on this promise will be diverted to that promise,\n     *                      and the original `oncancelled` callback will be discarded.\n     */\n    constructor(executor: CancellablePromiseExecutor<T>, oncancelled?: CancellablePromiseCanceller) {\n        let resolve!: (value: T | PromiseLike<T>) => void;\n        let reject!: (reason?: any) => void;\n        super((res, rej) => { resolve = res; reject = rej; });\n\n        if ((this.constructor as any)[species] !== Promise) {\n            throw new TypeError(\"CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.\");\n        }\n\n        let promise: CancellablePromiseWithResolvers<T> = {\n            promise: this,\n            resolve,\n            reject,\n            get oncancelled() { return oncancelled ?? null; },\n            set oncancelled(cb) { oncancelled = cb ?? undefined; }\n        };\n\n        const state: CancellablePromiseState = {\n            get root() { return state; },\n            resolving: false,\n            settled: false\n        };\n\n        // Setup cancellation system.\n        void Object.defineProperties(this, {\n            [barrierSym]: {\n                configurable: false,\n                enumerable: false,\n                writable: true,\n                value: null\n            },\n            [cancelImplSym]: {\n                configurable: false,\n                enumerable: false,\n                writable: false,\n                value: cancellerFor(promise, state)\n            }\n        });\n\n        // Run the actual executor.\n        const rejector = rejectorFor(promise, state);\n        try {\n            executor(resolverFor(promise, state), rejector);\n        } catch (err) {\n            if (state.resolving) {\n                console.log(\"Unhandled exception in CancellablePromise executor.\", err);\n            } else {\n                rejector(err);\n            }\n        }\n    }\n\n    /**\n     * Cancels immediately the execution of the operation associated with this promise.\n     * The promise rejects with a {@link CancelError} instance as reason,\n     * with the {@link CancelError#cause} property set to the given argument, if any.\n     *\n     * Has no effect if called after the promise has already settled;\n     * repeated calls in particular are safe, but only the first one\n     * will set the cancellation cause.\n     *\n     * The `CancelError` exception _need not_ be handled explicitly _on the promises that are being cancelled:_\n     * cancelling a promise with no attached rejection handler does not trigger an unhandled rejection event.\n     * Therefore, the following idioms are all equally correct:\n     * ```ts\n     * new CancellablePromise((resolve, reject) => { ... }).cancel();\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).cancel();\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).catch(...).cancel();\n     * ```\n     * Whenever some cancelled promise in a chain rejects with a `CancelError`\n     * with the same cancellation cause as itself, the error will be discarded silently.\n     * However, the `CancelError` _will still be delivered_ to all attached rejection handlers\n     * added by {@link then} and related methods:\n     * ```ts\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\n     * cancellable.then(() => { ... }).catch(console.log);\n     * cancellable.cancel(); // A CancelError is printed to the console.\n     * ```\n     * If the `CancelError` is not handled downstream by the time it reaches\n     * a _non-cancelled_ promise, it _will_ trigger an unhandled rejection event,\n     * just like normal rejections would:\n     * ```ts\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\n     * let chained = cancellable.then(() => { ... }).then(() => { ... }); // No catch...\n     * cancellable.cancel(); // Unhandled rejection event on chained!\n     * ```\n     * Therefore, it is important to either cancel whole promise chains from their tail,\n     * as shown in the correct idioms above, or take care of handling errors everywhere.\n     *\n     * @returns A cancellable promise that _fulfills_ after the cancel callback (if any)\n     * and all handlers attached up to the call to cancel have run.\n     * If the cancel callback returns a thenable, the promise returned by `cancel`\n     * will also wait for that thenable to settle.\n     * This enables callers to wait for the cancelled operation to terminate\n     * without being forced to handle potential errors at the call site.\n     * ```ts\n     * cancellable.cancel().then(() => {\n     *     // Cleanup finished, it's safe to do something else.\n     * }, (err) => {\n     *     // Unreachable: the promise returned from cancel will never reject.\n     * });\n     * ```\n     * Note that the returned promise will _not_ handle implicitly any rejection\n     * that might have occurred already in the cancelled chain.\n     * It will just track whether registered handlers have been executed or not.\n     * Therefore, unhandled rejections will never be silently handled by calling cancel.\n     */\n    cancel(cause?: any): CancellablePromise<void> {\n        return new CancellablePromise<void>((resolve) => {\n            // INVARIANT: the result of this[cancelImplSym] and the barrier do not ever reject.\n            // Unfortunately macOS High Sierra does not support Promise.allSettled.\n            Promise.all([\n                this[cancelImplSym](new CancelError(\"Promise cancelled.\", { cause })),\n                currentBarrier(this)\n            ]).then(() => resolve(), () => resolve());\n        });\n    }\n\n    /**\n     * Binds promise cancellation to the abort event of the given {@link AbortSignal}.\n     * If the signal has already aborted, the promise will be cancelled immediately.\n     * When either condition is verified, the cancellation cause will be set\n     * to the signal's abort reason (see {@link AbortSignal#reason}).\n     *\n     * Has no effect if called (or if the signal aborts) _after_ the promise has already settled.\n     * Only the first signal to abort will set the cancellation cause.\n     *\n     * For more details about the cancellation process,\n     * see {@link cancel} and the `CancellablePromise` constructor.\n     *\n     * This method enables `await`ing cancellable promises without having\n     * to store them for future cancellation, e.g.:\n     * ```ts\n     * await longRunningOperation().cancelOn(signal);\n     * ```\n     * instead of:\n     * ```ts\n     * let promiseToBeCancelled = longRunningOperation();\n     * await promiseToBeCancelled;\n     * ```\n     *\n     * @returns This promise, for method chaining.\n     */\n    cancelOn(signal: AbortSignal): CancellablePromise<T> {\n        if (signal.aborted) {\n            void this.cancel(signal.reason)\n        } else {\n            signal.addEventListener('abort', () => void this.cancel(signal.reason), {capture: true});\n        }\n\n        return this;\n    }\n\n    /**\n     * Attaches callbacks for the resolution and/or rejection of the `CancellablePromise`.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * @param onfulfilled The callback to execute when the Promise is resolved.\n     * @param onrejected The callback to execute when the Promise is rejected.\n     * @returns A `CancellablePromise` for the completion of whichever callback is executed.\n     * The returned promise is hooked up to propagate cancellation requests up the chain, but not down:\n     *\n     *   - if the parent promise is cancelled, the `onrejected` handler will be invoked with a `CancelError`\n     *     and the returned promise _will resolve regularly_ with its result;\n     *   - conversely, if the returned promise is cancelled, _the parent promise is cancelled too;_\n     *     the `onrejected` handler will still be invoked with the parent's `CancelError`,\n     *     but its result will be discarded\n     *     and the returned promise will reject with a `CancelError` as well.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If either callback returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     */\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<TResult1 | TResult2> {\n        if (!(this instanceof CancellablePromise)) {\n            throw new TypeError(\"CancellablePromise.prototype.then called on an invalid object.\");\n        }\n\n        // NOTE: TypeScript's built-in type for then is broken,\n        // as it allows specifying an arbitrary TResult1 != T even when onfulfilled is not a function.\n        // We cannot fix it if we want to CancellablePromise to implement PromiseLike<T>.\n\n        if (!isCallable(onfulfilled)) { onfulfilled = identity as any; }\n        if (!isCallable(onrejected)) { onrejected = thrower; }\n\n        if (onfulfilled === identity && onrejected == thrower) {\n            // Shortcut for trivial arguments.\n            return new CancellablePromise((resolve) => resolve(this as any));\n        }\n\n        const barrier: Partial<PromiseWithResolvers<void>> = {};\n        this[barrierSym] = barrier;\n\n        return new CancellablePromise<TResult1 | TResult2>((resolve, reject) => {\n            void super.then(\n                (value) => {\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\n                    barrier.resolve?.();\n\n                    try {\n                        resolve(onfulfilled!(value));\n                    } catch (err) {\n                        reject(err);\n                    }\n                },\n                (reason?) => {\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\n                    barrier.resolve?.();\n\n                    try {\n                        resolve(onrejected!(reason));\n                    } catch (err) {\n                        reject(err);\n                    }\n                }\n            );\n        }, async (cause?) => {\n            //cancelled = true;\n            try {\n                return oncancelled?.(cause);\n            } finally {\n                await this.cancel(cause);\n            }\n        });\n    }\n\n    /**\n     * Attaches a callback for only the rejection of the Promise.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * It is equivalent to\n     * ```ts\n     * cancellablePromise.then(undefined, onrejected, oncancelled);\n     * ```\n     * and the same caveats apply.\n     *\n     * @returns A Promise for the completion of the callback.\n     * Cancellation requests on the returned promise\n     * will propagate up the chain to the parent promise,\n     * but not in the other direction.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If `onrejected` returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     * See {@link then} for more details.\n     */\n    catch<TResult = never>(onrejected?: ((reason: any) => (PromiseLike<TResult> | TResult)) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T | TResult> {\n        return this.then(undefined, onrejected, oncancelled);\n    }\n\n    /**\n     * Attaches a callback that is invoked when the CancellablePromise is settled (fulfilled or rejected). The\n     * resolved value cannot be accessed or modified from the callback.\n     * The returned promise will settle in the same state as the original one\n     * after the provided callback has completed execution,\n     * unless the callback throws or returns a rejecting promise,\n     * in which case the returned promise will reject as well.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * Once the parent promise settles, the `onfinally` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * This method is implemented in terms of {@link then} and the same caveats apply.\n     * It is polyfilled, hence available in every OS/webview version.\n     *\n     * @returns A Promise for the completion of the callback.\n     * Cancellation requests on the returned promise\n     * will propagate up the chain to the parent promise,\n     * but not in the other direction.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If `onfinally` returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     * See {@link then} for more details.\n     */\n    finally(onfinally?: (() => void) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T> {\n        if (!(this instanceof CancellablePromise)) {\n            throw new TypeError(\"CancellablePromise.prototype.finally called on an invalid object.\");\n        }\n\n        if (!isCallable(onfinally)) {\n            return this.then(onfinally, onfinally, oncancelled);\n        }\n\n        return this.then(\n            (value) => CancellablePromise.resolve(onfinally()).then(() => value),\n            (reason?) => CancellablePromise.resolve(onfinally()).then(() => { throw reason; }),\n            oncancelled,\n        );\n    }\n\n    /**\n     * We use the `[Symbol.species]` static property, if available,\n     * to disable the built-in automatic subclassing features from {@link Promise}.\n     * It is critical for performance reasons that extenders do not override this.\n     * Once the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing\n     * is either accepted or retired, this implementation will have to be revised accordingly.\n     *\n     * @ignore\n     * @internal\n     */\n    static get [species]() {\n        return Promise;\n    }\n\n    /**\n     * Creates a CancellablePromise that is resolved with an array of results\n     * when all of the provided Promises resolve, or rejected when any Promise is rejected.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static all<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>[]>;\n    static all<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;\n    static all<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.all(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a CancellablePromise that is resolved with an array of results\n     * when all of the provided Promises resolve or reject.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static allSettled<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<PromiseSettledResult<Awaited<T>>[]>;\n    static allSettled<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;\n    static allSettled<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.allSettled(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * The any function returns a promise that is fulfilled by the first given promise to be fulfilled,\n     * or rejected with an AggregateError containing an array of rejection reasons\n     * if all of the given promises are rejected.\n     * It resolves all elements of the passed iterable to promises as it runs this algorithm.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static any<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\n    static any<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\n    static any<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.any(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved or rejected.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static race<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\n    static race<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\n    static race<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = new CancellablePromise<unknown>((resolve, reject) => {\n            void Promise.race(collected).then(resolve, reject);\n        }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a new cancelled CancellablePromise for the provided cause.\n     *\n     * @group Static Methods\n     */\n    static cancel<T = never>(cause?: any): CancellablePromise<T> {\n        const p = new CancellablePromise<T>(() => {});\n        p.cancel(cause);\n        return p;\n    }\n\n    /**\n     * Creates a new CancellablePromise that cancels\n     * after the specified timeout, with the provided cause.\n     *\n     * If the {@link AbortSignal.timeout} factory method is available,\n     * it is used to base the timeout on _active_ time rather than _elapsed_ time.\n     * Otherwise, `timeout` falls back to {@link setTimeout}.\n     *\n     * @group Static Methods\n     */\n    static timeout<T = never>(milliseconds: number, cause?: any): CancellablePromise<T> {\n        const promise = new CancellablePromise<T>(() => {});\n        if (AbortSignal && typeof AbortSignal === 'function' && AbortSignal.timeout && typeof AbortSignal.timeout === 'function') {\n            AbortSignal.timeout(milliseconds).addEventListener('abort', () => void promise.cancel(cause));\n        } else {\n            setTimeout(() => void promise.cancel(cause), milliseconds);\n        }\n        return promise;\n    }\n\n    /**\n     * Creates a new CancellablePromise that resolves after the specified timeout.\n     * The returned promise can be cancelled without consequences.\n     *\n     * @group Static Methods\n     */\n    static sleep(milliseconds: number): CancellablePromise<void>;\n    /**\n     * Creates a new CancellablePromise that resolves after\n     * the specified timeout, with the provided value.\n     * The returned promise can be cancelled without consequences.\n     *\n     * @group Static Methods\n     */\n    static sleep<T>(milliseconds: number, value: T): CancellablePromise<T>;\n    static sleep<T = void>(milliseconds: number, value?: T): CancellablePromise<T> {\n        return new CancellablePromise<T>((resolve) => {\n            setTimeout(() => resolve(value!), milliseconds);\n        });\n    }\n\n    /**\n     * Creates a new rejected CancellablePromise for the provided reason.\n     *\n     * @group Static Methods\n     */\n    static reject<T = never>(reason?: any): CancellablePromise<T> {\n        return new CancellablePromise<T>((_, reject) => reject(reason));\n    }\n\n    /**\n     * Creates a new resolved CancellablePromise.\n     *\n     * @group Static Methods\n     */\n    static resolve(): CancellablePromise<void>;\n    /**\n     * Creates a new resolved CancellablePromise for the provided value.\n     *\n     * @group Static Methods\n     */\n    static resolve<T>(value: T): CancellablePromise<Awaited<T>>;\n    /**\n     * Creates a new resolved CancellablePromise for the provided value.\n     *\n     * @group Static Methods\n     */\n    static resolve<T>(value: T | PromiseLike<T>): CancellablePromise<Awaited<T>>;\n    static resolve<T = void>(value?: T | PromiseLike<T>): CancellablePromise<Awaited<T>> {\n        if (value instanceof CancellablePromise) {\n            // Optimise for cancellable promises.\n            return value;\n        }\n        return new CancellablePromise<any>((resolve) => resolve(value));\n    }\n\n    /**\n     * Creates a new CancellablePromise and returns it in an object, along with its resolve and reject functions\n     * and a getter/setter for the cancellation callback.\n     *\n     * This method is polyfilled, hence available in every OS/webview version.\n     *\n     * @group Static Methods\n     */\n    static withResolvers<T>(): CancellablePromiseWithResolvers<T> {\n        let result: CancellablePromiseWithResolvers<T> = { oncancelled: null } as any;\n        result.promise = new CancellablePromise<T>((resolve, reject) => {\n            result.resolve = resolve;\n            result.reject = reject;\n        }, (cause?: any) => { result.oncancelled?.(cause); });\n        return result;\n    }\n}\n\n/**\n * Returns a callback that implements the cancellation algorithm for the given cancellable promise.\n * The promise returned from the resulting function does not reject.\n */\nfunction cancellerFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState) {\n    let cancellationPromise: void | PromiseLike<void> = undefined;\n\n    return (reason: CancelError): void | PromiseLike<void> => {\n        if (!state.settled) {\n            state.settled = true;\n            state.reason = reason;\n            promise.reject(reason);\n\n            // Attach an error handler that ignores this specific rejection reason and nothing else.\n            // In theory, a sane underlying implementation at this point\n            // should always reject with our cancellation reason,\n            // hence the handler will never throw.\n            void Promise.prototype.then.call(promise.promise, undefined, (err) => {\n                if (err !== reason) {\n                    throw err;\n                }\n            });\n        }\n\n        // If reason is not set, the promise resolved regularly, hence we must not call oncancelled.\n        // If oncancelled is unset, no need to go any further.\n        if (!state.reason || !promise.oncancelled) { return; }\n\n        cancellationPromise = new Promise<void>((resolve) => {\n            try {\n                resolve(promise.oncancelled!(state.reason!.cause));\n            } catch (err) {\n                Promise.reject(new CancelledRejectionError(promise.promise, err, \"Unhandled exception in oncancelled callback.\"));\n            }\n        }).catch((reason?) => {\n            Promise.reject(new CancelledRejectionError(promise.promise, reason, \"Unhandled rejection in oncancelled callback.\"));\n        });\n\n        // Unset oncancelled to prevent repeated calls.\n        promise.oncancelled = null;\n\n        return cancellationPromise;\n    }\n}\n\n/**\n * Returns a callback that implements the resolution algorithm for the given cancellable promise.\n */\nfunction resolverFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseResolver<T> {\n    return (value) => {\n        if (state.resolving) { return; }\n        state.resolving = true;\n\n        if (value === promise.promise) {\n            if (state.settled) { return; }\n            state.settled = true;\n            promise.reject(new TypeError(\"A promise cannot be resolved with itself.\"));\n            return;\n        }\n\n        if (value != null && (typeof value === 'object' || typeof value === 'function')) {\n            let then: any;\n            try {\n                then = (value as any).then;\n            } catch (err) {\n                state.settled = true;\n                promise.reject(err);\n                return;\n            }\n\n            if (isCallable(then)) {\n                try {\n                    let cancel = (value as any).cancel;\n                    if (isCallable(cancel)) {\n                        const oncancelled = (cause?: any) => {\n                            Reflect.apply(cancel, value, [cause]);\n                        };\n                        if (state.reason) {\n                            // If already cancelled, propagate cancellation.\n                            // The promise returned from the canceller algorithm does not reject\n                            // so it can be discarded safely.\n                            void cancellerFor({ ...promise, oncancelled }, state)(state.reason);\n                        } else {\n                            promise.oncancelled = oncancelled;\n                        }\n                    }\n                } catch {}\n\n                const newState: CancellablePromiseState = {\n                    root: state.root,\n                    resolving: false,\n                    get settled() { return this.root.settled },\n                    set settled(value) { this.root.settled = value; },\n                    get reason() { return this.root.reason }\n                };\n\n                const rejector = rejectorFor(promise, newState);\n                try {\n                    Reflect.apply(then, value, [resolverFor(promise, newState), rejector]);\n                } catch (err) {\n                    rejector(err);\n                }\n                return; // IMPORTANT!\n            }\n        }\n\n        if (state.settled) { return; }\n        state.settled = true;\n        promise.resolve(value);\n    };\n}\n\n/**\n * Returns a callback that implements the rejection algorithm for the given cancellable promise.\n */\nfunction rejectorFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseRejector {\n    return (reason?) => {\n        if (state.resolving) { return; }\n        state.resolving = true;\n\n        if (state.settled) {\n            try {\n                if (reason instanceof CancelError && state.reason instanceof CancelError && Object.is(reason.cause, state.reason.cause)) {\n                    // Swallow late rejections that are CancelErrors whose cancellation cause is the same as ours.\n                    return;\n                }\n            } catch {}\n\n            void Promise.reject(new CancelledRejectionError(promise.promise, reason));\n        } else {\n            state.settled = true;\n            promise.reject(reason);\n        }\n    }\n}\n\n/**\n * Cancels all values in an array that look like cancellable thenables.\n * Returns a promise that fulfills once all cancellation procedures for the given values have settled.\n */\nfunction cancelAll(parent: CancellablePromise<unknown>, values: any[], cause?: any): Promise<void> {\n    const results: Promise<void>[] = [];\n\n    for (const value of values) {\n        let cancel: CancellablePromiseCanceller;\n        try {\n            if (!isCallable(value.then)) { continue; }\n            cancel = value.cancel;\n            if (!isCallable(cancel)) { continue; }\n        } catch { continue; }\n\n        let result: void | PromiseLike<void>;\n        try {\n            result = Reflect.apply(cancel, value, [cause]);\n        } catch (err) {\n            Promise.reject(new CancelledRejectionError(parent, err, \"Unhandled exception in cancel method.\"));\n            continue;\n        }\n\n        if (!result) { continue; }\n        results.push(\n            (result instanceof Promise  ? result : Promise.resolve(result)).catch((reason?) => {\n                Promise.reject(new CancelledRejectionError(parent, reason, \"Unhandled rejection in cancel method.\"));\n            })\n        );\n    }\n\n    return Promise.all(results) as any;\n}\n\n/**\n * Returns its argument.\n */\nfunction identity<T>(x: T): T {\n    return x;\n}\n\n/**\n * Throws its argument.\n */\nfunction thrower(reason?: any): never {\n    throw reason;\n}\n\n/**\n * Attempts various strategies to convert an error to a string.\n */\nfunction errorMessage(err: any): string {\n    try {\n        if (err instanceof Error || typeof err !== 'object' || err.toString !== Object.prototype.toString) {\n            return \"\" + err;\n        }\n    } catch {}\n\n    try {\n        return JSON.stringify(err);\n    } catch {}\n\n    try {\n        return Object.prototype.toString.call(err);\n    } catch {}\n\n    return \"<could not convert error to string>\";\n}\n\n/**\n * Gets the current barrier promise for the given cancellable promise. If necessary, initialises the barrier.\n */\nfunction currentBarrier<T>(promise: CancellablePromise<T>): Promise<void> {\n    let pwr: Partial<PromiseWithResolvers<void>> = promise[barrierSym] ?? {};\n    if (!('promise' in pwr)) {\n        Object.assign(pwr, promiseWithResolvers<void>());\n    }\n    if (promise[barrierSym] == null) {\n        pwr.resolve!();\n        promise[barrierSym] = pwr;\n    }\n    return pwr.promise!;\n}\n\n// Polyfill Promise.withResolvers.\nlet promiseWithResolvers = Promise.withResolvers;\nif (promiseWithResolvers && typeof promiseWithResolvers === 'function') {\n    promiseWithResolvers = promiseWithResolvers.bind(Promise);\n} else {\n    promiseWithResolvers = function <T>(): PromiseWithResolvers<T> {\n        let resolve!: (value: T | PromiseLike<T>) => void;\n        let reject!: (reason?: any) => void;\n        const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });\n        return { promise, resolve, reject };\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Clipboard);\n\nconst ClipboardSetText = 0;\nconst ClipboardText = 1;\n\n/**\n * Sets the text to the Clipboard.\n *\n * @param text - The text to be set to the Clipboard.\n * @return A Promise that resolves when the operation is successful.\n */\nexport function SetText(text: string): Promise<void> {\n    return call(ClipboardSetText, {text});\n}\n\n/**\n * Get the Clipboard text\n *\n * @returns A promise that resolves with the text from the Clipboard.\n */\nexport function Text(): Promise<string> {\n    return call(ClipboardText);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nexport interface Size {\n    /** The width of a rectangular area. */\n    Width: number;\n    /** The height of a rectangular area. */\n    Height: number;\n}\n\nexport interface Rect {\n    /** The X coordinate of the origin. */\n    X: number;\n    /** The Y coordinate of the origin. */\n    Y: number;\n    /** The width of the rectangle. */\n    Width: number;\n    /** The height of the rectangle. */\n    Height: number;\n}\n\nexport interface Screen {\n    /** Unique identifier for the screen. */\n    ID: string;\n    /** Human-readable name of the screen. */\n    Name: string;\n    /** The scale factor of the screen (DPI/96). 1 = standard DPI, 2 = HiDPI (Retina), etc. */\n    ScaleFactor: number;\n    /** The X coordinate of the screen. */\n    X: number;\n    /** The Y coordinate of the screen. */\n    Y: number;\n    /** Contains the width and height of the screen. */\n    Size: Size;\n    /** Contains the bounds of the screen in terms of X, Y, Width, and Height. */\n    Bounds: Rect;\n    /** Contains the physical bounds of the screen in terms of X, Y, Width, and Height (before scaling). */\n    PhysicalBounds: Rect;\n    /** Contains the area of the screen that is actually usable (excluding taskbar and other system UI). */\n    WorkArea: Rect;\n    /** Contains the physical WorkArea of the screen (before scaling). */\n    PhysicalWorkArea: Rect;\n    /** True if this is the primary monitor selected by the user in the operating system. */\n    IsPrimary: boolean;\n    /** The rotation of the screen. */\n    Rotation: number;\n}\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nconst call = newRuntimeCaller(objectNames.Screens);\n\nconst getAll = 0;\nconst getPrimary = 1;\nconst getCurrent = 2;\nconst getByID = 3;\nconst getByIndex = 4;\n\n/**\n * Gets all screens.\n *\n * @returns A promise that resolves to an array of Screen objects.\n */\nexport function GetAll(): Promise<Screen[]> {\n    return call(getAll);\n}\n\n/**\n * Gets the primary screen.\n *\n * @returns A promise that resolves to the primary screen.\n */\nexport function GetPrimary(): Promise<Screen> {\n    return call(getPrimary);\n}\n\n/**\n * Gets the current active screen.\n *\n * @returns A promise that resolves with the current active screen.\n */\nexport function GetCurrent(): Promise<Screen> {\n    return call(getCurrent);\n}\n\n/**\n * Gets a screen by its unique display ID.\n *\n * @param id - The unique identifier of the screen.\n * @returns A promise that resolves to the matching Screen.\n */\nexport function GetByID(id: string): Promise<Screen> {\n    return call(getByID, { id });\n}\n\n/**\n * Gets a screen by its index in the screen list.\n *\n * @param index - The zero-based index of the screen.\n * @returns A promise that resolves to the matching Screen.\n */\nexport function GetByIndex(index: number): Promise<Screen> {\n    return call(getByIndex, { index });\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.IOS);\n\n// Method IDs\nconst HapticsImpact = 0;\nconst DeviceInfo = 1;\n\nexport namespace Haptics {\n    export type ImpactStyle = \"light\"|\"medium\"|\"heavy\"|\"soft\"|\"rigid\";\n    export function Impact(style: ImpactStyle = \"medium\"): Promise<void> {\n        return call(HapticsImpact, { style });\n    }\n}\n\nexport namespace Device {\n    export interface Info {\n        model: string;\n        systemName: string;\n        systemVersion: string;\n        isSimulator: boolean;\n    }\n    export function Info(): Promise<Info> {\n        return call(DeviceInfo);\n    }\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Android);\n\n// Method IDs (must match messageprocessor_android.go)\nconst HapticsVibrate = 0;\nconst DeviceInfo = 1;\nconst ToastShow = 2;\n\nexport namespace Haptics {\n    /** Vibrate the device for the given duration in milliseconds. */\n    export function Vibrate(durationMs: number = 100): Promise<void> {\n        return call(HapticsVibrate, { duration: durationMs });\n    }\n}\n\nexport namespace Device {\n    export interface Info {\n        platform: string;\n        manufacturer: string;\n        brand: string;\n        model: string;\n        device: string;\n        version: string;\n        sdkInt: number;\n    }\n    /** Return information about the Android device. */\n    export function Info(): Promise<Info> {\n        return call(DeviceInfo);\n    }\n}\n\nexport namespace Toast {\n    /** Show a short Android toast message. */\n    export function Show(message: string): Promise<void> {\n        return call(ToastShow, { message });\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Updater event name constants.\n *\n * Use these instead of hard-coding string literals when subscribing to\n * updater events from JavaScript:\n *\n *     import { Events, Updater } from \"@wailsio/runtime\";\n *\n *     Events.On(Updater.Events.UpdateAvailable, (e) => {\n *         console.log(\"update found:\", e.data.version);\n *     });\n *\n *     Events.On(Updater.Events.DownloadProgress, (e) => {\n *         const p = e.data;\n *         console.log(`${p.written} / ${p.total} bytes`);\n *     });\n *\n * Mirrors the Go-side constants in `pkg/updater/events.go` and the\n * user-action constants in `pkg/updater/window_lifecycle.go`. Any\n * changes here must stay in sync with those files \u2014 there's an\n * integration test that asserts the strings match.\n */\nexport const Events = Object.freeze({\n    /** A Check round-trip is starting. Payload: null. */\n    CheckStarted: \"wails:updater:check-started\",\n    /** Check found a newer release. Payload: Release. */\n    UpdateAvailable: \"wails:updater:update-available\",\n    /** Check confirmed the caller is up to date. Payload: null. */\n    NoUpdate: \"wails:updater:no-update\",\n    /** Download is starting. Payload: Release. */\n    DownloadStarted: \"wails:updater:download-started\",\n    /** Periodic progress tick during download (~10 Hz). Payload: Progress. */\n    DownloadProgress: \"wails:updater:download-progress\",\n    /** All bytes are on disk, but verification has not yet started. Payload: Release. */\n    DownloadComplete: \"wails:updater:download-complete\",\n    /** Signature / digest verification has started. Payload: Release. */\n    Verifying: \"wails:updater:verifying\",\n    /** The Updater is swapping the binary into place. Payload: Release. */\n    Installing: \"wails:updater:installing\",\n    /** Update is staged and a restart is pending. Payload: Release. */\n    UpdateReady: \"wails:updater:update-ready\",\n    /** Something failed. Payload: ErrorInfo { stage, message, provider }. */\n    Error: \"wails:updater:error\",\n    /** Host-side context delivered once per session. Payload: Meta { currentVersion, skippedVersion }. */\n    Meta: \"wails:updater:meta\",\n\n    /** Sub-namespace: user-action events that the UI emits BACK to the host. */\n    User: Object.freeze({\n        /** User clicked Install on an Available update. */\n        Install: \"wails:updater:user:install\",\n        /** User clicked Restart & Apply on a Ready update. */\n        Restart: \"wails:updater:user:restart\",\n        /** User clicked Skip This Version. */\n        Skip: \"wails:updater:user:skip\",\n        /** User clicked Remind Me Later. */\n        Remind: \"wails:updater:user:remind\",\n        /** User clicked Close / Cancel. */\n        Cancel: \"wails:updater:user:cancel\",\n    }),\n\n    /** Sub-namespace: framework-internal events the UI emits to coordinate\n     *  with the host. Most app code can ignore these. */\n    Window: Object.freeze({\n        /** The window finished loading and asks the host to replay current state. */\n        Ready: \"wails:updater:window:ready\",\n    }),\n});\n"],
  "mappings": "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",
  "names": ["_a", "Error", "call", "Error", "_a", "Array", "Map", "Array", "Map", "key", "call", "_a", "_a", "resizable", "_a", "call", "_a", "call", "_a", "call", "HideMethod", "ShowMethod", "isDocumentDotAll", "_a", "reason", "value", "call", "call", "call", "call", "Haptics", "Device", "Info", "Device", "Haptics", "call", "DeviceInfo", "Haptics", "Device", "Info", "Toast", "Show", "Events", "Events"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../runtime/desktop/@wailsio/runtime/src/index.ts", "../../runtime/desktop/@wailsio/runtime/src/wml.ts", "../../runtime/desktop/@wailsio/runtime/src/browser.ts", "../../runtime/desktop/@wailsio/runtime/src/nanoid.ts", "../../runtime/desktop/@wailsio/runtime/src/environment.ts", "../../runtime/desktop/@wailsio/runtime/src/runtime.ts", "../../runtime/desktop/@wailsio/runtime/src/dialogs.ts", "../../runtime/desktop/@wailsio/runtime/src/events.ts", "../../runtime/desktop/@wailsio/runtime/src/listener.ts", "../../runtime/desktop/@wailsio/runtime/src/create.ts", "../../runtime/desktop/@wailsio/runtime/src/event_types.ts", "../../runtime/desktop/@wailsio/runtime/src/utils.ts", "../../runtime/desktop/@wailsio/runtime/src/window.ts", "../../runtime/desktop/compiled/main.js", "../../runtime/desktop/@wailsio/runtime/src/system.ts", "../../runtime/desktop/@wailsio/runtime/src/contextmenu.ts", "../../runtime/desktop/@wailsio/runtime/src/flags.ts", "../../runtime/desktop/@wailsio/runtime/src/drag.ts", "../../runtime/desktop/@wailsio/runtime/src/appregion.ts", "../../runtime/desktop/@wailsio/runtime/src/application.ts", "../../runtime/desktop/@wailsio/runtime/src/calls.ts", "../../runtime/desktop/@wailsio/runtime/src/callable.ts", "../../runtime/desktop/@wailsio/runtime/src/cancellable.ts", "../../runtime/desktop/@wailsio/runtime/src/clipboard.ts", "../../runtime/desktop/@wailsio/runtime/src/screens.ts", "../../runtime/desktop/@wailsio/runtime/src/ios.ts", "../../runtime/desktop/@wailsio/runtime/src/android.ts", "../../runtime/desktop/@wailsio/runtime/src/updater.ts"],
  "sourcesContent": ["/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Setup\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    window._wails = window._wails || {};\n}\n\nimport \"./contextmenu.js\";\nimport \"./drag.js\";\nimport \"./appregion.js\";\n\n// Re-export public API\nimport * as Application from \"./application.js\";\nimport * as Browser from \"./browser.js\";\nimport * as Call from \"./calls.js\";\nimport * as Clipboard from \"./clipboard.js\";\nimport * as Create from \"./create.js\";\nimport * as Dialogs from \"./dialogs.js\";\nimport * as Events from \"./events.js\";\nimport * as Flags from \"./flags.js\";\nimport * as Screens from \"./screens.js\";\nimport * as System from \"./system.js\";\nimport * as IOS from \"./ios.js\";\nimport * as Android from \"./android.js\";\nimport * as Updater from \"./updater.js\";\nimport Window, { handleDragEnter, handleDragLeave, handleDragOver } from \"./window.js\";\nimport * as WML from \"./wml.js\";\n\nexport {\n    Application,\n    Browser,\n    Call,\n    Clipboard,\n    Dialogs,\n    Events,\n    Flags,\n    Screens,\n    System,\n    IOS,\n    Android,\n    Updater,\n    Window,\n    WML\n};\n\n/**\n * An internal utility consumed by the binding generator.\n *\n * @ignore\n */\nexport { Create };\n\nexport * from \"./cancellable.js\";\n\n// Export transport interfaces and utilities\nexport {\n    setTransport,\n    getTransport,\n    type RuntimeTransport,\n    objectNames,\n    clientId,\n} from \"./runtime.js\";\n\nimport { clientId } from \"./runtime.js\";\n\n// Notify backend\nif (hasDOM) {\n    window._wails.invoke = System.invoke;\n    window._wails.clientId = clientId;\n}\n\n// Register platform handlers (internal API)\n// Note: Window is the thisWindow instance (default export from window.ts)\n// Binding ensures 'this' correctly refers to the current window instance\nif (hasDOM) {\n    window._wails.handlePlatformFileDrop = Window.HandlePlatformFileDrop.bind(Window);\n}\n\n// Linux-specific drag handlers (GTK intercepts DOM drag events)\nif (hasDOM) {\n    window._wails.handleDragEnter = handleDragEnter;\n    window._wails.handleDragLeave = handleDragLeave;\n    window._wails.handleDragOver = handleDragOver;\n}\n\nif (hasDOM) {\n    System.invoke(\"wails:runtime:ready\");\n}\n\n/**\n * Loads a script from the given URL if it exists.\n * Uses HEAD request to check existence, then injects a script tag.\n * Silently ignores if the script doesn't exist.\n */\nexport function loadOptionalScript(url: string): Promise<void> {\n    return fetch(url, { method: 'HEAD' })\n        .then(response => {\n            if (response.ok) {\n                // Verify the response is actually JavaScript and not an HTML fallback\n                // (e.g. Vite dev server returns index.html for unknown routes)\n                const contentType = (response.headers.get('content-type') || '').toLowerCase();\n                if (contentType.includes('javascript')) {\n                    const script = document.createElement('script');\n                    script.src = url;\n                    document.head.appendChild(script);\n                }\n            }\n        })\n        .catch(() => {}); // Silently ignore - script is optional\n}\n\n// Load custom.js if available (used by server mode for WebSocket events, etc.)\nif (hasDOM) {\n    loadOptionalScript('/wails/custom.js');\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { OpenURL } from \"./browser.js\";\nimport { Question } from \"./dialogs.js\";\nimport { Emit } from \"./events.js\";\nimport { canAbortListeners, whenReady } from \"./utils.js\";\nimport Window from \"./window.js\";\n\n/**\n * Sends an event with the given name and optional data.\n *\n * @param eventName - - The name of the event to send.\n * @param [data=null] - - Optional data to send along with the event.\n */\nfunction sendEvent(eventName: string, data: any = null): void {\n    Emit(eventName, data);\n}\n\n/**\n * Calls a method on a specified window.\n *\n * @param windowName - The name of the window to call the method on.\n * @param methodName - The name of the method to call.\n */\nfunction callWindowMethod(windowName: string, methodName: string) {\n    const targetWindow = Window.Get(windowName);\n    const method = (targetWindow as any)[methodName];\n\n    if (typeof method !== \"function\") {\n        console.error(`Window method '${methodName}' not found`);\n        return;\n    }\n\n    try {\n        method.call(targetWindow);\n    } catch (e) {\n        console.error(`Error calling window method '${methodName}': `, e);\n    }\n}\n\n/**\n * Responds to a triggering event by running appropriate WML actions for the current target.\n */\nfunction onWMLTriggered(ev: Event): void {\n    const element = ev.currentTarget as Element;\n\n    function runEffect(choice = \"Yes\") {\n        if (choice !== \"Yes\")\n            return;\n\n        const eventType = element.getAttribute('wml-event') || element.getAttribute('data-wml-event');\n        const targetWindow = element.getAttribute('wml-target-window') || element.getAttribute('data-wml-target-window') || \"\";\n        const windowMethod = element.getAttribute('wml-window') || element.getAttribute('data-wml-window');\n        const url = element.getAttribute('wml-openurl') || element.getAttribute('data-wml-openurl');\n\n        if (eventType !== null)\n            sendEvent(eventType);\n        if (windowMethod !== null)\n            callWindowMethod(targetWindow, windowMethod);\n        if (url !== null)\n            void OpenURL(url);\n    }\n\n    const confirm = element.getAttribute('wml-confirm') || element.getAttribute('data-wml-confirm');\n\n    if (confirm) {\n        Question({\n            Title: \"Confirm\",\n            Message: confirm,\n            Detached: false,\n            Buttons: [\n                { Label: \"Yes\" },\n                { Label: \"No\", IsDefault: true }\n            ]\n        }).then(runEffect);\n    } else {\n        runEffect();\n    }\n}\n\n// Private field names.\nconst controllerSym = Symbol(\"controller\");\nconst triggerMapSym = Symbol(\"triggerMap\");\nconst elementCountSym = Symbol(\"elementCount\");\n\n/**\n * AbortControllerRegistry does not actually remember active event listeners: instead\n * it ties them to an AbortSignal and uses an AbortController to remove them all at once.\n */\nclass AbortControllerRegistry {\n    // Private fields.\n    [controllerSym]: AbortController;\n\n    constructor() {\n        this[controllerSym] = new AbortController();\n    }\n\n    /**\n     * Returns an options object for addEventListener that ties the listener\n     * to the AbortSignal from the current AbortController.\n     *\n     * @param element - An HTML element\n     * @param triggers - The list of active WML trigger events for the specified elements\n     */\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\n        return { signal: this[controllerSym].signal };\n    }\n\n    /**\n     * Removes all registered event listeners and resets the registry.\n     */\n    reset(): void {\n        this[controllerSym].abort();\n        this[controllerSym] = new AbortController();\n    }\n}\n\n/**\n * WeakMapRegistry maps active trigger events to each DOM element through a WeakMap.\n * This ensures that the mapping remains private to this module, while still allowing garbage\n * collection of the involved elements.\n */\nclass WeakMapRegistry {\n    /** Stores the current element-to-trigger mapping. */\n    [triggerMapSym]: WeakMap<Element, string[]>;\n    /** Counts the number of elements with active WML triggers. */\n    [elementCountSym]: number;\n\n    constructor() {\n        this[triggerMapSym] = new WeakMap();\n        this[elementCountSym] = 0;\n    }\n\n    /**\n     * Sets active triggers for the specified element.\n     *\n     * @param element - An HTML element\n     * @param triggers - The list of active WML trigger events for the specified element\n     */\n    set(element: Element, triggers: string[]): AddEventListenerOptions {\n        if (!this[triggerMapSym].has(element)) { this[elementCountSym]++; }\n        this[triggerMapSym].set(element, triggers);\n        return {};\n    }\n\n    /**\n     * Removes all registered event listeners.\n     */\n    reset(): void {\n        if (this[elementCountSym] <= 0)\n            return;\n\n        for (const element of document.body.querySelectorAll('*')) {\n            if (this[elementCountSym] <= 0)\n                break;\n\n            const triggers = this[triggerMapSym].get(element);\n            if (triggers != null) { this[elementCountSym]--; }\n\n            for (const trigger of triggers || [])\n                element.removeEventListener(trigger, onWMLTriggered);\n        }\n\n        this[triggerMapSym] = new WeakMap();\n        this[elementCountSym] = 0;\n    }\n}\n\nconst triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();\n\n/**\n * Adds event listeners to the specified element.\n */\nfunction addWMLListeners(element: Element): void {\n    const triggerRegExp = /\\S+/g;\n    const triggerAttr = (element.getAttribute('wml-trigger') || element.getAttribute('data-wml-trigger') || \"click\");\n    const triggers: string[] = [];\n\n    let match;\n    while ((match = triggerRegExp.exec(triggerAttr)) !== null)\n        triggers.push(match[0]);\n\n    const options = triggerRegistry.set(element, triggers);\n    for (const trigger of triggers)\n        element.addEventListener(trigger, onWMLTriggered, options);\n}\n\n/**\n * Schedules an automatic reload of WML to be performed as soon as the document is fully loaded.\n */\nexport function Enable(): void {\n    whenReady(Reload);\n}\n\n/**\n * Reloads the WML page by adding necessary event listeners and browser listeners.\n */\nexport function Reload(): void {\n    triggerRegistry.reset();\n    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]').forEach(addWMLListeners);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Browser);\n\nconst BrowserOpenURL = 0;\n\n/**\n * Open a browser window to the given URL.\n *\n * @param url - The URL to open\n */\nexport function OpenURL(url: string | URL): Promise<void> {\n    return call(BrowserOpenURL, {url: url.toString()});\n}\n", "// Source: https://github.com/ai/nanoid\n\n// The MIT License (MIT)\n//\n// Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n//     subject to the following conditions:\n//\n//     The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n//     THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// This alphabet uses `A-Za-z0-9_-` symbols.\n// The order of characters is optimized for better gzip and brotli compression.\n// References to the same file (works both for gzip and brotli):\n// `'use`, `andom`, and `rict'`\n// References to the brotli default dictionary:\n// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`\nconst urlAlphabet =\n    'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\n\nexport function nanoid(size: number = 21): string {\n    let id = ''\n    // A compact alternative for `for (var i = 0; i < step; i++)`.\n    let i = size | 0\n    while (i--) {\n        // `| 0` is more compact and faster than `Math.floor()`.\n        id += urlAlphabet[(Math.random() * 64) | 0]\n    }\n    return id\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * True when running inside a browser/webview with a DOM available.\n * False under server-side rendering (e.g. `next build` prerendering),\n * where application code may import the runtime module even though no\n * Wails APIs can actually be used (#4679). Modules must not touch\n * `window`/`document` at import time except behind this guard.\n */\nexport const hasDOM = typeof window !== \"undefined\" && typeof document !== \"undefined\";\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { nanoid } from \"./nanoid.js\";\nimport { hasDOM } from \"./environment.js\";\n\n// Resolved lazily: window does not exist when the module is imported during\n// server-side rendering (#4679), and nothing can call the runtime there.\nfunction runtimeURL(): string {\n    return window.location.origin + \"/wails/runtime\";\n}\n\n// Stay under WebView2's ~2MB request body buffering limit in WebResourceRequested.\nconst CHUNK_THRESHOLD = 512 * 1024;\n\n// Re-export nanoid for custom transport implementations\nexport { nanoid };\n\ntype CallErrorType = {\n    message: string,\n    cause?: unknown,\n    kind: \"ReferenceError\" | \"TypeError\" | \"RuntimeError\"\n}\n\n/**\n * Exception class that will be thrown in case the bound method returns an error.\n * The value of the {@link RuntimeError#name} property is \"RuntimeError\".\n */\nexport class RuntimeError extends Error {\n    /**\n     * Constructs a new RuntimeError instance.\n     * @param message - The error message.\n     * @param options - Options to be forwarded to the Error constructor.\n     */\n    constructor(message?: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"RuntimeError\";\n    }\n}\n\n// Object Names\nexport const objectNames = Object.freeze({\n    Call: 0,\n    Clipboard: 1,\n    Application: 2,\n    Events: 3,\n    ContextMenu: 4,\n    Dialog: 5,\n    Window: 6,\n    Screens: 7,\n    System: 8,\n    Browser: 9,\n    CancelCall: 10,\n    IOS: 11,\n    Android: 12,\n});\nexport let clientId = nanoid();\n\n/**\n * RuntimeTransport defines the interface for custom IPC transport implementations.\n * Implement this interface to use WebSockets, custom protocols, or any other\n * transport mechanism instead of the default HTTP fetch.\n */\nexport interface RuntimeTransport {\n    /**\n     * Send a runtime call and return the response.\n     *\n     * @param objectID - The Wails object ID (0=Call, 1=Clipboard, etc.)\n     * @param method - The method ID to call\n     * @param windowName - Optional window name\n     * @param args - Arguments to pass (will be JSON stringified if present)\n     * @returns Promise that resolves with the response data\n     */\n    call(objectID: number, method: number, windowName: string, args: any): Promise<any>;\n}\n\n/**\n * Custom transport implementation (can be set by user)\n */\nlet customTransport: RuntimeTransport | null = null;\n\n/**\n * Set a custom transport for all Wails runtime calls.\n * This allows you to replace the default HTTP fetch transport with\n * WebSockets, custom protocols, or any other mechanism.\n *\n * @param transport - Your custom transport implementation\n *\n * @example\n * ```typescript\n * import { setTransport } from '/wails/runtime.js';\n *\n * const wsTransport = {\n *   call: async (objectID, method, windowName, args) => {\n *     // Your WebSocket implementation\n *   }\n * };\n *\n * setTransport(wsTransport);\n * ```\n */\nexport function setTransport(transport: RuntimeTransport | null): void {\n    customTransport = transport;\n}\n\n/**\n * Get the current transport (useful for extending/wrapping)\n */\nexport function getTransport(): RuntimeTransport | null {\n    return customTransport;\n}\n\n/**\n * Creates a new runtime caller with specified ID.\n *\n * @param object - The object to invoke the method on.\n * @param windowName - The name of the window.\n * @return The new runtime caller function.\n */\nexport function newRuntimeCaller(object: number, windowName: string = '') {\n    return function (method: number, args: any = null) {\n        return runtimeCallWithID(object, method, windowName, args);\n    };\n}\n\nasync function runtimeCallWithID(objectID: number, method: number, windowName: string, args: any): Promise<any> {\n    // Use custom transport if available\n    if (customTransport) {\n        return customTransport.call(objectID, method, windowName, args);\n    }\n\n    // Default HTTP fetch transport\n    let url = new URL(runtimeURL());\n\n    let body: { object: number; method: number, args?: any } = {\n      object: objectID,\n      method\n    }\n    if (args !== null && args !== undefined) {\n      body.args = args;\n    }\n\n    let headers: Record<string, string> = {\n        [\"x-wails-client-id\"]: clientId,\n        [\"Content-Type\"]: \"application/json\"\n    }\n    if (windowName) {\n        headers[\"x-wails-window-name\"] = windowName;\n    }\n\n    const bodyStr = JSON.stringify(body);\n    let response: Response;\n    if (bodyStr.length > CHUNK_THRESHOLD) {\n        response = await sendChunked(url, headers, bodyStr);\n    } else {\n        response = await fetch(url, { method: 'POST', headers, body: bodyStr });\n    }\n    if (!response.ok) {\n      const ct = response.headers.get(\"Content-Type\");\n      if (ct?.includes(\"application/json\")) {\n          const json: CallErrorType = await response.json();\n          let err;\n          switch (json.kind) {\n              case \"ReferenceError\": err = new ReferenceError(json.message); break;\n              case \"TypeError\":      err = new TypeError(json.message); break;\n              case \"RuntimeError\":   err = new RuntimeError(json.message); break;\n              default:               err = new Error(json.message);\n          }\n          err.cause = json.cause;\n          throw err\n      }\n      throw new Error(await response.text());\n    }\n\n    if ((response.headers.get(\"Content-Type\")?.indexOf(\"application/json\") ?? -1) !== -1) {\n        return response.json();\n    } else {\n        return response.text();\n    }\n}\n\n// sendChunked splits a large serialised request body into CHUNK_THRESHOLD-sized\n// byte chunks and sends them serially.  Encoding to UTF-8 bytes before slicing\n// prevents corruption of non-BMP characters (surrogate pairs) that would occur\n// when splitting at JavaScript string indices.  The Go transport assembles the\n// raw bytes before processing.  Only the final chunk's response carries the RPC result.\nasync function sendChunked(url: URL, headers: Record<string, string>, bodyStr: string): Promise<Response> {\n    const chunkId = nanoid();\n    const bodyBytes = new TextEncoder().encode(bodyStr);\n    const totalChunks = Math.ceil(bodyBytes.length / CHUNK_THRESHOLD);\n\n    for (let i = 0; i < totalChunks - 1; i++) {\n        const chunk = bodyBytes.subarray(i * CHUNK_THRESHOLD, (i + 1) * CHUNK_THRESHOLD);\n        const resp = await fetch(url, {\n            method: 'POST',\n            headers: {\n                ...headers,\n                'x-wails-chunk-id': chunkId,\n                'x-wails-chunk-index': String(i),\n                'x-wails-chunk-total': String(totalChunks),\n            },\n            body: chunk,\n        });\n        if (!resp.ok) {\n            throw new Error(await resp.text());\n        }\n    }\n\n    return fetch(url, {\n        method: 'POST',\n        headers: {\n            ...headers,\n            'x-wails-chunk-id': chunkId,\n            'x-wails-chunk-index': String(totalChunks - 1),\n            'x-wails-chunk-total': String(totalChunks),\n        },\n        body: bodyBytes.subarray((totalChunks - 1) * CHUNK_THRESHOLD),\n    });\n}\n\n/**\n * Android WebView cannot deliver fetch() POST bodies to\n * shouldInterceptRequest, so the default HTTP transport cannot reach Go.\n * When the Android JavascriptInterface bridge (window.wails) is present,\n * route runtime calls through it instead. Responses arrive via\n * window._wailsAndroidCallback, invoked by the Java side.\n */\ninterface AndroidJSBridge {\n    invokeAsync(callbackID: string, payload: string): void;\n}\n\nconst androidBridge: AndroidJSBridge | null = hasDOM &&\n    typeof (window as any).wails?.invokeAsync === \"function\" ? (window as any).wails : null;\n\nif (androidBridge) {\n    const pending = new Map<string, { resolve: (value: any) => void; reject: (reason: any) => void }>();\n\n    (window as any)._wailsAndroidCallback = (id: string, response: string | null, error: string | null) => {\n        const promise = pending.get(id);\n        if (!promise) return;\n        pending.delete(id);\n        if (error) {\n            promise.reject(new Error(error));\n            return;\n        }\n        try {\n            const envelope = JSON.parse(response ?? \"{}\");\n            if (!envelope.ok) {\n                promise.reject(new Error(envelope.error ?? \"unknown runtime call error\"));\n                return;\n            }\n            promise.resolve(\"text\" in envelope ? envelope.text : envelope.data);\n        } catch (e) {\n            promise.reject(e);\n        }\n    };\n\n    customTransport = {\n        call(objectID: number, method: number, windowName: string, args: any): Promise<any> {\n            return new Promise((resolve, reject) => {\n                const id = nanoid();\n                pending.set(id, { resolve, reject });\n                try {\n                    androidBridge.invokeAsync(id, JSON.stringify({\n                        object: objectID,\n                        method: method,\n                        windowName: windowName,\n                        args: args ?? null,\n                        clientId: clientId,\n                    }));\n                } catch (e) {\n                    // Don't leak the pending entry if dispatch throws synchronously\n                    pending.delete(id);\n                    reject(e);\n                }\n            });\n        },\n    };\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\n\n// setup\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    window._wails = window._wails || {};\n}\n\nconst call = newRuntimeCaller(objectNames.Dialog);\n\n// Define constants from the `methods` object in Title Case\nconst DialogInfo = 0;\nconst DialogWarning = 1;\nconst DialogError = 2;\nconst DialogQuestion = 3;\nconst DialogOpenFile = 4;\nconst DialogSaveFile = 5;\n\nexport interface OpenFileDialogOptions {\n    /** Indicates if directories can be chosen. */\n    CanChooseDirectories?: boolean;\n    /** Indicates if files can be chosen. */\n    CanChooseFiles?: boolean;\n    /** Indicates if directories can be created. */\n    CanCreateDirectories?: boolean;\n    /** Indicates if hidden files should be shown. */\n    ShowHiddenFiles?: boolean;\n    /** Indicates if aliases should be resolved. */\n    ResolvesAliases?: boolean;\n    /** Indicates if multiple selection is allowed. */\n    AllowsMultipleSelection?: boolean;\n    /** Indicates if the extension should be hidden. */\n    HideExtension?: boolean;\n    /** Indicates if hidden extensions can be selected. */\n    CanSelectHiddenExtension?: boolean;\n    /** Indicates if file packages should be treated as directories. */\n    TreatsFilePackagesAsDirectories?: boolean;\n    /** Indicates if other file types are allowed. */\n    AllowsOtherFiletypes?: boolean;\n    /** Array of file filters. */\n    Filters?: FileFilter[];\n    /** Title of the dialog. */\n    Title?: string;\n    /** Message to show in the dialog. */\n    Message?: string;\n    /** Text to display on the button. */\n    ButtonText?: string;\n    /** Directory to open in the dialog. */\n    Directory?: string;\n    /** Indicates if the dialog should appear detached from the main window. */\n    Detached?: boolean;\n}\n\nexport interface SaveFileDialogOptions {\n    /** Default filename to use in the dialog. */\n    Filename?: string;\n    /** Indicates if directories can be chosen. */\n    CanChooseDirectories?: boolean;\n    /** Indicates if files can be chosen. */\n    CanChooseFiles?: boolean;\n    /** Indicates if directories can be created. */\n    CanCreateDirectories?: boolean;\n    /** Indicates if hidden files should be shown. */\n    ShowHiddenFiles?: boolean;\n    /** Indicates if aliases should be resolved. */\n    ResolvesAliases?: boolean;\n    /** Indicates if the extension should be hidden. */\n    HideExtension?: boolean;\n    /** Indicates if hidden extensions can be selected. */\n    CanSelectHiddenExtension?: boolean;\n    /** Indicates if file packages should be treated as directories. */\n    TreatsFilePackagesAsDirectories?: boolean;\n    /** Indicates if other file types are allowed. */\n    AllowsOtherFiletypes?: boolean;\n    /** Array of file filters. */\n    Filters?: FileFilter[];\n    /** Title of the dialog. */\n    Title?: string;\n    /** Message to show in the dialog. */\n    Message?: string;\n    /** Text to display on the button. */\n    ButtonText?: string;\n    /** Directory to open in the dialog. */\n    Directory?: string;\n    /** Indicates if the dialog should appear detached from the main window. */\n    Detached?: boolean;\n}\n\nexport interface MessageDialogOptions {\n    /** The title of the dialog window. */\n    Title?: string;\n    /** The main message to show in the dialog. */\n    Message?: string;\n    /** Array of button options to show in the dialog. */\n    Buttons?: Button[];\n    /** True if the dialog should appear detached from the main window (if applicable). */\n    Detached?: boolean;\n}\n\nexport interface Button {\n    /** Text that appears within the button. */\n    Label?: string;\n    /** True if the button should cancel an operation when clicked. */\n    IsCancel?: boolean;\n    /** True if the button should be the default action when the user presses enter. */\n    IsDefault?: boolean;\n}\n\nexport interface FileFilter {\n    /** Display name for the filter, it could be \"Text Files\", \"Images\" etc. */\n    DisplayName?: string;\n    /** Pattern to match for the filter, e.g. \"*.txt;*.md\" for text markdown files. */\n    Pattern?: string;\n}\n\n/**\n * Presents a dialog of specified type with the given options.\n *\n * @param type - Dialog type.\n * @param options - Options for the dialog.\n * @returns A promise that resolves with result of dialog.\n */\nfunction dialog(type: number, options: MessageDialogOptions | OpenFileDialogOptions | SaveFileDialogOptions = {}): Promise<any> {\n    return call(type, options);\n}\n\n/**\n * Presents an info dialog.\n *\n * @param options - Dialog options\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Info(options: MessageDialogOptions): Promise<string> { return dialog(DialogInfo, options); }\n\n/**\n * Presents a warning dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Warning(options: MessageDialogOptions): Promise<string> { return dialog(DialogWarning, options); }\n\n/**\n * Presents an error dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Error(options: MessageDialogOptions): Promise<string> { return dialog(DialogError, options); }\n\n/**\n * Presents a question dialog.\n *\n * @param options - Dialog options.\n * @returns A promise that resolves with the label of the chosen button.\n */\nexport function Question(options: MessageDialogOptions): Promise<string> { return dialog(DialogQuestion, options); }\n\n/**\n * Presents a file selection dialog to pick one or more files to open.\n *\n * @param options - Dialog options.\n * @returns Selected file or list of files, or a blank string/empty list if no file has been selected.\n */\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection: true }): Promise<string[]>;\nexport function OpenFile(options: OpenFileDialogOptions & { AllowsMultipleSelection?: false | undefined }): Promise<string>;\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]>;\nexport function OpenFile(options: OpenFileDialogOptions): Promise<string | string[]> { return dialog(DialogOpenFile, options) ?? []; }\n\n/**\n * Presents a file selection dialog to pick a file to save.\n *\n * @param options - Dialog options.\n * @returns Selected file, or a blank string if no file has been selected.\n */\nexport function SaveFile(options: SaveFileDialogOptions): Promise<string> { return dialog(DialogSaveFile, options); }\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { eventListeners, Listener, listenerOff } from \"./listener.js\";\nimport { Events as Create } from \"./create.js\";\nimport { Types } from \"./event_types.js\";\n\n// Setup\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    window._wails = window._wails || {};\n    window._wails.dispatchWailsEvent = dispatchWailsEvent;\n}\n\nconst call = newRuntimeCaller(objectNames.Events);\nconst EmitMethod = 0;\n\nexport * from \"./event_types.js\";\n\n/**\n * A table of data types for all known events.\n * Will be monkey-patched by the binding generator.\n */\nexport interface CustomEvents {}\n\n/**\n * Either a known event name or an arbitrary string.\n */\nexport type WailsEventName<E extends keyof CustomEvents = keyof CustomEvents> = E | (string & {});\n\n/**\n * Union of all known system event names.\n */\ntype SystemEventName = {\n    [K in keyof (typeof Types)]: (typeof Types)[K][keyof ((typeof Types)[K])]\n} extends (infer M) ? M[keyof M] : never;\n\n/**\n * The data type associated to a given event.\n */\nexport type WailsEventData<E extends WailsEventName = WailsEventName> =\n    E extends keyof CustomEvents ? CustomEvents[E] : (E extends SystemEventName ? void : any);\n\n/**\n * The type of handlers for a given event.\n */\nexport type WailsEventCallback<E extends WailsEventName = WailsEventName> = (ev: WailsEvent<E>) => void;\n\n/**\n * Represents a system event or a custom event emitted through wails-provided facilities.\n */\nexport class WailsEvent<E extends WailsEventName = WailsEventName> {\n    /**\n     * The name of the event.\n     */\n    name: E;\n\n    /**\n     * Optional data associated with the emitted event.\n     */\n    data: WailsEventData<E>;\n\n    /**\n     * Name of the originating window. Omitted for application events.\n     * Will be overridden if set manually.\n     */\n    sender?: string;\n\n    constructor(name: E, data: WailsEventData<E>);\n    constructor(name: WailsEventData<E> extends null | void ? E : never)\n    constructor(name: E, data?: any) {\n        this.name = name;\n        this.data = data ?? null;\n    }\n}\n\nfunction dispatchWailsEvent(event: any) {\n    let listeners = eventListeners.get(event.name);\n    if (!listeners) {\n        return;\n    }\n\n    let wailsEvent = new WailsEvent(\n        event.name,\n        (event.name in Create) ? Create[event.name](event.data) : event.data\n    );\n    if ('sender' in event) {\n        wailsEvent.sender = event.sender;\n    }\n\n    // Dispatch to a snapshot, then remove all expired listeners in a single\n    // post-dispatch filter of the live map.\n    // - Writing the snapshot back wholesale would undo subscription changes\n    //   made inside a handler (#4393).\n    // - Calling listenerOff() per expired listener inside the loop is O(n\u00B2)\n    //   when many listeners expire on the same event.\n    // Filtering the live array once after dispatch is O(n) and still honours\n    // any listeners added or removed by handlers during dispatch.\n    const expired = new Set<Listener>();\n    for (const listener of listeners.slice()) {\n        if (listener.dispatch(wailsEvent)) {\n            expired.add(listener);\n        }\n    }\n    if (expired.size > 0) {\n        const live = eventListeners.get(event.name);\n        if (live) {\n            const remaining = live.filter(l => !expired.has(l));\n            if (remaining.length === 0) {\n                eventListeners.delete(event.name);\n            } else {\n                eventListeners.set(event.name, remaining);\n            }\n        }\n    }\n}\n\n/**\n * Register a callback function to be called multiple times for a specific event.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @param maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function OnMultiple<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>, maxCallbacks: number) {\n    let listeners = eventListeners.get(eventName) || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    listeners.push(thisListener);\n    eventListeners.set(eventName, listeners);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers a callback function to be executed when the specified event occurs.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function On<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void {\n    return OnMultiple(eventName, callback, -1);\n}\n\n/**\n * Registers a callback function to be executed only once for the specified event.\n *\n * @param eventName - The name of the event to register the callback for.\n * @param callback - The callback function to be called when the event is triggered.\n * @returns A function that, when called, will unregister the callback from the event.\n */\nexport function Once<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void {\n    return OnMultiple(eventName, callback, 1);\n}\n\n/**\n * Removes event listeners for the specified event names.\n *\n * @param eventNames - The name of the events to remove listeners for.\n */\nexport function Off(...eventNames: [WailsEventName, ...WailsEventName[]]): void {\n    eventNames.forEach(eventName => eventListeners.delete(eventName));\n}\n\n/**\n * Removes all event listeners.\n */\nexport function OffAll(): void {\n    eventListeners.clear();\n}\n\n/**\n * Emits an event.\n *\n * @returns A promise that will be fulfilled once the event has been emitted.  Resolves to true if the event was cancelled.\n * @param name - The name of the event to emit\n * @param data - The data that will be sent with the event\n */\nexport function Emit<E extends WailsEventName = WailsEventName>(name: E, data: WailsEventData<E>): Promise<boolean>\nexport function Emit<E extends WailsEventName = WailsEventName>(name: WailsEventData<E> extends null | void ? E : never): Promise<boolean>\nexport function Emit<E extends WailsEventName = WailsEventName>(name: WailsEventData<E>, data?: any): Promise<boolean> {\n    return call(EmitMethod,  new WailsEvent(name, data))\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// The following utilities have been factored out of ./events.ts\n// for testing purposes.\n\nexport const eventListeners = new Map<string, Listener[]>();\n\nexport class Listener {\n    eventName: string;\n    callback: (data: any) => void;\n    maxCallbacks: number;\n\n    constructor(eventName: string, callback: (data: any) => void, maxCallbacks: number) {\n        this.eventName = eventName;\n        this.callback = callback;\n        this.maxCallbacks = maxCallbacks || -1;\n    }\n\n    dispatch(data: any): boolean {\n        try {\n            this.callback(data);\n        } catch (err) {\n            console.error(err);\n        }\n\n        if (this.maxCallbacks === -1) return false;\n        this.maxCallbacks -= 1;\n        return this.maxCallbacks === 0;\n    }\n}\n\nexport function listenerOff(listener: Listener): void {\n    let listeners = eventListeners.get(listener.eventName);\n    if (!listeners) {\n        return;\n    }\n\n    listeners = listeners.filter(l => l !== listener);\n    if (listeners.length === 0) {\n        eventListeners.delete(listener.eventName);\n    } else {\n        eventListeners.set(listener.eventName, listeners);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Any is a dummy creation function for simple or unknown types.\n */\nexport function Any<T = any>(source: any): T {\n    return source;\n}\n\n/**\n * ByteSlice is a creation function that replaces\n * null strings with empty strings.\n */\nexport function ByteSlice(source: any): string {\n    return ((source == null) ? \"\" : source);\n}\n\n/**\n * Array takes a creation function for an arbitrary type\n * and returns an in-place creation function for an array\n * whose elements are of that type.\n */\nexport function Array<T = any>(element: (source: any) => T): (source: any) => T[] {\n    if (element === Any) {\n        return (source) => (source === null ? [] : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return [];\n        }\n        for (let i = 0; i < source.length; i++) {\n            source[i] = element(source[i]);\n        }\n        return source;\n    };\n}\n\n/**\n * Map takes creation functions for two arbitrary types\n * and returns an in-place creation function for an object\n * whose keys and values are of those types.\n */\nexport function Map<K extends PropertyKey = any, V = any>(key: (source: any) => K, value: (source: any) => V): (source: any) => Record<K, V> {\n    if (value === Any) {\n        return (source) => (source === null ? {} : source);\n    }\n\n    return (source) => {\n        if (source === null) {\n            return {};\n        }\n        for (const key in source) {\n            source[key] = value(source[key]);\n        }\n        return source;\n    };\n}\n\n/**\n * Nullable takes a creation function for an arbitrary type\n * and returns a creation function for a nullable value of that type.\n */\nexport function Nullable<T = any>(element: (source: any) => T): (source: any) => (T | null) {\n    if (element === Any) {\n        return Any;\n    }\n\n    return (source) => (source === null ? null : element(source));\n}\n\n/**\n * Struct takes an object mapping field names to creation functions\n * and returns an in-place creation function for a struct.\n */\nexport function Struct(createField: Record<string, (source: any) => any>):\n    <U extends Record<string, any> = any>(source: any) => U\n{\n    let allAny = true;\n    for (const name in createField) {\n        if (createField[name] !== Any) {\n            allAny = false;\n            break;\n        }\n    }\n    if (allAny) {\n        return Any;\n    }\n\n    return (source) => {\n        for (const name in createField) {\n            if (name in source) {\n                source[name] = createField[name](source[name]);\n            }\n        }\n        return source;\n    };\n}\n\n/**\n * DateFromTime is a creation function that converts RFC3339 strings\n * (from Go's time.Time JSON marshaling) to JavaScript Date objects.\n */\nexport function DateFromTime(source: any): Date {\n    return new Date(source);\n}\n\n/**\n * Maps known event names to creation functions for their data types.\n * Will be monkey-patched by the binding generator.\n */\nexport const Events: Record<string, (source: any) => any> = {};\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH \u00C2 MODIWL\n// This file is automatically generated. DO NOT EDIT\n\nexport const Types = Object.freeze({\n\tWindows: Object.freeze({\n\t\tAPMPowerSettingChange: \"windows:APMPowerSettingChange\",\n\t\tAPMPowerStatusChange: \"windows:APMPowerStatusChange\",\n\t\tAPMResumeAutomatic: \"windows:APMResumeAutomatic\",\n\t\tAPMResumeSuspend: \"windows:APMResumeSuspend\",\n\t\tAPMSuspend: \"windows:APMSuspend\",\n\t\tApplicationStarted: \"windows:ApplicationStarted\",\n\t\tSystemThemeChanged: \"windows:SystemThemeChanged\",\n\t\tWebViewNavigationCompleted: \"windows:WebViewNavigationCompleted\",\n\t\tWindowActive: \"windows:WindowActive\",\n\t\tWindowBackgroundErase: \"windows:WindowBackgroundErase\",\n\t\tWindowClickActive: \"windows:WindowClickActive\",\n\t\tWindowClosing: \"windows:WindowClosing\",\n\t\tWindowDidMove: \"windows:WindowDidMove\",\n\t\tWindowDidResize: \"windows:WindowDidResize\",\n\t\tWindowDPIChanged: \"windows:WindowDPIChanged\",\n\t\tWindowDragDrop: \"windows:WindowDragDrop\",\n\t\tWindowDragEnter: \"windows:WindowDragEnter\",\n\t\tWindowDragLeave: \"windows:WindowDragLeave\",\n\t\tWindowDragOver: \"windows:WindowDragOver\",\n\t\tWindowEndMove: \"windows:WindowEndMove\",\n\t\tWindowEndResize: \"windows:WindowEndResize\",\n\t\tWindowFullscreen: \"windows:WindowFullscreen\",\n\t\tWindowHide: \"windows:WindowHide\",\n\t\tWindowInactive: \"windows:WindowInactive\",\n\t\tWindowKeyDown: \"windows:WindowKeyDown\",\n\t\tWindowKeyUp: \"windows:WindowKeyUp\",\n\t\tWindowKillFocus: \"windows:WindowKillFocus\",\n\t\tWindowNonClientHit: \"windows:WindowNonClientHit\",\n\t\tWindowNonClientMouseDown: \"windows:WindowNonClientMouseDown\",\n\t\tWindowNonClientMouseLeave: \"windows:WindowNonClientMouseLeave\",\n\t\tWindowNonClientMouseMove: \"windows:WindowNonClientMouseMove\",\n\t\tWindowNonClientMouseUp: \"windows:WindowNonClientMouseUp\",\n\t\tWindowPaint: \"windows:WindowPaint\",\n\t\tWindowRestore: \"windows:WindowRestore\",\n\t\tWindowSetFocus: \"windows:WindowSetFocus\",\n\t\tWindowShow: \"windows:WindowShow\",\n\t\tWindowStartMove: \"windows:WindowStartMove\",\n\t\tWindowStartResize: \"windows:WindowStartResize\",\n\t\tWindowUnFullscreen: \"windows:WindowUnFullscreen\",\n\t\tWindowZOrderChanged: \"windows:WindowZOrderChanged\",\n\t\tWindowMinimise: \"windows:WindowMinimise\",\n\t\tWindowUnMinimise: \"windows:WindowUnMinimise\",\n\t\tWindowMaximise: \"windows:WindowMaximise\",\n\t\tWindowUnMaximise: \"windows:WindowUnMaximise\",\n\t}),\n\tMac: Object.freeze({\n\t\tApplicationDidBecomeActive: \"mac:ApplicationDidBecomeActive\",\n\t\tApplicationDidChangeBackingProperties: \"mac:ApplicationDidChangeBackingProperties\",\n\t\tApplicationDidChangeEffectiveAppearance: \"mac:ApplicationDidChangeEffectiveAppearance\",\n\t\tApplicationDidChangeIcon: \"mac:ApplicationDidChangeIcon\",\n\t\tApplicationDidChangeOcclusionState: \"mac:ApplicationDidChangeOcclusionState\",\n\t\tApplicationDidChangeScreenParameters: \"mac:ApplicationDidChangeScreenParameters\",\n\t\tApplicationDidChangeStatusBarFrame: \"mac:ApplicationDidChangeStatusBarFrame\",\n\t\tApplicationDidChangeStatusBarOrientation: \"mac:ApplicationDidChangeStatusBarOrientation\",\n\t\tApplicationDidChangeTheme: \"mac:ApplicationDidChangeTheme\",\n\t\tApplicationDidFinishLaunching: \"mac:ApplicationDidFinishLaunching\",\n\t\tApplicationDidHide: \"mac:ApplicationDidHide\",\n\t\tApplicationDidResignActive: \"mac:ApplicationDidResignActive\",\n\t\tApplicationDidUnhide: \"mac:ApplicationDidUnhide\",\n\t\tApplicationDidUpdate: \"mac:ApplicationDidUpdate\",\n\t\tApplicationDidWake: \"mac:ApplicationDidWake\",\n\t\tApplicationScreensDidSleep: \"mac:ApplicationScreensDidSleep\",\n\t\tApplicationScreensDidWake: \"mac:ApplicationScreensDidWake\",\n\t\tApplicationShouldHandleReopen: \"mac:ApplicationShouldHandleReopen\",\n\t\tApplicationWillBecomeActive: \"mac:ApplicationWillBecomeActive\",\n\t\tApplicationWillFinishLaunching: \"mac:ApplicationWillFinishLaunching\",\n\t\tApplicationWillHide: \"mac:ApplicationWillHide\",\n\t\tApplicationWillResignActive: \"mac:ApplicationWillResignActive\",\n\t\tApplicationWillSleep: \"mac:ApplicationWillSleep\",\n\t\tApplicationWillTerminate: \"mac:ApplicationWillTerminate\",\n\t\tApplicationWillUnhide: \"mac:ApplicationWillUnhide\",\n\t\tApplicationWillUpdate: \"mac:ApplicationWillUpdate\",\n\t\tMenuDidAddItem: \"mac:MenuDidAddItem\",\n\t\tMenuDidBeginTracking: \"mac:MenuDidBeginTracking\",\n\t\tMenuDidClose: \"mac:MenuDidClose\",\n\t\tMenuDidDisplayItem: \"mac:MenuDidDisplayItem\",\n\t\tMenuDidEndTracking: \"mac:MenuDidEndTracking\",\n\t\tMenuDidHighlightItem: \"mac:MenuDidHighlightItem\",\n\t\tMenuDidOpen: \"mac:MenuDidOpen\",\n\t\tMenuDidPopUp: \"mac:MenuDidPopUp\",\n\t\tMenuDidRemoveItem: \"mac:MenuDidRemoveItem\",\n\t\tMenuDidSendAction: \"mac:MenuDidSendAction\",\n\t\tMenuDidSendActionToItem: \"mac:MenuDidSendActionToItem\",\n\t\tMenuDidUpdate: \"mac:MenuDidUpdate\",\n\t\tMenuWillAddItem: \"mac:MenuWillAddItem\",\n\t\tMenuWillBeginTracking: \"mac:MenuWillBeginTracking\",\n\t\tMenuWillDisplayItem: \"mac:MenuWillDisplayItem\",\n\t\tMenuWillEndTracking: \"mac:MenuWillEndTracking\",\n\t\tMenuWillHighlightItem: \"mac:MenuWillHighlightItem\",\n\t\tMenuWillOpen: \"mac:MenuWillOpen\",\n\t\tMenuWillPopUp: \"mac:MenuWillPopUp\",\n\t\tMenuWillRemoveItem: \"mac:MenuWillRemoveItem\",\n\t\tMenuWillSendAction: \"mac:MenuWillSendAction\",\n\t\tMenuWillSendActionToItem: \"mac:MenuWillSendActionToItem\",\n\t\tMenuWillUpdate: \"mac:MenuWillUpdate\",\n\t\tWebViewDidCommitNavigation: \"mac:WebViewDidCommitNavigation\",\n\t\tWebViewDidFinishNavigation: \"mac:WebViewDidFinishNavigation\",\n\t\tWebViewDidReceiveServerRedirectForProvisionalNavigation: \"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation\",\n\t\tWebViewDidStartProvisionalNavigation: \"mac:WebViewDidStartProvisionalNavigation\",\n\t\tWindowDidBecomeKey: \"mac:WindowDidBecomeKey\",\n\t\tWindowDidBecomeMain: \"mac:WindowDidBecomeMain\",\n\t\tWindowDidBeginSheet: \"mac:WindowDidBeginSheet\",\n\t\tWindowDidChangeAlpha: \"mac:WindowDidChangeAlpha\",\n\t\tWindowDidChangeBackingLocation: \"mac:WindowDidChangeBackingLocation\",\n\t\tWindowDidChangeBackingProperties: \"mac:WindowDidChangeBackingProperties\",\n\t\tWindowDidChangeCollectionBehavior: \"mac:WindowDidChangeCollectionBehavior\",\n\t\tWindowDidChangeEffectiveAppearance: \"mac:WindowDidChangeEffectiveAppearance\",\n\t\tWindowDidChangeOcclusionState: \"mac:WindowDidChangeOcclusionState\",\n\t\tWindowDidChangeOrderingMode: \"mac:WindowDidChangeOrderingMode\",\n\t\tWindowDidChangeScreen: \"mac:WindowDidChangeScreen\",\n\t\tWindowDidChangeScreenParameters: \"mac:WindowDidChangeScreenParameters\",\n\t\tWindowDidChangeScreenProfile: \"mac:WindowDidChangeScreenProfile\",\n\t\tWindowDidChangeScreenSpace: \"mac:WindowDidChangeScreenSpace\",\n\t\tWindowDidChangeScreenSpaceProperties: \"mac:WindowDidChangeScreenSpaceProperties\",\n\t\tWindowDidChangeSharingType: \"mac:WindowDidChangeSharingType\",\n\t\tWindowDidChangeSpace: \"mac:WindowDidChangeSpace\",\n\t\tWindowDidChangeSpaceOrderingMode: \"mac:WindowDidChangeSpaceOrderingMode\",\n\t\tWindowDidChangeTitle: \"mac:WindowDidChangeTitle\",\n\t\tWindowDidChangeToolbar: \"mac:WindowDidChangeToolbar\",\n\t\tWindowDidDeminiaturize: \"mac:WindowDidDeminiaturize\",\n\t\tWindowDidEndSheet: \"mac:WindowDidEndSheet\",\n\t\tWindowDidEnterFullScreen: \"mac:WindowDidEnterFullScreen\",\n\t\tWindowDidEnterVersionBrowser: \"mac:WindowDidEnterVersionBrowser\",\n\t\tWindowDidExitFullScreen: \"mac:WindowDidExitFullScreen\",\n\t\tWindowDidExitVersionBrowser: \"mac:WindowDidExitVersionBrowser\",\n\t\tWindowDidExpose: \"mac:WindowDidExpose\",\n\t\tWindowDidFocus: \"mac:WindowDidFocus\",\n\t\tWindowDidMiniaturize: \"mac:WindowDidMiniaturize\",\n\t\tWindowDidMove: \"mac:WindowDidMove\",\n\t\tWindowDidOrderOffScreen: \"mac:WindowDidOrderOffScreen\",\n\t\tWindowDidOrderOnScreen: \"mac:WindowDidOrderOnScreen\",\n\t\tWindowDidResignKey: \"mac:WindowDidResignKey\",\n\t\tWindowDidResignMain: \"mac:WindowDidResignMain\",\n\t\tWindowDidResize: \"mac:WindowDidResize\",\n\t\tWindowDidUpdate: \"mac:WindowDidUpdate\",\n\t\tWindowDidUpdateAlpha: \"mac:WindowDidUpdateAlpha\",\n\t\tWindowDidUpdateCollectionBehavior: \"mac:WindowDidUpdateCollectionBehavior\",\n\t\tWindowDidUpdateCollectionProperties: \"mac:WindowDidUpdateCollectionProperties\",\n\t\tWindowDidUpdateShadow: \"mac:WindowDidUpdateShadow\",\n\t\tWindowDidUpdateTitle: \"mac:WindowDidUpdateTitle\",\n\t\tWindowDidUpdateToolbar: \"mac:WindowDidUpdateToolbar\",\n\t\tWindowDidZoom: \"mac:WindowDidZoom\",\n\t\tWindowFileDraggingEntered: \"mac:WindowFileDraggingEntered\",\n\t\tWindowFileDraggingExited: \"mac:WindowFileDraggingExited\",\n\t\tWindowFileDraggingPerformed: \"mac:WindowFileDraggingPerformed\",\n\t\tWindowHide: \"mac:WindowHide\",\n\t\tWindowMaximise: \"mac:WindowMaximise\",\n\t\tWindowUnMaximise: \"mac:WindowUnMaximise\",\n\t\tWindowMinimise: \"mac:WindowMinimise\",\n\t\tWindowUnMinimise: \"mac:WindowUnMinimise\",\n\t\tWindowShouldClose: \"mac:WindowShouldClose\",\n\t\tWindowShow: \"mac:WindowShow\",\n\t\tWindowWillBecomeKey: \"mac:WindowWillBecomeKey\",\n\t\tWindowWillBecomeMain: \"mac:WindowWillBecomeMain\",\n\t\tWindowWillBeginSheet: \"mac:WindowWillBeginSheet\",\n\t\tWindowWillChangeOrderingMode: \"mac:WindowWillChangeOrderingMode\",\n\t\tWindowWillClose: \"mac:WindowWillClose\",\n\t\tWindowWillDeminiaturize: \"mac:WindowWillDeminiaturize\",\n\t\tWindowWillEnterFullScreen: \"mac:WindowWillEnterFullScreen\",\n\t\tWindowWillEnterVersionBrowser: \"mac:WindowWillEnterVersionBrowser\",\n\t\tWindowWillExitFullScreen: \"mac:WindowWillExitFullScreen\",\n\t\tWindowWillExitVersionBrowser: \"mac:WindowWillExitVersionBrowser\",\n\t\tWindowWillFocus: \"mac:WindowWillFocus\",\n\t\tWindowWillMiniaturize: \"mac:WindowWillMiniaturize\",\n\t\tWindowWillMove: \"mac:WindowWillMove\",\n\t\tWindowWillOrderOffScreen: \"mac:WindowWillOrderOffScreen\",\n\t\tWindowWillOrderOnScreen: \"mac:WindowWillOrderOnScreen\",\n\t\tWindowWillResignMain: \"mac:WindowWillResignMain\",\n\t\tWindowWillResize: \"mac:WindowWillResize\",\n\t\tWindowWillUnfocus: \"mac:WindowWillUnfocus\",\n\t\tWindowWillUpdate: \"mac:WindowWillUpdate\",\n\t\tWindowWillUpdateAlpha: \"mac:WindowWillUpdateAlpha\",\n\t\tWindowWillUpdateCollectionBehavior: \"mac:WindowWillUpdateCollectionBehavior\",\n\t\tWindowWillUpdateCollectionProperties: \"mac:WindowWillUpdateCollectionProperties\",\n\t\tWindowWillUpdateShadow: \"mac:WindowWillUpdateShadow\",\n\t\tWindowWillUpdateTitle: \"mac:WindowWillUpdateTitle\",\n\t\tWindowWillUpdateToolbar: \"mac:WindowWillUpdateToolbar\",\n\t\tWindowWillUpdateVisibility: \"mac:WindowWillUpdateVisibility\",\n\t\tWindowWillUseStandardFrame: \"mac:WindowWillUseStandardFrame\",\n\t\tWindowZoomIn: \"mac:WindowZoomIn\",\n\t\tWindowZoomOut: \"mac:WindowZoomOut\",\n\t\tWindowZoomReset: \"mac:WindowZoomReset\",\n\t\tWebViewWebContentProcessDidTerminate: \"mac:WebViewWebContentProcessDidTerminate\",\n\t}),\n\tLinux: Object.freeze({\n\t\tApplicationStartup: \"linux:ApplicationStartup\",\n\t\tSystemDidWake: \"linux:SystemDidWake\",\n\t\tSystemThemeChanged: \"linux:SystemThemeChanged\",\n\t\tSystemWillSleep: \"linux:SystemWillSleep\",\n\t\tWindowDeleteEvent: \"linux:WindowDeleteEvent\",\n\t\tWindowDidMove: \"linux:WindowDidMove\",\n\t\tWindowDidResize: \"linux:WindowDidResize\",\n\t\tWindowFocusIn: \"linux:WindowFocusIn\",\n\t\tWindowFocusOut: \"linux:WindowFocusOut\",\n\t\tWindowLoadStarted: \"linux:WindowLoadStarted\",\n\t\tWindowLoadRedirected: \"linux:WindowLoadRedirected\",\n\t\tWindowLoadCommitted: \"linux:WindowLoadCommitted\",\n\t\tWindowLoadFinished: \"linux:WindowLoadFinished\",\n\t}),\n\tiOS: Object.freeze({\n\t\tApplicationDidBecomeActive: \"ios:ApplicationDidBecomeActive\",\n\t\tApplicationDidEnterBackground: \"ios:ApplicationDidEnterBackground\",\n\t\tApplicationDidFinishLaunching: \"ios:ApplicationDidFinishLaunching\",\n\t\tApplicationDidReceiveMemoryWarning: \"ios:ApplicationDidReceiveMemoryWarning\",\n\t\tApplicationWillEnterForeground: \"ios:ApplicationWillEnterForeground\",\n\t\tApplicationWillResignActive: \"ios:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"ios:ApplicationWillTerminate\",\n\t\tWindowDidLoad: \"ios:WindowDidLoad\",\n\t\tWindowWillAppear: \"ios:WindowWillAppear\",\n\t\tWindowDidAppear: \"ios:WindowDidAppear\",\n\t\tWindowWillDisappear: \"ios:WindowWillDisappear\",\n\t\tWindowDidDisappear: \"ios:WindowDidDisappear\",\n\t\tWindowSafeAreaInsetsChanged: \"ios:WindowSafeAreaInsetsChanged\",\n\t\tWindowOrientationChanged: \"ios:WindowOrientationChanged\",\n\t\tWindowTouchBegan: \"ios:WindowTouchBegan\",\n\t\tWindowTouchMoved: \"ios:WindowTouchMoved\",\n\t\tWindowTouchEnded: \"ios:WindowTouchEnded\",\n\t\tWindowTouchCancelled: \"ios:WindowTouchCancelled\",\n\t\tWebViewDidStartNavigation: \"ios:WebViewDidStartNavigation\",\n\t\tWebViewDidFinishNavigation: \"ios:WebViewDidFinishNavigation\",\n\t\tWebViewDidFailNavigation: \"ios:WebViewDidFailNavigation\",\n\t\tWebViewDecidePolicyForNavigationAction: \"ios:WebViewDecidePolicyForNavigationAction\",\n\t\tBatteryChanged: \"ios:BatteryChanged\",\n\t\tNetworkChanged: \"ios:NetworkChanged\",\n\t\tThemeChanged: \"ios:ThemeChanged\",\n\t\tScreenLocked: \"ios:ScreenLocked\",\n\t\tScreenUnlocked: \"ios:ScreenUnlocked\",\n\t}),\n\tAndroid: Object.freeze({\n\t\tActivityCreated: \"android:ActivityCreated\",\n\t\tActivityStarted: \"android:ActivityStarted\",\n\t\tActivityResumed: \"android:ActivityResumed\",\n\t\tActivityPaused: \"android:ActivityPaused\",\n\t\tActivityStopped: \"android:ActivityStopped\",\n\t\tActivityDestroyed: \"android:ActivityDestroyed\",\n\t\tApplicationLowMemory: \"android:ApplicationLowMemory\",\n\t\tWebViewPageStarted: \"android:WebViewPageStarted\",\n\t\tWebViewPageFinished: \"android:WebViewPageFinished\",\n\t\tBatteryChanged: \"android:BatteryChanged\",\n\t\tNetworkChanged: \"android:NetworkChanged\",\n\t\tThemeChanged: \"android:ThemeChanged\",\n\t\tScreenLocked: \"android:ScreenLocked\",\n\t\tScreenUnlocked: \"android:ScreenUnlocked\",\n\t}),\n\tCommon: Object.freeze({\n\t\tApplicationOpenedWithFile: \"common:ApplicationOpenedWithFile\",\n\t\tApplicationStarted: \"common:ApplicationStarted\",\n\t\tApplicationLaunchedWithUrl: \"common:ApplicationLaunchedWithUrl\",\n\t\tThemeChanged: \"common:ThemeChanged\",\n\t\tSystemDidWake: \"common:SystemDidWake\",\n\t\tSystemWillSleep: \"common:SystemWillSleep\",\n\t\tWindowClosing: \"common:WindowClosing\",\n\t\tWindowDidMove: \"common:WindowDidMove\",\n\t\tWindowDidResize: \"common:WindowDidResize\",\n\t\tWindowDPIChanged: \"common:WindowDPIChanged\",\n\t\tWindowFilesDropped: \"common:WindowFilesDropped\",\n\t\tWindowFocus: \"common:WindowFocus\",\n\t\tWindowFullscreen: \"common:WindowFullscreen\",\n\t\tWindowHide: \"common:WindowHide\",\n\t\tWindowLostFocus: \"common:WindowLostFocus\",\n\t\tWindowMaximise: \"common:WindowMaximise\",\n\t\tWindowMinimise: \"common:WindowMinimise\",\n\t\tWindowToggleFrameless: \"common:WindowToggleFrameless\",\n\t\tWindowRestore: \"common:WindowRestore\",\n\t\tWindowRuntimeReady: \"common:WindowRuntimeReady\",\n\t\tWindowShow: \"common:WindowShow\",\n\t\tWindowUnFullscreen: \"common:WindowUnFullscreen\",\n\t\tWindowUnMaximise: \"common:WindowUnMaximise\",\n\t\tWindowUnMinimise: \"common:WindowUnMinimise\",\n\t\tWindowZoom: \"common:WindowZoom\",\n\t\tWindowZoomIn: \"common:WindowZoomIn\",\n\t\tWindowZoomOut: \"common:WindowZoomOut\",\n\t\tWindowZoomReset: \"common:WindowZoomReset\",\n\t\tBatteryChanged: \"common:BatteryChanged\",\n\t\tNetworkChanged: \"common:NetworkChanged\",\n\t\tScreenLocked: \"common:ScreenLocked\",\n\t\tScreenUnlocked: \"common:ScreenUnlocked\",\n\t\tLowMemory: \"common:LowMemory\",\n\t}),\n});\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Logs a message to the console with custom formatting.\n *\n * @param message - The message to be logged.\n */\nexport function debugLog(message: any) {\n    // eslint-disable-next-line\n    console.log(\n        '%c wails3 %c ' + message + ' ',\n        'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',\n        'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'\n    );\n}\n\n/**\n * Checks whether the webview supports the {@link MouseEvent#buttons} property.\n * Looking at you macOS High Sierra!\n */\nexport function canTrackButtons(): boolean {\n    return (new MouseEvent('mousedown')).buttons === 0;\n}\n\n/**\n * Checks whether the browser supports removing listeners by triggering an AbortSignal\n * (see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#signal).\n */\nexport function canAbortListeners() {\n    if (!EventTarget || !AbortSignal || !AbortController)\n        return false;\n\n    let result = true;\n\n    const target = new EventTarget();\n    const controller = new AbortController();\n    target.addEventListener('test', () => { result = false; }, { signal: controller.signal });\n    controller.abort();\n    target.dispatchEvent(new CustomEvent('test'));\n\n    return result;\n}\n\n/**\n * Resolves the closest HTMLElement ancestor of an event's target.\n */\nexport function eventTarget(event: Event): HTMLElement {\n    if (event.target instanceof HTMLElement) {\n        return event.target;\n    } else if (!(event.target instanceof HTMLElement) && event.target instanceof Node) {\n        return event.target.parentElement ?? document.body;\n    } else {\n        return document.body;\n    }\n}\n\n/***\n This technique for proper load detection is taken from HTMX:\n\n BSD 2-Clause License\n\n Copyright (c) 2020, Big Sky Software\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n 1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n ***/\n\nlet isReady = false;\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    document.addEventListener('DOMContentLoaded', () => { isReady = true });\n}\n\nexport function whenReady(callback: () => void) {\n    if (isReady || document.readyState === 'complete') {\n        callback();\n    } else {\n        document.addEventListener('DOMContentLoaded', callback);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\nimport type { Screen } from \"./screens.js\";\n\n// Drop target constants\nconst DROP_TARGET_ATTRIBUTE = 'data-file-drop-target';\nconst DROP_TARGET_ACTIVE_CLASS = 'file-drop-target-active';\nlet currentDropTarget: Element | null = null;\n\nconst PositionMethod                    = 0;\nconst CenterMethod                      = 1;\nconst CloseMethod                       = 2;\nconst DisableSizeConstraintsMethod      = 3;\nconst EnableSizeConstraintsMethod       = 4;\nconst FocusMethod                       = 5;\nconst ForceReloadMethod                 = 6;\nconst FullscreenMethod                  = 7;\nconst GetScreenMethod                   = 8;\nconst GetZoomMethod                     = 9;\nconst HeightMethod                      = 10;\nconst HideMethod                        = 11;\nconst IsFocusedMethod                   = 12;\nconst IsFullscreenMethod                = 13;\nconst IsMaximisedMethod                 = 14;\nconst IsMinimisedMethod                 = 15;\nconst MaximiseMethod                    = 16;\nconst MinimiseMethod                    = 17;\nconst NameMethod                        = 18;\nconst OpenDevToolsMethod                = 19;\nconst RelativePositionMethod            = 20;\nconst ReloadMethod                      = 21;\nconst ResizableMethod                   = 22;\nconst RestoreMethod                     = 23;\nconst SetPositionMethod                 = 24;\nconst SetAlwaysOnTopMethod              = 25;\nconst SetBackgroundColourMethod         = 26;\nconst SetFramelessMethod                = 27;\nconst SetFullscreenButtonEnabledMethod  = 28;\nconst SetMaxSizeMethod                  = 29;\nconst SetMinSizeMethod                  = 30;\nconst SetRelativePositionMethod         = 31;\nconst SetResizableMethod                = 32;\nconst SetSizeMethod                     = 33;\nconst SetTitleMethod                    = 34;\nconst SetZoomMethod                     = 35;\nconst ShowMethod                        = 36;\nconst SizeMethod                        = 37;\nconst ToggleFullscreenMethod            = 38;\nconst ToggleMaximiseMethod              = 39;\nconst ToggleFramelessMethod             = 40; \nconst UnFullscreenMethod                = 41;\nconst UnMaximiseMethod                  = 42;\nconst UnMinimiseMethod                  = 43;\nconst WidthMethod                       = 44;\nconst ZoomMethod                        = 45;\nconst ZoomInMethod                      = 46;\nconst ZoomOutMethod                     = 47;\nconst ZoomResetMethod                   = 48;\nconst SnapAssistMethod                  = 49;\nconst FilesDropped                      = 50;\nconst PrintMethod                       = 51;\nconst SetScreenMethod                   = 52;\n\n/**\n * Finds the nearest drop target element by walking up the DOM tree.\n */\nfunction getDropTargetElement(element: Element | null): Element | null {\n    if (!element) {\n        return null;\n    }\n    return element.closest(`[${DROP_TARGET_ATTRIBUTE}]`);\n}\n\n/**\n * Check if we can use WebView2's postMessageWithAdditionalObjects (Windows)\n * Also checks that EnableFileDrop is true for this window.\n */\nfunction canResolveFilePaths(): boolean {\n    // Must have WebView2's postMessageWithAdditionalObjects API (Windows only)\n    if ((window as any).chrome?.webview?.postMessageWithAdditionalObjects == null) {\n        return false;\n    }\n    // Must have EnableFileDrop set to true for this window\n    // This flag is set by the Go backend during runtime initialization\n    return (window as any)._wails?.flags?.enableFileDrop === true;\n}\n\n/**\n * Send file drop to backend via WebView2 (Windows only)\n */\nfunction resolveFilePaths(x: number, y: number, files: File[]): void {\n    if ((window as any).chrome?.webview?.postMessageWithAdditionalObjects) {\n        (window as any).chrome.webview.postMessageWithAdditionalObjects(`file:drop:${x}:${y}`, files);\n    }\n}\n\n// Native drag state (Linux/macOS intercept DOM drag events)\nlet nativeDragActive = false;\n\n/**\n * Cleans up native drag state and hover effects.\n * Called on drop or when drag leaves the window.\n */\nfunction cleanupNativeDrag(): void {\n    nativeDragActive = false;\n    if (currentDropTarget) {\n        currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n        currentDropTarget = null;\n    }\n}\n\n/**\n * Called from Go when a file drag enters the window on Linux/macOS.\n */\nfunction handleDragEnter(): void {\n    // Check if file drops are enabled for this window\n    if ((window as any)._wails?.flags?.enableFileDrop === false) {\n        return; // File drops disabled, don't activate drag state\n    }\n    nativeDragActive = true;\n}\n\n/**\n * Called from Go when a file drag leaves the window on Linux/macOS.\n */\nfunction handleDragLeave(): void {\n    cleanupNativeDrag();\n}\n\n/**\n * Called from Go during file drag to update hover state on Linux/macOS.\n * @param x - X coordinate in CSS pixels\n * @param y - Y coordinate in CSS pixels\n */\nfunction handleDragOver(x: number, y: number): void {\n    if (!nativeDragActive) return;\n    \n    // Check if file drops are enabled for this window\n    if ((window as any)._wails?.flags?.enableFileDrop === false) {\n        return; // File drops disabled, don't show hover effects\n    }\n    \n    const targetElement = document.elementFromPoint(x, y);\n    const dropTarget = getDropTargetElement(targetElement);\n    \n    if (currentDropTarget && currentDropTarget !== dropTarget) {\n        currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n    }\n    \n    if (dropTarget) {\n        dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);\n        currentDropTarget = dropTarget;\n    } else {\n        currentDropTarget = null;\n    }\n}\n\n\n\n// Export the handlers for use by Go via index.ts\nexport { handleDragEnter, handleDragLeave, handleDragOver };\n\n/**\n * A record describing the position of a window.\n */\ninterface Position {\n    /** The horizontal position of the window. */\n    x: number;\n    /** The vertical position of the window. */\n    y: number;\n}\n\n/**\n * A record describing the size of a window.\n */\ninterface Size {\n    /** The width of the window. */\n    width: number;\n    /** The height of the window. */\n    height: number;\n}\n\n// Private field names.\nconst callerSym = Symbol(\"caller\");\n\nclass Window {\n    // Private fields.\n    private [callerSym]: (message: number, args?: any) => Promise<any>;\n\n    /**\n     * Initialises a window object with the specified name.\n     *\n     * @private\n     * @param name - The name of the target window.\n     */\n    constructor(name: string = '') {\n        this[callerSym] = newRuntimeCaller(objectNames.Window, name)\n\n        // bind instance method to make them easily usable in event handlers\n        for (const method of Object.getOwnPropertyNames(Window.prototype)) {\n            if (\n                method !== \"constructor\"\n                && typeof (this as any)[method] === \"function\"\n            ) {\n                (this as any)[method] = (this as any)[method].bind(this);\n            }\n        }\n    }\n\n    /**\n     * Gets the specified window.\n     *\n     * @param name - The name of the window to get.\n     * @returns The corresponding window object.\n     */\n    Get(name: string): Window {\n        return new Window(name);\n    }\n\n    /**\n     * Returns the absolute position of the window.\n     *\n     * @returns The current absolute position of the window.\n     */\n    Position(): Promise<Position> {\n        return this[callerSym](PositionMethod);\n    }\n\n    /**\n     * Centers the window on the screen.\n     */\n    Center(): Promise<void> {\n        return this[callerSym](CenterMethod);\n    }\n\n    /**\n     * Closes the window.\n     */\n    Close(): Promise<void> {\n        return this[callerSym](CloseMethod);\n    }\n\n    /**\n     * Disables min/max size constraints.\n     */\n    DisableSizeConstraints(): Promise<void> {\n        return this[callerSym](DisableSizeConstraintsMethod);\n    }\n\n    /**\n     * Enables min/max size constraints.\n     */\n    EnableSizeConstraints(): Promise<void> {\n        return this[callerSym](EnableSizeConstraintsMethod);\n    }\n\n    /**\n     * Focuses the window.\n     */\n    Focus(): Promise<void> {\n        return this[callerSym](FocusMethod);\n    }\n\n    /**\n     * Forces the window to reload the page assets.\n     */\n    ForceReload(): Promise<void> {\n        return this[callerSym](ForceReloadMethod);\n    }\n\n    /**\n     * Switches the window to fullscreen mode.\n     */\n    Fullscreen(): Promise<void> {\n        return this[callerSym](FullscreenMethod);\n    }\n\n    /**\n     * Returns the screen that the window is on.\n     *\n     * @returns The screen the window is currently on.\n     */\n    GetScreen(): Promise<Screen> {\n        return this[callerSym](GetScreenMethod);\n    }\n\n    /**\n     * Returns the current zoom level of the window.\n     *\n     * @returns The current zoom level.\n     */\n    GetZoom(): Promise<number> {\n        return this[callerSym](GetZoomMethod);\n    }\n\n    /**\n     * Returns the height of the window.\n     *\n     * @returns The current height of the window.\n     */\n    Height(): Promise<number> {\n        return this[callerSym](HeightMethod);\n    }\n\n    /**\n     * Hides the window.\n     */\n    Hide(): Promise<void> {\n        return this[callerSym](HideMethod);\n    }\n\n    /**\n     * Returns true if the window is focused.\n     *\n     * @returns Whether the window is currently focused.\n     */\n    IsFocused(): Promise<boolean> {\n        return this[callerSym](IsFocusedMethod);\n    }\n\n    /**\n     * Returns true if the window is fullscreen.\n     *\n     * @returns Whether the window is currently fullscreen.\n     */\n    IsFullscreen(): Promise<boolean> {\n        return this[callerSym](IsFullscreenMethod);\n    }\n\n    /**\n     * Returns true if the window is maximised.\n     *\n     * @returns Whether the window is currently maximised.\n     */\n    IsMaximised(): Promise<boolean> {\n        return this[callerSym](IsMaximisedMethod);\n    }\n\n    /**\n     * Returns true if the window is minimised.\n     *\n     * @returns Whether the window is currently minimised.\n     */\n    IsMinimised(): Promise<boolean> {\n        return this[callerSym](IsMinimisedMethod);\n    }\n\n    /**\n     * Maximises the window.\n     */\n    Maximise(): Promise<void> {\n        return this[callerSym](MaximiseMethod);\n    }\n\n    /**\n     * Minimises the window.\n     */\n    Minimise(): Promise<void> {\n        return this[callerSym](MinimiseMethod);\n    }\n\n    /**\n     * Returns the name of the window.\n     *\n     * @returns The name of the window.\n     */\n    Name(): Promise<string> {\n        return this[callerSym](NameMethod);\n    }\n\n    /**\n     * Opens the development tools pane.\n     */\n    OpenDevTools(): Promise<void> {\n        return this[callerSym](OpenDevToolsMethod);\n    }\n\n    /**\n     * Returns the relative position of the window to the screen.\n     *\n     * @returns The current relative position of the window.\n     */\n    RelativePosition(): Promise<Position> {\n        return this[callerSym](RelativePositionMethod);\n    }\n\n    /**\n     * Reloads the page assets.\n     */\n    Reload(): Promise<void> {\n        return this[callerSym](ReloadMethod);\n    }\n\n    /**\n     * Returns true if the window is resizable.\n     *\n     * @returns Whether the window is currently resizable.\n     */\n    Resizable(): Promise<boolean> {\n        return this[callerSym](ResizableMethod);\n    }\n\n    /**\n     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.\n     */\n    Restore(): Promise<void> {\n        return this[callerSym](RestoreMethod);\n    }\n\n    /**\n     * Sets the absolute position of the window.\n     *\n     * @param x - The desired horizontal absolute position of the window.\n     * @param y - The desired vertical absolute position of the window.\n     */\n    SetPosition(x: number, y: number): Promise<void> {\n        return this[callerSym](SetPositionMethod, { x, y });\n    }\n\n    /**\n     * Sets the window to be always on top.\n     *\n     * @param alwaysOnTop - Whether the window should stay on top.\n     */\n    SetAlwaysOnTop(alwaysOnTop: boolean): Promise<void> {\n        return this[callerSym](SetAlwaysOnTopMethod, { alwaysOnTop });\n    }\n\n    /**\n     * Sets the background colour of the window.\n     *\n     * @param r - The desired red component of the window background.\n     * @param g - The desired green component of the window background.\n     * @param b - The desired blue component of the window background.\n     * @param a - The desired alpha component of the window background.\n     */\n    SetBackgroundColour(r: number, g: number, b: number, a: number): Promise<void> {\n        return this[callerSym](SetBackgroundColourMethod, { r, g, b, a });\n    }\n\n    /**\n     * Removes the window frame and title bar.\n     *\n     * @param frameless - Whether the window should be frameless.\n     */\n    SetFrameless(frameless: boolean): Promise<void> {\n        return this[callerSym](SetFramelessMethod, { frameless });\n    }\n\n    /**\n     * Disables the system fullscreen button.\n     *\n     * @param enabled - Whether the fullscreen button should be enabled.\n     */\n    SetFullscreenButtonEnabled(enabled: boolean): Promise<void> {\n        return this[callerSym](SetFullscreenButtonEnabledMethod, { enabled });\n    }\n\n    /**\n     * Sets the maximum size of the window.\n     *\n     * @param width - The desired maximum width of the window.\n     * @param height - The desired maximum height of the window.\n     */\n    SetMaxSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetMaxSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the minimum size of the window.\n     *\n     * @param width - The desired minimum width of the window.\n     * @param height - The desired minimum height of the window.\n     */\n    SetMinSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetMinSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the relative position of the window to the screen.\n     *\n     * @param x - The desired horizontal relative position of the window.\n     * @param y - The desired vertical relative position of the window.\n     */\n    SetRelativePosition(x: number, y: number): Promise<void> {\n        return this[callerSym](SetRelativePositionMethod, { x, y });\n    }\n\n    /**\n     * Sets whether the window is resizable.\n     *\n     * @param resizable - Whether the window should be resizable.\n     */\n    SetResizable(resizable: boolean): Promise<void> {\n        return this[callerSym](SetResizableMethod, { resizable });\n    }\n\n    /**\n     * Sets the size of the window.\n     *\n     * @param width - The desired width of the window.\n     * @param height - The desired height of the window.\n     */\n    SetSize(width: number, height: number): Promise<void> {\n        return this[callerSym](SetSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the title of the window.\n     *\n     * @param title - The desired title of the window.\n     */\n    SetTitle(title: string): Promise<void> {\n        return this[callerSym](SetTitleMethod, { title });\n    }\n\n    /**\n     * Sets the zoom level of the window.\n     *\n     * @param zoom - The desired zoom level.\n     */\n    SetZoom(zoom: number): Promise<void> {\n        return this[callerSym](SetZoomMethod, { zoom });\n    }\n\n    /**\n     * Shows the window.\n     */\n    Show(): Promise<void> {\n        return this[callerSym](ShowMethod);\n    }\n\n    /**\n     * Returns the size of the window.\n     *\n     * @returns The current size of the window.\n     */\n    Size(): Promise<Size> {\n        return this[callerSym](SizeMethod);\n    }\n\n    /**\n     * Toggles the window between fullscreen and normal.\n     */\n    ToggleFullscreen(): Promise<void> {\n        return this[callerSym](ToggleFullscreenMethod);\n    }\n\n    /**\n     * Toggles the window between maximised and normal.\n     */\n    ToggleMaximise(): Promise<void> {\n        return this[callerSym](ToggleMaximiseMethod);\n    }\n\n    /**\n     * Toggles the window between frameless and normal.\n     */\n    ToggleFrameless(): Promise<void> {\n        return this[callerSym](ToggleFramelessMethod);\n    }\n\n    /**\n     * Un-fullscreens the window.\n     */\n    UnFullscreen(): Promise<void> {\n        return this[callerSym](UnFullscreenMethod);\n    }\n\n    /**\n     * Un-maximises the window.\n     */\n    UnMaximise(): Promise<void> {\n        return this[callerSym](UnMaximiseMethod);\n    }\n\n    /**\n     * Un-minimises the window.\n     */\n    UnMinimise(): Promise<void> {\n        return this[callerSym](UnMinimiseMethod);\n    }\n\n    /**\n     * Returns the width of the window.\n     *\n     * @returns The current width of the window.\n     */\n    Width(): Promise<number> {\n        return this[callerSym](WidthMethod);\n    }\n\n    /**\n     * Zooms the window.\n     */\n    Zoom(): Promise<void> {\n        return this[callerSym](ZoomMethod);\n    }\n\n    /**\n     * Increases the zoom level of the webview content.\n     */\n    ZoomIn(): Promise<void> {\n        return this[callerSym](ZoomInMethod);\n    }\n\n    /**\n     * Decreases the zoom level of the webview content.\n     */\n    ZoomOut(): Promise<void> {\n        return this[callerSym](ZoomOutMethod);\n    }\n\n    /**\n     * Resets the zoom level of the webview content.\n     */\n    ZoomReset(): Promise<void> {\n        return this[callerSym](ZoomResetMethod);\n    }\n\n    /**\n     * Handles file drops originating from platform-specific code (e.g., macOS/Linux native drag-and-drop).\n     * Gathers information about the drop target element and sends it back to the Go backend.\n     *\n     * @param filenames - An array of file paths (strings) that were dropped.\n     * @param x - The x-coordinate of the drop event, in logical (CSS) pixels relative to the webview.\n     * @param y - The y-coordinate of the drop event, in logical (CSS) pixels relative to the webview.\n     */\n    HandlePlatformFileDrop(filenames: string[], x: number, y: number): void {\n        // Check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            return; // File drops disabled, ignore the drop\n        }\n        \n        const element = document.elementFromPoint(x, y);\n        const dropTarget = getDropTargetElement(element);\n\n        if (!dropTarget) {\n            // Drop was not on a designated drop target - ignore\n            return;\n        }\n\n        const elementDetails = {\n            id: dropTarget.id,\n            classList: Array.from(dropTarget.classList),\n            attributes: {} as { [key: string]: string },\n        };\n        for (let i = 0; i < dropTarget.attributes.length; i++) {\n            const attr = dropTarget.attributes[i];\n            elementDetails.attributes[attr.name] = attr.value;\n        }\n\n        const payload = {\n            filenames,\n            x,\n            y,\n            elementDetails,\n        };\n\n        this[callerSym](FilesDropped, payload);\n        \n        // Clean up native drag state after drop\n        cleanupNativeDrag();\n    }\n  \n    /**\n     * Moves the window to the center of the specified screen's work area.\n     *\n     * @param screenID - The ID of the target screen.\n     */\n    SetScreen(screenID: string): Promise<void> {\n        return this[callerSym](SetScreenMethod, { screenID });\n    }\n\n    /* Triggers Windows 11 Snap Assist feature (Windows only).\n     * This is equivalent to pressing Win+Z and shows snap layout options.\n     */\n    SnapAssist(): Promise<void> {\n        return this[callerSym](SnapAssistMethod);\n    }\n\n    /**\n     * Opens the print dialog for the window.\n     */\n    Print(): Promise<void> {\n        return this[callerSym](PrintMethod);\n    }\n}\n\n/**\n * The window within which the script is running.\n */\nconst thisWindow = new Window('');\n\n/**\n * Sets up global drag and drop event listeners for file drops.\n * Handles visual feedback (hover state) and file drop processing.\n */\nfunction setupDropTargetListeners() {\n    const docElement = document.documentElement;\n    let dragEnterCounter = 0;\n\n    docElement.addEventListener('dragenter', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return; // Only handle file drags, let other drags pass through\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            event.dataTransfer.dropEffect = 'none'; // Show \"no drop\" cursor\n            return; // File drops disabled, don't show hover effects\n        }\n        dragEnterCounter++;\n        \n        const targetElement = document.elementFromPoint(event.clientX, event.clientY);\n        const dropTarget = getDropTargetElement(targetElement);\n\n        // Update hover state\n        if (currentDropTarget && currentDropTarget !== dropTarget) {\n            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n        }\n\n        if (dropTarget) {\n            dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);\n            event.dataTransfer.dropEffect = 'copy';\n            currentDropTarget = dropTarget;\n        } else {\n            event.dataTransfer.dropEffect = 'none';\n            currentDropTarget = null;\n        }\n    }, false);\n\n    docElement.addEventListener('dragover', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return; // Only handle file drags\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            event.dataTransfer.dropEffect = 'none'; // Show \"no drop\" cursor\n            return; // File drops disabled, don't show hover effects\n        }\n        \n        // Update drop target as cursor moves\n        const targetElement = document.elementFromPoint(event.clientX, event.clientY);\n        const dropTarget = getDropTargetElement(targetElement);\n        \n        if (currentDropTarget && currentDropTarget !== dropTarget) {\n            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n        }\n        \n        if (dropTarget) {\n            if (!dropTarget.classList.contains(DROP_TARGET_ACTIVE_CLASS)) {\n                dropTarget.classList.add(DROP_TARGET_ACTIVE_CLASS);\n            }\n            event.dataTransfer.dropEffect = 'copy';\n            currentDropTarget = dropTarget;\n        } else {\n            event.dataTransfer.dropEffect = 'none';\n            currentDropTarget = null;\n        }\n    }, false);\n\n    docElement.addEventListener('dragleave', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return;\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            return;\n        }\n        \n        // On Linux/WebKitGTK and macOS, dragleave fires immediately with relatedTarget=null when native\n        // drag handling is involved. Ignore these spurious events - we'll clean up on drop instead.\n        if (event.relatedTarget === null) {\n            return;\n        }\n        \n        dragEnterCounter--;\n        \n        if (dragEnterCounter === 0 || \n            (currentDropTarget && !currentDropTarget.contains(event.relatedTarget as Node))) {\n            if (currentDropTarget) {\n                currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n                currentDropTarget = null;\n            }\n            dragEnterCounter = 0;\n        }\n    }, false);\n\n    docElement.addEventListener('drop', (event) => {\n        if (!event.dataTransfer?.types.includes('Files')) {\n            return; // Only handle file drops\n        }\n        event.preventDefault(); // Always prevent default to stop browser navigation\n        // On Windows, check if file drops are enabled for this window\n        if ((window as any)._wails?.flags?.enableFileDrop === false) {\n            return;\n        }\n        dragEnterCounter = 0;\n        \n        if (currentDropTarget) {\n            currentDropTarget.classList.remove(DROP_TARGET_ACTIVE_CLASS);\n            currentDropTarget = null;\n        }\n\n        // On Windows, handle file drops via JavaScript\n        // On macOS/Linux, native code will call HandlePlatformFileDrop\n        if (canResolveFilePaths()) {\n            const files: File[] = [];\n            if (event.dataTransfer.items) {\n                for (const item of event.dataTransfer.items) {\n                    if (item.kind === 'file') {\n                        const file = item.getAsFile();\n                        if (file) files.push(file);\n                    }\n                }\n            } else if (event.dataTransfer.files) {\n                for (const file of event.dataTransfer.files) {\n                    files.push(file);\n                }\n            }\n            \n            if (files.length > 0) {\n                resolveFilePaths(event.clientX, event.clientY, files);\n            }\n        }\n    }, false);\n}\n\n// Initialize listeners when the script loads\nif (typeof window !== \"undefined\" && typeof document !== \"undefined\") {\n    setupDropTargetListeners();\n}\n\nexport default thisWindow;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport * as Runtime from \"../@wailsio/runtime/src\";\n\n// NOTE: the following methods MUST be imported explicitly because of how esbuild injection works\nimport { Enable as EnableWML } from \"../@wailsio/runtime/src/wml\";\nimport { debugLog } from \"../@wailsio/runtime/src/utils\";\n\nwindow.wails = Runtime;\nEnableWML();\n\nif (DEBUG) {\n    debugLog(\"Wails Runtime Loaded\")\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.System);\n\nconst SystemIsDarkMode = 0;\nconst SystemEnvironment = 1;\nconst SystemCapabilities = 2;\n\nconst _invoke = (function () {\n    try {\n        // Windows WebView2\n        if ((window as any).chrome?.webview?.postMessage) {\n            return (window as any).chrome.webview.postMessage.bind((window as any).chrome.webview);\n        }\n        // macOS/iOS WKWebView\n        else if ((window as any).webkit?.messageHandlers?.['external']?.postMessage) {\n            return (window as any).webkit.messageHandlers['external'].postMessage.bind((window as any).webkit.messageHandlers['external']);\n        }\n        // Android WebView - uses addJavascriptInterface which exposes window.wails.invoke\n        else if ((window as any).wails?.invoke) {\n            return (msg: any) => (window as any).wails.invoke(typeof msg === 'string' ? msg : JSON.stringify(msg));\n        }\n    } catch(e) {}\n\n    console.warn('\\n%c\u26A0\uFE0F Browser Environment Detected %c\\n\\n%cOnly UI previews are available in the browser. For full functionality, please run the application in desktop mode.\\nMore information at: https://v3.wails.io/learn/build/#using-a-browser-for-development\\n',\n        'background: #ffffff; color: #000000; font-weight: bold; padding: 4px 8px; border-radius: 4px; border: 2px solid #000000;',\n        'background: transparent;',\n        'color: #ffffff; font-style: italic; font-weight: bold;');\n    return null;\n})();\n\nexport function invoke(msg: any): void {\n    _invoke?.(msg);\n}\n\n/**\n * Retrieves the system dark mode status.\n *\n * @returns A promise that resolves to a boolean value indicating if the system is in dark mode.\n */\nexport function IsDarkMode(): Promise<boolean> {\n    return call(SystemIsDarkMode);\n}\n\n/**\n * Fetches the capabilities of the application from the server.\n *\n * @returns A promise that resolves to an object containing the capabilities.\n */\nexport async function Capabilities(): Promise<Record<string, any>> {\n    return call(SystemCapabilities);\n}\n\nexport interface OSInfo {\n    /** The branding of the OS. */\n    Branding: string;\n    /** The ID of the OS. */\n    ID: string;\n    /** The name of the OS. */\n    Name: string;\n    /** The version of the OS. */\n    Version: string;\n}\n\nexport interface EnvironmentInfo {\n    /** The architecture of the system. */\n    Arch: string;\n    /** True if the application is running in debug mode, otherwise false. */\n    Debug: boolean;\n    /** The operating system in use. */\n    OS: string;\n    /** Details of the operating system. */\n    OSInfo: OSInfo;\n    /** Additional platform information. */\n    PlatformInfo: Record<string, any>;\n}\n\n/**\n * Retrieves environment details.\n *\n * @returns A promise that resolves to an object containing OS and system architecture.\n */\nexport function Environment(): Promise<EnvironmentInfo> {\n    return call(SystemEnvironment);\n}\n\n/**\n * Checks if the current operating system is Windows.\n *\n * @return True if the operating system is Windows, otherwise false.\n */\nexport function IsWindows(): boolean {\n    return (window as any)._wails?.environment?.OS === \"windows\";\n}\n\n/**\n * Checks if the current operating system is Linux.\n *\n * @returns Returns true if the current operating system is Linux, false otherwise.\n */\nexport function IsLinux(): boolean {\n    return (window as any)._wails?.environment?.OS === \"linux\";\n}\n\n/**\n * Checks if the current environment is a macOS operating system.\n *\n * @returns True if the environment is macOS, false otherwise.\n */\nexport function IsMac(): boolean {\n    return (window as any)._wails?.environment?.OS === \"darwin\";\n}\n\n/**\n * Checks if the current operating system is iOS.\n *\n * @returns True if the operating system is iOS, otherwise false.\n */\nexport function IsIOS(): boolean {\n    return (window as any)._wails?.environment?.OS === \"ios\";\n}\n\n/**\n * Checks if the current operating system is Android.\n *\n * @returns True if the operating system is Android, otherwise false.\n */\nexport function IsAndroid(): boolean {\n    return (window as any)._wails?.environment?.OS === \"android\";\n}\n\n/**\n * Checks if the app is running on a mobile OS (iOS or Android).\n *\n * @returns True on iOS or Android, otherwise false.\n */\nexport function IsMobile(): boolean {\n    return IsIOS() || IsAndroid();\n}\n\n/**\n * Checks if the app is running on a desktop OS (macOS, Windows or Linux).\n *\n * @returns True on macOS, Windows or Linux, otherwise false.\n */\nexport function IsDesktop(): boolean {\n    return IsMac() || IsWindows() || IsLinux();\n}\n\n/**\n * Checks if the current environment architecture is AMD64.\n *\n * @returns True if the current environment architecture is AMD64, false otherwise.\n */\nexport function IsAMD64(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"amd64\";\n}\n\n/**\n * Checks if the current architecture is ARM.\n *\n * @returns True if the current architecture is ARM, false otherwise.\n */\nexport function IsARM(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"arm\";\n}\n\n/**\n * Checks if the current environment is ARM64 architecture.\n *\n * @returns Returns true if the environment is ARM64 architecture, otherwise returns false.\n */\nexport function IsARM64(): boolean {\n    return (window as any)._wails?.environment?.Arch === \"arm64\";\n}\n\n/**\n * Reports whether the app is being run in debug mode.\n *\n * @returns True if the app is being run in debug mode.\n */\nexport function IsDebug(): boolean {\n    return Boolean((window as any)._wails?.environment?.Debug);\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { IsDebug } from \"./system.js\";\nimport { eventTarget } from \"./utils.js\";\n\n// setup\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    window.addEventListener('contextmenu', contextMenuHandler);\n}\n\nconst call = newRuntimeCaller(objectNames.ContextMenu);\n\nconst ContextMenuOpen = 0;\n\nfunction openContextMenu(id: string, x: number, y: number, data: any): void {\n    void call(ContextMenuOpen, {id, x, y, data});\n}\n\nfunction contextMenuHandler(event: MouseEvent) {\n    const target = eventTarget(event);\n\n    // Check for custom context menu\n    const customContextMenu = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu\").trim();\n\n    if (customContextMenu) {\n        event.preventDefault();\n        const data = window.getComputedStyle(target).getPropertyValue(\"--custom-contextmenu-data\");\n        openContextMenu(customContextMenu, event.clientX, event.clientY, data);\n    } else {\n        processDefaultContextMenu(event, target);\n    }\n}\n\n\n/*\n--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea\n--default-contextmenu: show; will always show the default context menu\n--default-contextmenu: hide; will always hide the default context menu\n\nThis rule is inherited like normal CSS rules, so nesting works as expected\n*/\nfunction processDefaultContextMenu(event: MouseEvent, target: HTMLElement) {\n    // Debug builds always show the menu\n    if (IsDebug()) {\n        return;\n    }\n\n    // Process default context menu\n    switch (window.getComputedStyle(target).getPropertyValue(\"--default-contextmenu\").trim()) {\n        case 'show':\n            return;\n        case 'hide':\n            event.preventDefault();\n            return;\n    }\n\n    // Check if contentEditable is true\n    if (target.isContentEditable) {\n        return;\n    }\n\n    // Check if text has been selected\n    const selection = window.getSelection();\n    const hasSelection = selection && selection.toString().length > 0;\n    if (hasSelection) {\n        for (let i = 0; i < selection.rangeCount; i++) {\n            const range = selection.getRangeAt(i);\n            const rects = range.getClientRects();\n            for (let j = 0; j < rects.length; j++) {\n                const rect = rects[j];\n                if (document.elementFromPoint(rect.left, rect.top) === target) {\n                    return;\n                }\n            }\n        }\n    }\n\n    // Check if tag is input or textarea.\n    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {\n        if (hasSelection || (!target.readOnly && !target.disabled)) {\n            return;\n        }\n    }\n\n    // hide default context menu\n    event.preventDefault();\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Retrieves the value associated with the specified key from the flag map.\n *\n * @param key - The key to retrieve the value for.\n * @return The value associated with the specified key.\n */\nexport function GetFlag(key: string): any {\n    try {\n        return window._wails.flags[key];\n    } catch (e) {\n        throw new Error(\"Unable to retrieve flag '\" + key + \"': \" + e, { cause: e });\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { invoke, IsWindows, IsLinux } from \"./system.js\";\nimport { GetFlag } from \"./flags.js\";\nimport { canTrackButtons, eventTarget } from \"./utils.js\";\n\n// Setup\nlet canDrag = false;\nlet dragging = false;\n\nlet resizable = false;\nlet canResize = false;\nlet resizing = false;\nlet resizeEdge: string = \"\";\nlet defaultCursor = \"auto\";\n\nlet buttons = 0;\nimport { hasDOM } from \"./environment.js\";\n\nlet buttonsTracked = false;\n\nif (hasDOM) {\n    buttonsTracked = canTrackButtons();\n    window._wails = window._wails || {};\n    window._wails.setResizable = (value: boolean): void => {\n        resizable = value;\n        if (!resizable) {\n            // Stop resizing if in progress.\n            canResize = resizing = false;\n            setResize();\n        }\n    };\n}\n\n// Defer attaching mouse listeners until we know we're not on mobile.\nlet dragInitDone = false;\nfunction isMobile(): boolean {\n    const os = (window as any)._wails?.environment?.OS;\n    if (os === \"ios\" || os === \"android\") return true;\n    // Fallback heuristic if environment not yet set\n    const ua = navigator.userAgent || navigator.vendor || (window as any).opera || \"\";\n    return /android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(ua);\n}\nfunction tryInitDragHandlers(): void {\n    if (dragInitDone) return;\n    if (isMobile()) return;\n    window.addEventListener('mousedown', update, { capture: true });\n    window.addEventListener('mousemove', update, { capture: true });\n    window.addEventListener('mouseup', update, { capture: true });\n    for (const ev of ['click', 'contextmenu', 'dblclick']) {\n        window.addEventListener(ev, suppressEvent, { capture: true });\n    }\n    dragInitDone = true;\n}\nif (hasDOM) {\n    // Attempt immediate init (in case environment already present)\n    tryInitDragHandlers();\n    // Also attempt on DOM ready\n    document.addEventListener('DOMContentLoaded', tryInitDragHandlers, { once: true });\n    // As a last resort, poll for environment for a short period\n    let dragEnvPolls = 0;\n    const dragEnvPoll = window.setInterval(() => {\n        if (dragInitDone) { window.clearInterval(dragEnvPoll); return; }\n        tryInitDragHandlers();\n        if (++dragEnvPolls > 100) { window.clearInterval(dragEnvPoll); }\n    }, 50);\n}\n\nfunction suppressEvent(event: Event) {\n    // Suppress click events while resizing or dragging.\n    if (dragging || resizing) {\n        event.stopImmediatePropagation();\n        event.stopPropagation();\n        event.preventDefault();\n    }\n}\n\n// Use constants to avoid comparing strings multiple times.\nconst MouseDown = 0;\nconst MouseUp   = 1;\nconst MouseMove = 2;\n\nfunction update(event: MouseEvent) {\n    // Windows suppresses mouse events at the end of dragging or resizing,\n    // so we need to be smart and synthesize button events.\n\n    let eventType: number, eventButtons = event.buttons;\n    switch (event.type) {\n        case 'mousedown':\n            eventType = MouseDown;\n            if (!buttonsTracked) { eventButtons = buttons | (1 << event.button); }\n            break;\n        case 'mouseup':\n            eventType = MouseUp;\n            if (!buttonsTracked) { eventButtons = buttons & ~(1 << event.button); }\n            break;\n        default:\n            eventType = MouseMove;\n            if (!buttonsTracked) { eventButtons = buttons; }\n            break;\n    }\n\n    let released = buttons & ~eventButtons;\n    let pressed = eventButtons & ~buttons;\n\n    buttons = eventButtons;\n\n    // Synthesize a release-press sequence if we detect a press of an already pressed button.\n    if (eventType === MouseDown && !(pressed & event.button)) {\n        released |= (1 << event.button);\n        pressed |= (1 << event.button);\n    }\n\n    // Suppress all button events during dragging and resizing,\n    // unless this is a mouseup event that is ending a drag action.\n    if (\n        eventType !== MouseMove // Fast path for mousemove\n        && resizing\n        || (\n            dragging\n            && (\n                eventType === MouseDown\n                || event.button !== 0\n            )\n        )\n    ) {\n        event.stopImmediatePropagation();\n        event.stopPropagation();\n        event.preventDefault();\n    }\n\n    // Handle releases\n    if (released & 1) { primaryUp(event); }\n    // Handle presses\n    if (pressed & 1) { primaryDown(event); }\n\n    // Handle mousemove\n    if (eventType === MouseMove) { onMouseMove(event); };\n}\n\nfunction primaryDown(event: MouseEvent): void {\n    // Reset readiness state.\n    canDrag = false;\n    canResize = false;\n\n    // Ignore repeated clicks on macOS and Linux.\n    if (!IsWindows()) {\n        if (event.type === 'mousedown' && event.button === 0 && event.detail !== 1) {\n            return;\n        }\n    }\n\n    if (resizeEdge) {\n        // Do not arm edge resize from synthesized presses observed on move/up:\n        // entering the window with the primary button already held should not\n        // steal another gesture into a resize.\n        if (event.type !== 'mousedown') {\n            return;\n        }\n\n        // Ready to resize if the primary button was pressed for the first time.\n        canResize = true;\n        // Do not start drag operations when on resize edges.\n        return;\n    }\n\n    // Retrieve target element\n    const target = eventTarget(event);\n\n    // Ready to drag if the primary button was pressed for the first time on a draggable element.\n    // Ignore clicks on the scrollbar.\n    const style = window.getComputedStyle(target);\n    canDrag = (\n        style.getPropertyValue(\"--wails-draggable\").trim() === \"drag\"\n        && (\n            event.offsetX - parseFloat(style.paddingLeft) < target.clientWidth\n            && event.offsetY - parseFloat(style.paddingTop) < target.clientHeight\n        )\n    );\n}\n\nfunction primaryUp(event: MouseEvent) {\n    // Stop dragging and resizing.\n    canDrag = false;\n    dragging = false;\n    canResize = false;\n    resizing = false;\n}\n\nconst cursorForEdge = Object.freeze({\n    \"se-resize\": \"nwse-resize\",\n    \"sw-resize\": \"nesw-resize\",\n    \"nw-resize\": \"nwse-resize\",\n    \"ne-resize\": \"nesw-resize\",\n    \"w-resize\": \"ew-resize\",\n    \"n-resize\": \"ns-resize\",\n    \"s-resize\": \"ns-resize\",\n    \"e-resize\": \"ew-resize\",\n})\n\nfunction setResize(edge?: keyof typeof cursorForEdge): void {\n    if (edge) {\n        if (!resizeEdge) { defaultCursor = document.body.style.cursor; }\n        document.body.style.cursor = cursorForEdge[edge];\n    } else if (!edge && resizeEdge) {\n        document.body.style.cursor = defaultCursor;\n    }\n\n    resizeEdge = edge || \"\";\n}\n\nfunction onMouseMove(event: MouseEvent): void {\n    if (canResize && resizeEdge) {\n        // Start resizing.\n        resizing = true;\n        invoke(\"wails:resize:\" + resizeEdge);\n    } else if (canDrag) {\n        // Start dragging.\n        dragging = true;\n        invoke(\"wails:drag\");\n    }\n\n    if (dragging || resizing) {\n        // Either drag or resize is ongoing,\n        // reset readiness and stop processing.\n        canDrag = canResize = false;\n        return;\n    }\n\n    if (!resizable || (!IsWindows() && !(IsLinux() && GetFlag(\"frameless\")))) {\n        if (resizeEdge) { setResize(); }\n        return;\n    }\n\n    const resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\n    const resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\n\n    // Extra pixels for the corner areas.\n    const cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\n\n    // When a scrollbar is present at the window edge it consumes mouse events in that strip.\n    // Shift the effective content edge inward so the resize zone sits just before the scrollbar.\n    const scrollbarWidth = Math.max(0, window.innerWidth - document.documentElement.clientWidth);\n    const scrollbarHeight = Math.max(0, window.innerHeight - document.documentElement.clientHeight);\n    const rightContentEdge = window.innerWidth - scrollbarWidth;\n    const bottomContentEdge = window.innerHeight - scrollbarHeight;\n\n    const rightBorder = event.clientX < rightContentEdge && (rightContentEdge - event.clientX) < resizeHandleWidth;\n    const leftBorder = event.clientX < resizeHandleWidth;\n    const topBorder = event.clientY < resizeHandleHeight;\n    const bottomBorder = event.clientY < bottomContentEdge && (bottomContentEdge - event.clientY) < resizeHandleHeight;\n\n    // Adjust for corner areas.\n    const rightCorner = event.clientX < rightContentEdge && (rightContentEdge - event.clientX) < (resizeHandleWidth + cornerExtra);\n    const leftCorner = event.clientX < (resizeHandleWidth + cornerExtra);\n    const topCorner = event.clientY < (resizeHandleHeight + cornerExtra);\n    const bottomCorner = event.clientY < bottomContentEdge && (bottomContentEdge - event.clientY) < (resizeHandleHeight + cornerExtra);\n\n    if (!leftCorner && !topCorner && !bottomCorner && !rightCorner) {\n        // Optimisation: out of all corner areas implies out of borders.\n        setResize();\n    }\n    // Detect corners.\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\n    // Detect borders.\n    else if (leftBorder) setResize(\"w-resize\");\n    else if (topBorder) setResize(\"n-resize\");\n    else if (bottomBorder) setResize(\"s-resize\");\n    else if (rightBorder) setResize(\"e-resize\");\n    // Out of border area.\n    else setResize();\n}\n", "/*\n _     __    _ __\n| |   / /___(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { invoke } from \"./system.js\";\nimport { whenReady } from \"./utils.js\";\nimport { hasDOM } from \"./environment.js\";\n\ntype NonClientRegionKind = \"caption\" | \"minimize\" | \"maximize\" | \"close\";\n\ninterface NonClientRegion {\n    kind: NonClientRegionKind;\n    left: number;\n    top: number;\n    right: number;\n    bottom: number;\n}\n\n/*\n--wails-non-client-region: caption;  marks an area that can drag the window\n--wails-non-client-region: minimize; marks a custom minimize button\n--wails-non-client-region: maximize; marks a custom maximize button\n--wails-non-client-region: close;    marks a custom close button\n*/\nconst regionProperty = \"--wails-non-client-region\";\nconst runtimeConfigReadyEvent = \"wails:runtime-config-ready\";\nconst validRegions = new Set<NonClientRegionKind>([\"caption\", \"minimize\", \"maximize\", \"close\"]);\n\n// Setup\nif (hasDOM) {\n    window._wails = window._wails || {};\n}\n\nlet updatePending = false;\nlet lastPayload = \"\";\nlet observedElements = new Set<Element>();\nlet resizeObserver: ResizeObserver | undefined;\nlet trackingStarted = false;\n\nfunction normaliseRegionKind(value: string): NonClientRegionKind | undefined {\n    const region = value.trim().toLowerCase();\n    if (validRegions.has(region as NonClientRegionKind)) {\n        return region as NonClientRegionKind;\n    }\n    return undefined;\n}\n\nfunction nonClientRegionForElement(element: Element): NonClientRegionKind | undefined {\n    if (!(element instanceof HTMLElement)) {\n        return undefined;\n    }\n\n    const style = window.getComputedStyle(element);\n    const region = normaliseRegionKind(style.getPropertyValue(regionProperty));\n    if (!region) {\n        return undefined;\n    }\n\n    const parent = element.parentElement;\n    if (parent) {\n        const parentStyle = window.getComputedStyle(parent);\n        // The CSS property is inherited. Only report the outermost element for\n        // each contiguous region so native hit testing sees stable rectangles.\n        if (normaliseRegionKind(parentStyle.getPropertyValue(regionProperty)) === region) {\n            return undefined;\n        }\n    }\n\n    return region;\n}\n\nfunction isVisible(element: HTMLElement): boolean {\n    const style = window.getComputedStyle(element);\n    return style.display !== \"none\" &&\n        style.visibility !== \"hidden\" &&\n        style.contentVisibility !== \"hidden\";\n}\n\nfunction elementRegion(element: Element): NonClientRegion | undefined {\n    if (!(element instanceof HTMLElement)) {\n        return undefined;\n    }\n\n    const kind = nonClientRegionForElement(element);\n    if (!kind || !isVisible(element)) {\n        return undefined;\n    }\n\n    const rect = element.getBoundingClientRect();\n    if (rect.width <= 0 || rect.height <= 0) {\n        return undefined;\n    }\n\n    // Native hit testing runs in physical pixels, while DOM geometry is in CSS pixels.\n    const scale = window.devicePixelRatio || 1;\n    const left = Math.floor(rect.left * scale);\n    const top = Math.floor(rect.top * scale);\n    const right = Math.ceil(rect.right * scale);\n    const bottom = Math.ceil(rect.bottom * scale);\n\n    if (right <= left || bottom <= top) {\n        return undefined;\n    }\n\n    return { kind, left, top, right, bottom };\n}\n\nfunction regionElements(): Element[] {\n    const elements: Element[] = [];\n\n    if (document.documentElement) {\n        elements.push(document.documentElement);\n    }\n    if (document.body) {\n        elements.push(document.body);\n        // Append via a loop: spreading a huge NodeList into push() overflows\n        // the engine's argument limit on very large documents.\n        for (const element of document.body.querySelectorAll(\"*\")) {\n            elements.push(element);\n        }\n    }\n\n    return elements;\n}\n\nfunction observeRegionElements(elements: Element[]): void {\n    if (typeof ResizeObserver === \"undefined\") {\n        return;\n    }\n\n    // Track size changes only for active region elements. DOM structure and style\n    // changes are covered by MutationObserver in startNonClientRegionTracking().\n    resizeObserver ??= new ResizeObserver(scheduleUpdate);\n    const nextElements = new Set(elements);\n\n    for (const element of observedElements) {\n        if (!nextElements.has(element)) {\n            resizeObserver.unobserve(element);\n        }\n    }\n\n    for (const element of nextElements) {\n        if (!observedElements.has(element)) {\n            resizeObserver.observe(element);\n        }\n    }\n\n    observedElements = nextElements;\n}\n\nfunction updateNonClientRegions(): void {\n    updatePending = false;\n\n    const elements = regionElements();\n    const regions: NonClientRegion[] = [];\n    const activeElements: Element[] = [];\n\n    for (const element of elements) {\n        const region = elementRegion(element);\n        if (region) {\n            regions.push(region);\n            activeElements.push(element);\n        }\n    }\n\n    observeRegionElements(activeElements);\n\n    const payload = JSON.stringify({ version: 1, regions });\n    if (payload === lastPayload) {\n        // Avoid sending duplicate native messages during resize or style churn.\n        return;\n    }\n\n    lastPayload = payload;\n    invoke(\"wails:non-client-region:\" + payload);\n}\n\nfunction scheduleUpdate(): void {\n    if (updatePending) {\n        return;\n    }\n\n    // Batch region updates to animation frames so layout is measured once per frame.\n    updatePending = true;\n    window.requestAnimationFrame(updateNonClientRegions);\n}\n\nfunction startNonClientRegionTracking(): void {\n    if (trackingStarted) {\n        return;\n    }\n\n    trackingStarted = true;\n    // Send an initial empty or populated region list once the DOM is ready.\n    scheduleUpdate();\n\n    const mutationObserver = new MutationObserver(scheduleUpdate);\n    mutationObserver.observe(document.documentElement, {\n        attributes: true,\n        childList: true,\n        subtree: true,\n    });\n\n    window.addEventListener(\"resize\", scheduleUpdate);\n    window.addEventListener(\"scroll\", scheduleUpdate, true);\n    window.visualViewport?.addEventListener(\"resize\", scheduleUpdate);\n    window.visualViewport?.addEventListener(\"scroll\", scheduleUpdate);\n}\n\nfunction tryStartNonClientRegionTracking(): boolean {\n    const os = window._wails.environment?.OS;\n    if (os === undefined) {\n        return false;\n    }\n\n    const enabled = window._wails.flags?.nonClientRegionTracking;\n    if (os === \"windows\") {\n        if (enabled === true) {\n            whenReady(startNonClientRegionTracking);\n        }\n        return true;\n    }\n\n    return true;\n}\n\nif (hasDOM && !tryStartNonClientRegionTracking()) {\n    window.addEventListener(runtimeConfigReadyEvent, tryStartNonClientRegionTracking, { once: true });\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nconst call = newRuntimeCaller(objectNames.Application);\n\nconst HideMethod = 0;\nconst ShowMethod = 1;\nconst QuitMethod = 2;\n\n/**\n * Hides a certain method by calling the HideMethod function.\n */\nexport function Hide(): Promise<void> {\n    return call(HideMethod);\n}\n\n/**\n * Calls the ShowMethod and returns the result.\n */\nexport function Show(): Promise<void> {\n    return call(ShowMethod);\n}\n\n/**\n * Calls the QuitMethod to terminate the program.\n */\nexport function Quit(): Promise<void> {\n    return call(QuitMethod);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { CancellablePromise, type CancellablePromiseWithResolvers } from \"./cancellable.js\";\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nimport { nanoid } from \"./nanoid.js\";\n\n// Setup\nimport { hasDOM } from \"./environment.js\";\n\nif (hasDOM) {\n    window._wails = window._wails || {};\n}\n\ntype PromiseResolvers = Omit<CancellablePromiseWithResolvers<any>, \"promise\" | \"oncancelled\">\n\nconst call = newRuntimeCaller(objectNames.Call);\nconst cancelCall = newRuntimeCaller(objectNames.CancelCall);\nconst callResponses = new Map<string, PromiseResolvers>();\n\nconst CallBinding = 0;\nconst CancelMethod = 0\n\n/**\n * Holds all required information for a binding call.\n * May provide either a method ID or a method name, but not both.\n */\nexport type CallOptions = {\n    /** The numeric ID of the bound method to call. */\n    methodID: number;\n    /** The fully qualified name of the bound method to call. */\n    methodName?: never;\n    /** Arguments to be passed into the bound method. */\n    args: any[];\n} | {\n    /** The numeric ID of the bound method to call. */\n    methodID?: never;\n    /** The fully qualified name of the bound method to call. */\n    methodName: string;\n    /** Arguments to be passed into the bound method. */\n    args: any[];\n};\n\n// runtime.js needs to use RuntimeError internally to properly parse and return\n// errors for binding calls, so it had to move there. Exporting here again to\n// keep from breaking the public Call interface.\nexport { RuntimeError } from \"./runtime.js\";\n\n/**\n * Generates a unique ID using the nanoid library.\n *\n * @returns A unique ID that does not exist in the callResponses set.\n */\nfunction generateID(): string {\n    let result;\n    do {\n        result = nanoid();\n    } while (callResponses.has(result));\n    return result;\n}\n\n/**\n * Call a bound method according to the given call options.\n *\n * In case of failure, the returned promise will reject with an exception\n * among ReferenceError (unknown method), TypeError (wrong argument count or type),\n * {@link RuntimeError} (method returned an error), or other (network or internal errors).\n * The exception might have a \"cause\" field with the value returned\n * by the application- or service-level error marshaling functions.\n *\n * @param options - A method call descriptor.\n * @returns The result of the call.\n */\nexport function Call(options: CallOptions): CancellablePromise<any> {\n    const id = generateID();\n\n    const result = CancellablePromise.withResolvers<any>();\n    callResponses.set(id, { resolve: result.resolve, reject: result.reject });\n\n    const request = call(CallBinding, Object.assign({ \"call-id\": id }, options));\n    let running = true;\n\n    request.then((res) => {\n        running = false;\n        callResponses.delete(id);\n        result.resolve(res);\n    }, (err) => {\n        running = false;\n        callResponses.delete(id);\n        result.reject(err);\n    });\n\n    const cancel = () => {\n        callResponses.delete(id);\n        return cancelCall(CancelMethod, {\"call-id\": id}).catch((err) => {\n            console.error(\"Error while requesting binding call cancellation:\", err);\n        });\n    };\n\n    result.oncancelled = () => {\n        if (running) {\n            return cancel();\n        } else {\n            return request.then(cancel);\n        }\n    };\n\n    return result.promise;\n}\n\n/**\n * Calls a bound method by name with the specified arguments.\n * See {@link Call} for details.\n *\n * @param methodName - The name of the method in the format 'package.struct.method'.\n * @param args - The arguments to pass to the method.\n * @returns The result of the method call.\n */\nexport function ByName(methodName: string, ...args: any[]): CancellablePromise<any> {\n    return Call({ methodName, args });\n}\n\n/**\n * Calls a method by its numeric ID with the specified arguments.\n * See {@link Call} for details.\n *\n * @param methodID - The ID of the method to call.\n * @param args - The arguments to pass to the method.\n * @return The result of the method call.\n */\nexport function ByID(methodID: number, ...args: any[]): CancellablePromise<any> {\n    return Call({ methodID, args });\n}\n", "// Source: https://github.com/inspect-js/is-callable\n\n// The MIT License (MIT)\n//\n// Copyright (c) 2015 Jordan Harband\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply: typeof Reflect.apply | false | null = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike: any;\nvar isCallableMarker: any;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n    try {\n        badArrayLike = Object.defineProperty({}, 'length', {\n            get: function () {\n                throw isCallableMarker;\n            }\n        });\n        isCallableMarker = {};\n        // eslint-disable-next-line no-throw-literal\n        reflectApply(function () { throw 42; }, null, badArrayLike);\n    } catch (_) {\n        if (_ !== isCallableMarker) {\n            reflectApply = null;\n        }\n    }\n} else {\n    reflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value: any): boolean {\n    try {\n        var fnStr = fnToStr.call(value);\n        return constructorRegex.test(fnStr);\n    } catch (e) {\n        return false; // not a function\n    }\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value: any): boolean {\n    try {\n        if (isES6ClassFn(value)) { return false; }\n        fnToStr.call(value);\n        return true;\n    } catch (e) {\n        return false;\n    }\n};\nvar toStr = Object.prototype.toString;\nvar objectClass = '[object Object]';\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\nvar ddaClass2 = '[object HTML document.all class]';\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\n\nvar isDDA: (value: any) => boolean = function isDocumentDotAll() { return false; };\nif (typeof document === 'object') {\n    // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\n    var all = document.all;\n    if (toStr.call(all) === toStr.call(document.all)) {\n        isDDA = function isDocumentDotAll(value) {\n            /* globals document: false */\n            // in IE 6-8, typeof document.all is \"object\" and it's truthy\n            if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\n                try {\n                    var str = toStr.call(value);\n                    return (\n                        str === ddaClass\n                        || str === ddaClass2\n                        || str === ddaClass3 // opera 12.16\n                        || str === objectClass // IE 6-8\n                    ) && value('') == null; // eslint-disable-line eqeqeq\n                } catch (e) { /**/ }\n            }\n            return false;\n        };\n    }\n}\n\nfunction isCallableRefApply<T>(value: T | unknown): value is (...args: any[]) => any  {\n    if (isDDA(value)) { return true; }\n    if (!value) { return false; }\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\n    try {\n        (reflectApply as any)(value, null, badArrayLike);\n    } catch (e) {\n        if (e !== isCallableMarker) { return false; }\n    }\n    return !isES6ClassFn(value) && tryFunctionObject(value);\n}\n\nfunction isCallableNoRefApply<T>(value: T | unknown): value is (...args: any[]) => any {\n    if (isDDA(value)) { return true; }\n    if (!value) { return false; }\n    if (typeof value !== 'function' && typeof value !== 'object') { return false; }\n    if (hasToStringTag) { return tryFunctionObject(value); }\n    if (isES6ClassFn(value)) { return false; }\n    var strClass = toStr.call(value);\n    if (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\n    return tryFunctionObject(value);\n};\n\nexport default reflectApply ? isCallableRefApply : isCallableNoRefApply;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport isCallable from \"./callable.js\";\n\n/**\n * Exception class that will be used as rejection reason\n * in case a {@link CancellablePromise} is cancelled successfully.\n *\n * The value of the {@link name} property is the string `\"CancelError\"`.\n * The value of the {@link cause} property is the cause passed to the cancel method, if any.\n */\nexport class CancelError extends Error {\n    /**\n     * Constructs a new `CancelError` instance.\n     * @param message - The error message.\n     * @param options - Options to be forwarded to the Error constructor.\n     */\n    constructor(message?: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"CancelError\";\n    }\n}\n\n/**\n * Exception class that will be reported as an unhandled rejection\n * in case a {@link CancellablePromise} rejects after being cancelled,\n * or when the `oncancelled` callback throws or rejects.\n *\n * The value of the {@link name} property is the string `\"CancelledRejectionError\"`.\n * The value of the {@link cause} property is the reason the promise rejected with.\n *\n * Because the original promise was cancelled,\n * a wrapper promise will be passed to the unhandled rejection listener instead.\n * The {@link promise} property holds a reference to the original promise.\n */\nexport class CancelledRejectionError extends Error {\n    /**\n     * Holds a reference to the promise that was cancelled and then rejected.\n     */\n    promise: CancellablePromise<unknown>;\n\n    /**\n     * Constructs a new `CancelledRejectionError` instance.\n     * @param promise - The promise that caused the error originally.\n     * @param reason - The rejection reason.\n     * @param info - An optional informative message specifying the circumstances in which the error was thrown.\n     *               Defaults to the string `\"Unhandled rejection in cancelled promise.\"`.\n     */\n    constructor(promise: CancellablePromise<unknown>, reason?: any, info?: string) {\n        super((info ?? \"Unhandled rejection in cancelled promise.\") + \" Reason: \" + errorMessage(reason), { cause: reason });\n        this.promise = promise;\n        this.name = \"CancelledRejectionError\";\n    }\n}\n\ntype CancellablePromiseResolver<T> = (value: T | PromiseLike<T> | CancellablePromiseLike<T>) => void;\ntype CancellablePromiseRejector = (reason?: any) => void;\ntype CancellablePromiseCanceller = (cause?: any) => void | PromiseLike<void>;\ntype CancellablePromiseExecutor<T> = (resolve: CancellablePromiseResolver<T>, reject: CancellablePromiseRejector) => void;\n\nexport interface CancellablePromiseLike<T> {\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null): CancellablePromiseLike<TResult1 | TResult2>;\n    cancel(cause?: any): void | PromiseLike<void>;\n}\n\n/**\n * Wraps a cancellable promise along with its resolution methods.\n * The `oncancelled` field will be null initially but may be set to provide a custom cancellation function.\n */\nexport interface CancellablePromiseWithResolvers<T> {\n    promise: CancellablePromise<T>;\n    resolve: CancellablePromiseResolver<T>;\n    reject: CancellablePromiseRejector;\n    oncancelled: CancellablePromiseCanceller | null;\n}\n\ninterface CancellablePromiseState {\n    readonly root: CancellablePromiseState;\n    resolving: boolean;\n    settled: boolean;\n    reason?: CancelError;\n}\n\n// Private field names.\nconst barrierSym = Symbol(\"barrier\");\nconst cancelImplSym = Symbol(\"cancelImpl\");\nconst species: typeof Symbol.species = Symbol.species ?? Symbol(\"speciesPolyfill\");\n\n/**\n * A promise with an attached method for cancelling long-running operations (see {@link CancellablePromise#cancel}).\n * Cancellation can optionally be bound to an {@link AbortSignal}\n * for better composability (see {@link CancellablePromise#cancelOn}).\n *\n * Cancelling a pending promise will result in an immediate rejection\n * with an instance of {@link CancelError} as reason,\n * but whoever started the promise will be responsible\n * for actually aborting the underlying operation.\n * To this purpose, the constructor and all chaining methods\n * accept optional cancellation callbacks.\n *\n * If a `CancellablePromise` still resolves after having been cancelled,\n * the result will be discarded. If it rejects, the reason\n * will be reported as an unhandled rejection,\n * wrapped in a {@link CancelledRejectionError} instance.\n * To facilitate the handling of cancellation requests,\n * cancelled `CancellablePromise`s will _not_ report unhandled `CancelError`s\n * whose `cause` field is the same as the one with which the current promise was cancelled.\n *\n * All usual promise methods are defined and return a `CancellablePromise`\n * whose cancel method will cancel the parent operation as well, propagating the cancellation reason\n * upwards through promise chains.\n * Conversely, cancelling a promise will not automatically cancel dependent promises downstream:\n * ```ts\n * let root = new CancellablePromise((resolve, reject) => { ... });\n * let child1 = root.then(() => { ... });\n * let child2 = child1.then(() => { ... });\n * let child3 = root.catch(() => { ... });\n * child1.cancel(); // Cancels child1 and root, but not child2 or child3\n * ```\n * Cancelling a promise that has already settled is safe and has no consequence.\n *\n * The `cancel` method returns a promise that _always fulfills_\n * after the whole chain has processed the cancel request\n * and all attached callbacks up to that moment have run.\n *\n * All ES2024 promise methods (static and instance) are defined on CancellablePromise,\n * but actual availability may vary with OS/webview version.\n *\n * In line with the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing,\n * `CancellablePromise` does not support transparent subclassing.\n * Extenders should take care to provide their own method implementations.\n * This might be reconsidered in case the proposal is retired.\n *\n * CancellablePromise is a wrapper around the DOM Promise object\n * and is compliant with the [Promises/A+ specification](https://promisesaplus.com/)\n * (it passes the [compliance suite](https://github.com/promises-aplus/promises-tests))\n * if so is the underlying implementation.\n */\nexport class CancellablePromise<T> extends Promise<T> implements PromiseLike<T>, CancellablePromiseLike<T> {\n    // Private fields.\n    /** @internal */\n    private [barrierSym]!: Partial<PromiseWithResolvers<void>> | null;\n    /** @internal */\n    private readonly [cancelImplSym]!: (reason: CancelError) => void | PromiseLike<void>;\n\n    /**\n     * Creates a new `CancellablePromise`.\n     *\n     * @param executor - A callback used to initialize the promise. This callback is passed two arguments:\n     *                   a `resolve` callback used to resolve the promise with a value\n     *                   or the result of another promise (possibly cancellable),\n     *                   and a `reject` callback used to reject the promise with a provided reason or error.\n     *                   If the value provided to the `resolve` callback is a thenable _and_ cancellable object\n     *                   (it has a `then` _and_ a `cancel` method),\n     *                   cancellation requests will be forwarded to that object and the oncancelled will not be invoked anymore.\n     *                   If any one of the two callbacks is called _after_ the promise has been cancelled,\n     *                   the provided values will be cancelled and resolved as usual,\n     *                   but their results will be discarded.\n     *                   However, if the resolution process ultimately ends up in a rejection\n     *                   that is not due to cancellation, the rejection reason\n     *                   will be wrapped in a {@link CancelledRejectionError}\n     *                   and bubbled up as an unhandled rejection.\n     * @param oncancelled - It is the caller's responsibility to ensure that any operation\n     *                      started by the executor is properly halted upon cancellation.\n     *                      This optional callback can be used to that purpose.\n     *                      It will be called _synchronously_ with a cancellation cause\n     *                      when cancellation is requested, _after_ the promise has already rejected\n     *                      with a {@link CancelError}, but _before_\n     *                      any {@link then}/{@link catch}/{@link finally} callback runs.\n     *                      If the callback returns a thenable, the promise returned from {@link cancel}\n     *                      will only fulfill after the former has settled.\n     *                      Unhandled exceptions or rejections from the callback will be wrapped\n     *                      in a {@link CancelledRejectionError} and bubbled up as unhandled rejections.\n     *                      If the `resolve` callback is called before cancellation with a cancellable promise,\n     *                      cancellation requests on this promise will be diverted to that promise,\n     *                      and the original `oncancelled` callback will be discarded.\n     */\n    constructor(executor: CancellablePromiseExecutor<T>, oncancelled?: CancellablePromiseCanceller) {\n        let resolve!: (value: T | PromiseLike<T>) => void;\n        let reject!: (reason?: any) => void;\n        super((res, rej) => { resolve = res; reject = rej; });\n\n        if ((this.constructor as any)[species] !== Promise) {\n            throw new TypeError(\"CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.\");\n        }\n\n        let promise: CancellablePromiseWithResolvers<T> = {\n            promise: this,\n            resolve,\n            reject,\n            get oncancelled() { return oncancelled ?? null; },\n            set oncancelled(cb) { oncancelled = cb ?? undefined; }\n        };\n\n        const state: CancellablePromiseState = {\n            get root() { return state; },\n            resolving: false,\n            settled: false\n        };\n\n        // Setup cancellation system.\n        void Object.defineProperties(this, {\n            [barrierSym]: {\n                configurable: false,\n                enumerable: false,\n                writable: true,\n                value: null\n            },\n            [cancelImplSym]: {\n                configurable: false,\n                enumerable: false,\n                writable: false,\n                value: cancellerFor(promise, state)\n            }\n        });\n\n        // Run the actual executor.\n        const rejector = rejectorFor(promise, state);\n        try {\n            executor(resolverFor(promise, state), rejector);\n        } catch (err) {\n            if (state.resolving) {\n                console.log(\"Unhandled exception in CancellablePromise executor.\", err);\n            } else {\n                rejector(err);\n            }\n        }\n    }\n\n    /**\n     * Cancels immediately the execution of the operation associated with this promise.\n     * The promise rejects with a {@link CancelError} instance as reason,\n     * with the {@link CancelError#cause} property set to the given argument, if any.\n     *\n     * Has no effect if called after the promise has already settled;\n     * repeated calls in particular are safe, but only the first one\n     * will set the cancellation cause.\n     *\n     * The `CancelError` exception _need not_ be handled explicitly _on the promises that are being cancelled:_\n     * cancelling a promise with no attached rejection handler does not trigger an unhandled rejection event.\n     * Therefore, the following idioms are all equally correct:\n     * ```ts\n     * new CancellablePromise((resolve, reject) => { ... }).cancel();\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).cancel();\n     * new CancellablePromise((resolve, reject) => { ... }).then(...).catch(...).cancel();\n     * ```\n     * Whenever some cancelled promise in a chain rejects with a `CancelError`\n     * with the same cancellation cause as itself, the error will be discarded silently.\n     * However, the `CancelError` _will still be delivered_ to all attached rejection handlers\n     * added by {@link then} and related methods:\n     * ```ts\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\n     * cancellable.then(() => { ... }).catch(console.log);\n     * cancellable.cancel(); // A CancelError is printed to the console.\n     * ```\n     * If the `CancelError` is not handled downstream by the time it reaches\n     * a _non-cancelled_ promise, it _will_ trigger an unhandled rejection event,\n     * just like normal rejections would:\n     * ```ts\n     * let cancellable = new CancellablePromise((resolve, reject) => { ... });\n     * let chained = cancellable.then(() => { ... }).then(() => { ... }); // No catch...\n     * cancellable.cancel(); // Unhandled rejection event on chained!\n     * ```\n     * Therefore, it is important to either cancel whole promise chains from their tail,\n     * as shown in the correct idioms above, or take care of handling errors everywhere.\n     *\n     * @returns A cancellable promise that _fulfills_ after the cancel callback (if any)\n     * and all handlers attached up to the call to cancel have run.\n     * If the cancel callback returns a thenable, the promise returned by `cancel`\n     * will also wait for that thenable to settle.\n     * This enables callers to wait for the cancelled operation to terminate\n     * without being forced to handle potential errors at the call site.\n     * ```ts\n     * cancellable.cancel().then(() => {\n     *     // Cleanup finished, it's safe to do something else.\n     * }, (err) => {\n     *     // Unreachable: the promise returned from cancel will never reject.\n     * });\n     * ```\n     * Note that the returned promise will _not_ handle implicitly any rejection\n     * that might have occurred already in the cancelled chain.\n     * It will just track whether registered handlers have been executed or not.\n     * Therefore, unhandled rejections will never be silently handled by calling cancel.\n     */\n    cancel(cause?: any): CancellablePromise<void> {\n        return new CancellablePromise<void>((resolve) => {\n            // INVARIANT: the result of this[cancelImplSym] and the barrier do not ever reject.\n            // Unfortunately macOS High Sierra does not support Promise.allSettled.\n            Promise.all([\n                this[cancelImplSym](new CancelError(\"Promise cancelled.\", { cause })),\n                currentBarrier(this)\n            ]).then(() => resolve(), () => resolve());\n        });\n    }\n\n    /**\n     * Binds promise cancellation to the abort event of the given {@link AbortSignal}.\n     * If the signal has already aborted, the promise will be cancelled immediately.\n     * When either condition is verified, the cancellation cause will be set\n     * to the signal's abort reason (see {@link AbortSignal#reason}).\n     *\n     * Has no effect if called (or if the signal aborts) _after_ the promise has already settled.\n     * Only the first signal to abort will set the cancellation cause.\n     *\n     * For more details about the cancellation process,\n     * see {@link cancel} and the `CancellablePromise` constructor.\n     *\n     * This method enables `await`ing cancellable promises without having\n     * to store them for future cancellation, e.g.:\n     * ```ts\n     * await longRunningOperation().cancelOn(signal);\n     * ```\n     * instead of:\n     * ```ts\n     * let promiseToBeCancelled = longRunningOperation();\n     * await promiseToBeCancelled;\n     * ```\n     *\n     * @returns This promise, for method chaining.\n     */\n    cancelOn(signal: AbortSignal): CancellablePromise<T> {\n        if (signal.aborted) {\n            void this.cancel(signal.reason)\n        } else {\n            signal.addEventListener('abort', () => void this.cancel(signal.reason), {capture: true});\n        }\n\n        return this;\n    }\n\n    /**\n     * Attaches callbacks for the resolution and/or rejection of the `CancellablePromise`.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * @param onfulfilled The callback to execute when the Promise is resolved.\n     * @param onrejected The callback to execute when the Promise is rejected.\n     * @returns A `CancellablePromise` for the completion of whichever callback is executed.\n     * The returned promise is hooked up to propagate cancellation requests up the chain, but not down:\n     *\n     *   - if the parent promise is cancelled, the `onrejected` handler will be invoked with a `CancelError`\n     *     and the returned promise _will resolve regularly_ with its result;\n     *   - conversely, if the returned promise is cancelled, _the parent promise is cancelled too;_\n     *     the `onrejected` handler will still be invoked with the parent's `CancelError`,\n     *     but its result will be discarded\n     *     and the returned promise will reject with a `CancelError` as well.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If either callback returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     */\n    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1> | CancellablePromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2> | CancellablePromiseLike<TResult2>) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<TResult1 | TResult2> {\n        if (!(this instanceof CancellablePromise)) {\n            throw new TypeError(\"CancellablePromise.prototype.then called on an invalid object.\");\n        }\n\n        // NOTE: TypeScript's built-in type for then is broken,\n        // as it allows specifying an arbitrary TResult1 != T even when onfulfilled is not a function.\n        // We cannot fix it if we want to CancellablePromise to implement PromiseLike<T>.\n\n        if (!isCallable(onfulfilled)) { onfulfilled = identity as any; }\n        if (!isCallable(onrejected)) { onrejected = thrower; }\n\n        if (onfulfilled === identity && onrejected == thrower) {\n            // Shortcut for trivial arguments.\n            return new CancellablePromise((resolve) => resolve(this as any));\n        }\n\n        const barrier: Partial<PromiseWithResolvers<void>> = {};\n        this[barrierSym] = barrier;\n\n        return new CancellablePromise<TResult1 | TResult2>((resolve, reject) => {\n            void super.then(\n                (value) => {\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\n                    barrier.resolve?.();\n\n                    try {\n                        resolve(onfulfilled!(value));\n                    } catch (err) {\n                        reject(err);\n                    }\n                },\n                (reason?) => {\n                    if (this[barrierSym] === barrier) { this[barrierSym] = null; }\n                    barrier.resolve?.();\n\n                    try {\n                        resolve(onrejected!(reason));\n                    } catch (err) {\n                        reject(err);\n                    }\n                }\n            );\n        }, async (cause?) => {\n            //cancelled = true;\n            try {\n                return oncancelled?.(cause);\n            } finally {\n                await this.cancel(cause);\n            }\n        });\n    }\n\n    /**\n     * Attaches a callback for only the rejection of the Promise.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * When the parent promise rejects or is cancelled, the `onrejected` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * It is equivalent to\n     * ```ts\n     * cancellablePromise.then(undefined, onrejected, oncancelled);\n     * ```\n     * and the same caveats apply.\n     *\n     * @returns A Promise for the completion of the callback.\n     * Cancellation requests on the returned promise\n     * will propagate up the chain to the parent promise,\n     * but not in the other direction.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If `onrejected` returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     * See {@link then} for more details.\n     */\n    catch<TResult = never>(onrejected?: ((reason: any) => (PromiseLike<TResult> | TResult)) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T | TResult> {\n        return this.then(undefined, onrejected, oncancelled);\n    }\n\n    /**\n     * Attaches a callback that is invoked when the CancellablePromise is settled (fulfilled or rejected). The\n     * resolved value cannot be accessed or modified from the callback.\n     * The returned promise will settle in the same state as the original one\n     * after the provided callback has completed execution,\n     * unless the callback throws or returns a rejecting promise,\n     * in which case the returned promise will reject as well.\n     *\n     * The optional `oncancelled` argument will be invoked when the returned promise is cancelled,\n     * with the same semantics as the `oncancelled` argument of the constructor.\n     * Once the parent promise settles, the `onfinally` callback will run,\n     * _even after the returned promise has been cancelled:_\n     * in that case, should it reject or throw, the reason will be wrapped\n     * in a {@link CancelledRejectionError} and bubbled up as an unhandled rejection.\n     *\n     * This method is implemented in terms of {@link then} and the same caveats apply.\n     * It is polyfilled, hence available in every OS/webview version.\n     *\n     * @returns A Promise for the completion of the callback.\n     * Cancellation requests on the returned promise\n     * will propagate up the chain to the parent promise,\n     * but not in the other direction.\n     *\n     * The promise returned from {@link cancel} will fulfill only after all attached handlers\n     * up the entire promise chain have been run.\n     *\n     * If `onfinally` returns a cancellable promise,\n     * cancellation requests will be diverted to it,\n     * and the specified `oncancelled` callback will be discarded.\n     * See {@link then} for more details.\n     */\n    finally(onfinally?: (() => void) | undefined | null, oncancelled?: CancellablePromiseCanceller): CancellablePromise<T> {\n        if (!(this instanceof CancellablePromise)) {\n            throw new TypeError(\"CancellablePromise.prototype.finally called on an invalid object.\");\n        }\n\n        if (!isCallable(onfinally)) {\n            return this.then(onfinally, onfinally, oncancelled);\n        }\n\n        return this.then(\n            (value) => CancellablePromise.resolve(onfinally()).then(() => value),\n            (reason?) => CancellablePromise.resolve(onfinally()).then(() => { throw reason; }),\n            oncancelled,\n        );\n    }\n\n    /**\n     * We use the `[Symbol.species]` static property, if available,\n     * to disable the built-in automatic subclassing features from {@link Promise}.\n     * It is critical for performance reasons that extenders do not override this.\n     * Once the proposal at https://github.com/tc39/proposal-rm-builtin-subclassing\n     * is either accepted or retired, this implementation will have to be revised accordingly.\n     *\n     * @ignore\n     * @internal\n     */\n    static get [species]() {\n        return Promise;\n    }\n\n    /**\n     * Creates a CancellablePromise that is resolved with an array of results\n     * when all of the provided Promises resolve, or rejected when any Promise is rejected.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static all<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>[]>;\n    static all<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;\n    static all<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.all(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a CancellablePromise that is resolved with an array of results\n     * when all of the provided Promises resolve or reject.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static allSettled<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<PromiseSettledResult<Awaited<T>>[]>;\n    static allSettled<T extends readonly unknown[] | []>(values: T): CancellablePromise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;\n    static allSettled<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.allSettled(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * The any function returns a promise that is fulfilled by the first given promise to be fulfilled,\n     * or rejected with an AggregateError containing an array of rejection reasons\n     * if all of the given promises are rejected.\n     * It resolves all elements of the passed iterable to promises as it runs this algorithm.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static any<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\n    static any<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\n    static any<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = collected.length === 0\n            ? CancellablePromise.resolve(collected)\n            : new CancellablePromise<unknown>((resolve, reject) => {\n                void Promise.any(collected).then(resolve, reject);\n            }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved or rejected.\n     *\n     * Every one of the provided objects that is a thenable _and_ cancellable object\n     * will be cancelled when the returned promise is cancelled, with the same cause.\n     *\n     * @group Static Methods\n     */\n    static race<T>(values: Iterable<T | PromiseLike<T>>): CancellablePromise<Awaited<T>>;\n    static race<T extends readonly unknown[] | []>(values: T): CancellablePromise<Awaited<T[number]>>;\n    static race<T extends Iterable<unknown> | ArrayLike<unknown>>(values: T): CancellablePromise<unknown> {\n        let collected = Array.from(values);\n        const promise = new CancellablePromise<unknown>((resolve, reject) => {\n            void Promise.race(collected).then(resolve, reject);\n        }, (cause?): Promise<void> => cancelAll(promise, collected, cause));\n        return promise;\n    }\n\n    /**\n     * Creates a new cancelled CancellablePromise for the provided cause.\n     *\n     * @group Static Methods\n     */\n    static cancel<T = never>(cause?: any): CancellablePromise<T> {\n        const p = new CancellablePromise<T>(() => {});\n        p.cancel(cause);\n        return p;\n    }\n\n    /**\n     * Creates a new CancellablePromise that cancels\n     * after the specified timeout, with the provided cause.\n     *\n     * If the {@link AbortSignal.timeout} factory method is available,\n     * it is used to base the timeout on _active_ time rather than _elapsed_ time.\n     * Otherwise, `timeout` falls back to {@link setTimeout}.\n     *\n     * @group Static Methods\n     */\n    static timeout<T = never>(milliseconds: number, cause?: any): CancellablePromise<T> {\n        const promise = new CancellablePromise<T>(() => {});\n        if (AbortSignal && typeof AbortSignal === 'function' && AbortSignal.timeout && typeof AbortSignal.timeout === 'function') {\n            AbortSignal.timeout(milliseconds).addEventListener('abort', () => void promise.cancel(cause));\n        } else {\n            setTimeout(() => void promise.cancel(cause), milliseconds);\n        }\n        return promise;\n    }\n\n    /**\n     * Creates a new CancellablePromise that resolves after the specified timeout.\n     * The returned promise can be cancelled without consequences.\n     *\n     * @group Static Methods\n     */\n    static sleep(milliseconds: number): CancellablePromise<void>;\n    /**\n     * Creates a new CancellablePromise that resolves after\n     * the specified timeout, with the provided value.\n     * The returned promise can be cancelled without consequences.\n     *\n     * @group Static Methods\n     */\n    static sleep<T>(milliseconds: number, value: T): CancellablePromise<T>;\n    static sleep<T = void>(milliseconds: number, value?: T): CancellablePromise<T> {\n        return new CancellablePromise<T>((resolve) => {\n            setTimeout(() => resolve(value!), milliseconds);\n        });\n    }\n\n    /**\n     * Creates a new rejected CancellablePromise for the provided reason.\n     *\n     * @group Static Methods\n     */\n    static reject<T = never>(reason?: any): CancellablePromise<T> {\n        return new CancellablePromise<T>((_, reject) => reject(reason));\n    }\n\n    /**\n     * Creates a new resolved CancellablePromise.\n     *\n     * @group Static Methods\n     */\n    static resolve(): CancellablePromise<void>;\n    /**\n     * Creates a new resolved CancellablePromise for the provided value.\n     *\n     * @group Static Methods\n     */\n    static resolve<T>(value: T): CancellablePromise<Awaited<T>>;\n    /**\n     * Creates a new resolved CancellablePromise for the provided value.\n     *\n     * @group Static Methods\n     */\n    static resolve<T>(value: T | PromiseLike<T>): CancellablePromise<Awaited<T>>;\n    static resolve<T = void>(value?: T | PromiseLike<T>): CancellablePromise<Awaited<T>> {\n        if (value instanceof CancellablePromise) {\n            // Optimise for cancellable promises.\n            return value;\n        }\n        return new CancellablePromise<any>((resolve) => resolve(value));\n    }\n\n    /**\n     * Creates a new CancellablePromise and returns it in an object, along with its resolve and reject functions\n     * and a getter/setter for the cancellation callback.\n     *\n     * This method is polyfilled, hence available in every OS/webview version.\n     *\n     * @group Static Methods\n     */\n    static withResolvers<T>(): CancellablePromiseWithResolvers<T> {\n        let result: CancellablePromiseWithResolvers<T> = { oncancelled: null } as any;\n        result.promise = new CancellablePromise<T>((resolve, reject) => {\n            result.resolve = resolve;\n            result.reject = reject;\n        }, (cause?: any) => { result.oncancelled?.(cause); });\n        return result;\n    }\n}\n\n/**\n * Returns a callback that implements the cancellation algorithm for the given cancellable promise.\n * The promise returned from the resulting function does not reject.\n */\nfunction cancellerFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState) {\n    let cancellationPromise: void | PromiseLike<void> = undefined;\n\n    return (reason: CancelError): void | PromiseLike<void> => {\n        if (!state.settled) {\n            state.settled = true;\n            state.reason = reason;\n            promise.reject(reason);\n\n            // Attach an error handler that ignores this specific rejection reason and nothing else.\n            // In theory, a sane underlying implementation at this point\n            // should always reject with our cancellation reason,\n            // hence the handler will never throw.\n            void Promise.prototype.then.call(promise.promise, undefined, (err) => {\n                if (err !== reason) {\n                    throw err;\n                }\n            });\n        }\n\n        // If reason is not set, the promise resolved regularly, hence we must not call oncancelled.\n        // If oncancelled is unset, no need to go any further.\n        if (!state.reason || !promise.oncancelled) { return; }\n\n        cancellationPromise = new Promise<void>((resolve) => {\n            try {\n                resolve(promise.oncancelled!(state.reason!.cause));\n            } catch (err) {\n                Promise.reject(new CancelledRejectionError(promise.promise, err, \"Unhandled exception in oncancelled callback.\"));\n            }\n        }).catch((reason?) => {\n            Promise.reject(new CancelledRejectionError(promise.promise, reason, \"Unhandled rejection in oncancelled callback.\"));\n        });\n\n        // Unset oncancelled to prevent repeated calls.\n        promise.oncancelled = null;\n\n        return cancellationPromise;\n    }\n}\n\n/**\n * Returns a callback that implements the resolution algorithm for the given cancellable promise.\n */\nfunction resolverFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseResolver<T> {\n    return (value) => {\n        if (state.resolving) { return; }\n        state.resolving = true;\n\n        if (value === promise.promise) {\n            if (state.settled) { return; }\n            state.settled = true;\n            promise.reject(new TypeError(\"A promise cannot be resolved with itself.\"));\n            return;\n        }\n\n        if (value != null && (typeof value === 'object' || typeof value === 'function')) {\n            let then: any;\n            try {\n                then = (value as any).then;\n            } catch (err) {\n                state.settled = true;\n                promise.reject(err);\n                return;\n            }\n\n            if (isCallable(then)) {\n                try {\n                    let cancel = (value as any).cancel;\n                    if (isCallable(cancel)) {\n                        const oncancelled = (cause?: any) => {\n                            Reflect.apply(cancel, value, [cause]);\n                        };\n                        if (state.reason) {\n                            // If already cancelled, propagate cancellation.\n                            // The promise returned from the canceller algorithm does not reject\n                            // so it can be discarded safely.\n                            void cancellerFor({ ...promise, oncancelled }, state)(state.reason);\n                        } else {\n                            promise.oncancelled = oncancelled;\n                        }\n                    }\n                } catch {}\n\n                const newState: CancellablePromiseState = {\n                    root: state.root,\n                    resolving: false,\n                    get settled() { return this.root.settled },\n                    set settled(value) { this.root.settled = value; },\n                    get reason() { return this.root.reason }\n                };\n\n                const rejector = rejectorFor(promise, newState);\n                try {\n                    Reflect.apply(then, value, [resolverFor(promise, newState), rejector]);\n                } catch (err) {\n                    rejector(err);\n                }\n                return; // IMPORTANT!\n            }\n        }\n\n        if (state.settled) { return; }\n        state.settled = true;\n        promise.resolve(value);\n    };\n}\n\n/**\n * Returns a callback that implements the rejection algorithm for the given cancellable promise.\n */\nfunction rejectorFor<T>(promise: CancellablePromiseWithResolvers<T>, state: CancellablePromiseState): CancellablePromiseRejector {\n    return (reason?) => {\n        if (state.resolving) { return; }\n        state.resolving = true;\n\n        if (state.settled) {\n            try {\n                if (reason instanceof CancelError && state.reason instanceof CancelError && Object.is(reason.cause, state.reason.cause)) {\n                    // Swallow late rejections that are CancelErrors whose cancellation cause is the same as ours.\n                    return;\n                }\n            } catch {}\n\n            void Promise.reject(new CancelledRejectionError(promise.promise, reason));\n        } else {\n            state.settled = true;\n            promise.reject(reason);\n        }\n    }\n}\n\n/**\n * Cancels all values in an array that look like cancellable thenables.\n * Returns a promise that fulfills once all cancellation procedures for the given values have settled.\n */\nfunction cancelAll(parent: CancellablePromise<unknown>, values: any[], cause?: any): Promise<void> {\n    const results: Promise<void>[] = [];\n\n    for (const value of values) {\n        let cancel: CancellablePromiseCanceller;\n        try {\n            if (!isCallable(value.then)) { continue; }\n            cancel = value.cancel;\n            if (!isCallable(cancel)) { continue; }\n        } catch { continue; }\n\n        let result: void | PromiseLike<void>;\n        try {\n            result = Reflect.apply(cancel, value, [cause]);\n        } catch (err) {\n            Promise.reject(new CancelledRejectionError(parent, err, \"Unhandled exception in cancel method.\"));\n            continue;\n        }\n\n        if (!result) { continue; }\n        results.push(\n            (result instanceof Promise  ? result : Promise.resolve(result)).catch((reason?) => {\n                Promise.reject(new CancelledRejectionError(parent, reason, \"Unhandled rejection in cancel method.\"));\n            })\n        );\n    }\n\n    return Promise.all(results) as any;\n}\n\n/**\n * Returns its argument.\n */\nfunction identity<T>(x: T): T {\n    return x;\n}\n\n/**\n * Throws its argument.\n */\nfunction thrower(reason?: any): never {\n    throw reason;\n}\n\n/**\n * Attempts various strategies to convert an error to a string.\n */\nfunction errorMessage(err: any): string {\n    try {\n        if (err instanceof Error || typeof err !== 'object' || err.toString !== Object.prototype.toString) {\n            return \"\" + err;\n        }\n    } catch {}\n\n    try {\n        return JSON.stringify(err);\n    } catch {}\n\n    try {\n        return Object.prototype.toString.call(err);\n    } catch {}\n\n    return \"<could not convert error to string>\";\n}\n\n/**\n * Gets the current barrier promise for the given cancellable promise. If necessary, initialises the barrier.\n */\nfunction currentBarrier<T>(promise: CancellablePromise<T>): Promise<void> {\n    let pwr: Partial<PromiseWithResolvers<void>> = promise[barrierSym] ?? {};\n    if (!('promise' in pwr)) {\n        Object.assign(pwr, promiseWithResolvers<void>());\n    }\n    if (promise[barrierSym] == null) {\n        pwr.resolve!();\n        promise[barrierSym] = pwr;\n    }\n    return pwr.promise!;\n}\n\n// Polyfill Promise.withResolvers.\nlet promiseWithResolvers = Promise.withResolvers;\nif (promiseWithResolvers && typeof promiseWithResolvers === 'function') {\n    promiseWithResolvers = promiseWithResolvers.bind(Promise);\n} else {\n    promiseWithResolvers = function <T>(): PromiseWithResolvers<T> {\n        let resolve!: (value: T | PromiseLike<T>) => void;\n        let reject!: (reason?: any) => void;\n        const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });\n        return { promise, resolve, reject };\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {newRuntimeCaller, objectNames} from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Clipboard);\n\nconst ClipboardSetText = 0;\nconst ClipboardText = 1;\n\n/**\n * Sets the text to the Clipboard.\n *\n * @param text - The text to be set to the Clipboard.\n * @return A Promise that resolves when the operation is successful.\n */\nexport function SetText(text: string): Promise<void> {\n    return call(ClipboardSetText, {text});\n}\n\n/**\n * Get the Clipboard text\n *\n * @returns A promise that resolves with the text from the Clipboard.\n */\nexport function Text(): Promise<string> {\n    return call(ClipboardText);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nexport interface Size {\n    /** The width of a rectangular area. */\n    Width: number;\n    /** The height of a rectangular area. */\n    Height: number;\n}\n\nexport interface Rect {\n    /** The X coordinate of the origin. */\n    X: number;\n    /** The Y coordinate of the origin. */\n    Y: number;\n    /** The width of the rectangle. */\n    Width: number;\n    /** The height of the rectangle. */\n    Height: number;\n}\n\nexport interface Screen {\n    /** Unique identifier for the screen. */\n    ID: string;\n    /** Human-readable name of the screen. */\n    Name: string;\n    /** The scale factor of the screen (DPI/96). 1 = standard DPI, 2 = HiDPI (Retina), etc. */\n    ScaleFactor: number;\n    /** The X coordinate of the screen. */\n    X: number;\n    /** The Y coordinate of the screen. */\n    Y: number;\n    /** Contains the width and height of the screen. */\n    Size: Size;\n    /** Contains the bounds of the screen in terms of X, Y, Width, and Height. */\n    Bounds: Rect;\n    /** Contains the physical bounds of the screen in terms of X, Y, Width, and Height (before scaling). */\n    PhysicalBounds: Rect;\n    /** Contains the area of the screen that is actually usable (excluding taskbar and other system UI). */\n    WorkArea: Rect;\n    /** Contains the physical WorkArea of the screen (before scaling). */\n    PhysicalWorkArea: Rect;\n    /** True if this is the primary monitor selected by the user in the operating system. */\n    IsPrimary: boolean;\n    /** The rotation of the screen. */\n    Rotation: number;\n}\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\nconst call = newRuntimeCaller(objectNames.Screens);\n\nconst getAll = 0;\nconst getPrimary = 1;\nconst getCurrent = 2;\nconst getByID = 3;\nconst getByIndex = 4;\n\n/**\n * Gets all screens.\n *\n * @returns A promise that resolves to an array of Screen objects.\n */\nexport function GetAll(): Promise<Screen[]> {\n    return call(getAll);\n}\n\n/**\n * Gets the primary screen.\n *\n * @returns A promise that resolves to the primary screen.\n */\nexport function GetPrimary(): Promise<Screen> {\n    return call(getPrimary);\n}\n\n/**\n * Gets the current active screen.\n *\n * @returns A promise that resolves with the current active screen.\n */\nexport function GetCurrent(): Promise<Screen> {\n    return call(getCurrent);\n}\n\n/**\n * Gets a screen by its unique display ID.\n *\n * @param id - The unique identifier of the screen.\n * @returns A promise that resolves to the matching Screen.\n */\nexport function GetByID(id: string): Promise<Screen> {\n    return call(getByID, { id });\n}\n\n/**\n * Gets a screen by its index in the screen list.\n *\n * @param index - The zero-based index of the screen.\n * @returns A promise that resolves to the matching Screen.\n */\nexport function GetByIndex(index: number): Promise<Screen> {\n    return call(getByIndex, { index });\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.IOS);\n\n// Method IDs\nconst HapticsImpact = 0;\nconst DeviceInfo = 1;\n\nexport namespace Haptics {\n    export type ImpactStyle = \"light\"|\"medium\"|\"heavy\"|\"soft\"|\"rigid\";\n    export function Impact(style: ImpactStyle = \"medium\"): Promise<void> {\n        return call(HapticsImpact, { style });\n    }\n}\n\nexport namespace Device {\n    export interface Info {\n        model: string;\n        systemName: string;\n        systemVersion: string;\n        isSimulator: boolean;\n    }\n    export function Info(): Promise<Info> {\n        return call(DeviceInfo);\n    }\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport { newRuntimeCaller, objectNames } from \"./runtime.js\";\n\nconst call = newRuntimeCaller(objectNames.Android);\n\n// Method IDs (must match messageprocessor_android.go)\nconst HapticsVibrate = 0;\nconst DeviceInfo = 1;\nconst ToastShow = 2;\n\nexport namespace Haptics {\n    /** Vibrate the device for the given duration in milliseconds. */\n    export function Vibrate(durationMs: number = 100): Promise<void> {\n        return call(HapticsVibrate, { duration: durationMs });\n    }\n}\n\nexport namespace Device {\n    export interface Info {\n        platform: string;\n        manufacturer: string;\n        brand: string;\n        model: string;\n        device: string;\n        version: string;\n        sdkInt: number;\n    }\n    /** Return information about the Android device. */\n    export function Info(): Promise<Info> {\n        return call(DeviceInfo);\n    }\n}\n\nexport namespace Toast {\n    /** Show a short Android toast message. */\n    export function Show(message: string): Promise<void> {\n        return call(ToastShow, { message });\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Updater event name constants.\n *\n * Use these instead of hard-coding string literals when subscribing to\n * updater events from JavaScript:\n *\n *     import { Events, Updater } from \"@wailsio/runtime\";\n *\n *     Events.On(Updater.Events.UpdateAvailable, (e) => {\n *         console.log(\"update found:\", e.data.version);\n *     });\n *\n *     Events.On(Updater.Events.DownloadProgress, (e) => {\n *         const p = e.data;\n *         console.log(`${p.written} / ${p.total} bytes`);\n *     });\n *\n * Mirrors the Go-side constants in `pkg/updater/events.go` and the\n * user-action constants in `pkg/updater/window_lifecycle.go`. Any\n * changes here must stay in sync with those files \u2014 there's an\n * integration test that asserts the strings match.\n */\nexport const Events = Object.freeze({\n    /** A Check round-trip is starting. Payload: null. */\n    CheckStarted: \"wails:updater:check-started\",\n    /** Check found a newer release. Payload: Release. */\n    UpdateAvailable: \"wails:updater:update-available\",\n    /** Check confirmed the caller is up to date. Payload: null. */\n    NoUpdate: \"wails:updater:no-update\",\n    /** Download is starting. Payload: Release. */\n    DownloadStarted: \"wails:updater:download-started\",\n    /** Periodic progress tick during download (~10 Hz). Payload: Progress. */\n    DownloadProgress: \"wails:updater:download-progress\",\n    /** All bytes are on disk, but verification has not yet started. Payload: Release. */\n    DownloadComplete: \"wails:updater:download-complete\",\n    /** Signature / digest verification has started. Payload: Release. */\n    Verifying: \"wails:updater:verifying\",\n    /** The Updater is swapping the binary into place. Payload: Release. */\n    Installing: \"wails:updater:installing\",\n    /** Update is staged and a restart is pending. Payload: Release. */\n    UpdateReady: \"wails:updater:update-ready\",\n    /** Something failed. Payload: ErrorInfo { stage, message, provider }. */\n    Error: \"wails:updater:error\",\n    /** Host-side context delivered once per session. Payload: Meta { currentVersion, skippedVersion }. */\n    Meta: \"wails:updater:meta\",\n\n    /** Sub-namespace: user-action events that the UI emits BACK to the host. */\n    User: Object.freeze({\n        /** User clicked Install on an Available update. */\n        Install: \"wails:updater:user:install\",\n        /** User clicked Restart & Apply on a Ready update. */\n        Restart: \"wails:updater:user:restart\",\n        /** User clicked Skip This Version. */\n        Skip: \"wails:updater:user:skip\",\n        /** User clicked Remind Me Later. */\n        Remind: \"wails:updater:user:remind\",\n        /** User clicked Close / Cancel. */\n        Cancel: \"wails:updater:user:cancel\",\n    }),\n\n    /** Sub-namespace: framework-internal events the UI emits to coordinate\n     *  with the host. Most app code can ignore these. */\n    Window: Object.freeze({\n        /** The window finished loading and asks the host to replay current state. */\n        Ready: \"wails:updater:window:ready\",\n    }),\n});\n"],
  "mappings": "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",
  "names": ["_a", "Error", "call", "Error", "_a", "Array", "Map", "Array", "Map", "key", "call", "_a", "_a", "resizable", "_a", "call", "_a", "call", "_a", "_a", "call", "HideMethod", "ShowMethod", "isDocumentDotAll", "_a", "reason", "value", "call", "call", "call", "call", "Haptics", "Device", "Info", "Device", "Haptics", "call", "DeviceInfo", "Haptics", "Device", "Info", "Toast", "Show", "Events", "Events"]
}
 diff --git a/v3/internal/assetserver/bundledassets/runtime.js b/v3/internal/assetserver/bundledassets/runtime.js index cb897597d2c..217a6359e93 100644 --- a/v3/internal/assetserver/bundledassets/runtime.js +++ b/v3/internal/assetserver/bundledassets/runtime.js @@ -1 +1 @@ -var ln=Object.defineProperty,zn=Object.defineProperties;var Hn=Object.getOwnPropertyDescriptors;var an=Object.getOwnPropertySymbols;var Vn=Object.prototype.hasOwnProperty,Zn=Object.prototype.propertyIsEnumerable;var sn=(n,e,i)=>e in n?ln(n,e,{enumerable:!0,configurable:!0,writable:!0,value:i}):n[e]=i,N=(n,e)=>{for(var i in e||(e={}))Vn.call(e,i)&&sn(n,i,e[i]);if(an)for(var i of an(e))Zn.call(e,i)&&sn(n,i,e[i]);return n},j=(n,e)=>zn(n,Hn(e));var p=(n,e)=>{for(var i in e)ln(n,i,{get:e[i],enumerable:!0})};var Te={};p(Te,{Android:()=>on,Application:()=>Ne,Browser:()=>we,Call:()=>Ge,CancelError:()=>B,CancellablePromise:()=>Y,CancelledRejectionError:()=>D,Clipboard:()=>Ye,Create:()=>ge,Dialogs:()=>fe,Events:()=>be,Flags:()=>Re,IOS:()=>qe,Screens:()=>Xe,System:()=>Ae,Updater:()=>rn,WML:()=>Se,Window:()=>A,clientId:()=>x,getTransport:()=>un,loadOptionalScript:()=>jn,objectNames:()=>c,setTransport:()=>mn});var Se={};p(Se,{Enable:()=>Pe,Reload:()=>Pn});var we={};p(we,{OpenURL:()=>ue});var _n="useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";function M(n=21){let e="",i=n|0;for(;i--;)e+=_n[Math.random()*64|0];return e}var w=typeof window<"u"&&typeof document<"u";function Kn(){return window.location.origin+"/wails/runtime"}var z=512*1024;var c=Object.freeze({Call:0,Clipboard:1,Application:2,Events:3,ContextMenu:4,Dialog:5,Window:6,Screens:7,System:8,Browser:9,CancelCall:10,IOS:11,Android:12}),x=M(),H=null;function mn(n){H=n}function un(){return H}function u(n,e=""){return function(i,t=null){return Gn(n,i,e,t)}}async function Gn(n,e,i,t){var f,y;if(H)return H.call(n,e,i,t);let o=new URL(Kn()),a={object:n,method:e};t!=null&&(a.args=t);let r={"x-wails-client-id":x,"Content-Type":"application/json"};i&&(r["x-wails-window-name"]=i);let l=JSON.stringify(a),d;if(l.length>z?d=await Yn(o,r,l):d=await fetch(o,{method:"POST",headers:r,body:l}),!d.ok)throw new Error(await d.text());return((y=(f=d.headers.get("Content-Type"))==null?void 0:f.indexOf("application/json"))!=null?y:-1)!==-1?d.json():d.text()}async function Yn(n,e,i){let t=M(),o=new TextEncoder().encode(i),a=Math.ceil(o.length/z);for(let r=0;r<a-1;r++){let l=o.subarray(r*z,(r+1)*z),d=await fetch(n,{method:"POST",headers:j(N({},e),{"x-wails-chunk-id":t,"x-wails-chunk-index":String(r),"x-wails-chunk-total":String(a)}),body:l});if(!d.ok)throw new Error(await d.text())}return fetch(n,{method:"POST",headers:j(N({},e),{"x-wails-chunk-id":t,"x-wails-chunk-index":String(a-1),"x-wails-chunk-total":String(a)}),body:o.subarray((a-1)*z)})}var cn,dn=w&&typeof((cn=window.wails)==null?void 0:cn.invokeAsync)=="function"?window.wails:null;if(dn){let n=new Map;window._wailsAndroidCallback=(e,i,t)=>{var a;let o=n.get(e);if(o){if(n.delete(e),t){o.reject(new Error(t));return}try{let r=JSON.parse(i!=null?i:"{}");if(!r.ok){o.reject(new Error((a=r.error)!=null?a:"unknown runtime call error"));return}o.resolve("text"in r?r.text:r.data)}catch(r){o.reject(r)}}},H={call(e,i,t,o){return new Promise((a,r)=>{let l=M();n.set(l,{resolve:a,reject:r});try{dn.invokeAsync(l,JSON.stringify({object:e,method:i,windowName:t,args:o!=null?o:null,clientId:x}))}catch(d){n.delete(l),r(d)}})}}}var Xn=u(c.Browser),Jn=0;function ue(n){return Xn(Jn,{url:n.toString()})}var fe={};p(fe,{Error:()=>ai,Info:()=>oi,OpenFile:()=>si,Question:()=>pe,SaveFile:()=>li,Warning:()=>ri});w&&(window._wails=window._wails||{});var Qn=u(c.Dialog),qn=0,$n=1,ei=2,ni=3,ii=4,ti=5;function E(n,e={}){return Qn(n,e)}function oi(n){return E(qn,n)}function ri(n){return E($n,n)}function ai(n){return E(ei,n)}function pe(n){return E(ni,n)}function si(n){var e;return(e=E(ii,n))!=null?e:[]}function li(n){return E(ti,n)}var be={};p(be,{Emit:()=>We,Off:()=>yi,OffAll:()=>vi,On:()=>Wi,OnMultiple:()=>he,Once:()=>bi,Types:()=>pi,WailsEvent:()=>V});var g=new Map,q=class{constructor(e,i,t){this.eventName=e,this.callback=i,this.maxCallbacks=t||-1}dispatch(e){try{this.callback(e)}catch(i){}return this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0)}};function wn(n){let e=g.get(n.eventName);e&&(e=e.filter(i=>i!==n),e.length===0?g.delete(n.eventName):g.set(n.eventName,e))}var ge={};p(ge,{Any:()=>C,Array:()=>ci,ByteSlice:()=>di,Events:()=>$,Map:()=>mi,Nullable:()=>ui,Struct:()=>wi});function C(n){return n}function di(n){return n==null?"":n}function ci(n){return n===C?e=>e===null?[]:e:e=>{if(e===null)return[];for(let i=0;i<e.length;i++)e[i]=n(e[i]);return e}}function mi(n,e){return e===C?i=>i===null?{}:i:i=>{if(i===null)return{};for(let t in i)i[t]=e(i[t]);return i}}function ui(n){return n===C?C:e=>e===null?null:n(e)}function wi(n){let e=!0;for(let i in n)if(n[i]!==C){e=!1;break}return e?C:i=>{for(let t in n)t in i&&(i[t]=n[t](i[t]));return i}}var $={};var pi=Object.freeze({Windows:Object.freeze({APMPowerSettingChange:"windows:APMPowerSettingChange",APMPowerStatusChange:"windows:APMPowerStatusChange",APMResumeAutomatic:"windows:APMResumeAutomatic",APMResumeSuspend:"windows:APMResumeSuspend",APMSuspend:"windows:APMSuspend",ApplicationStarted:"windows:ApplicationStarted",SystemThemeChanged:"windows:SystemThemeChanged",WebViewNavigationCompleted:"windows:WebViewNavigationCompleted",WindowActive:"windows:WindowActive",WindowBackgroundErase:"windows:WindowBackgroundErase",WindowClickActive:"windows:WindowClickActive",WindowClosing:"windows:WindowClosing",WindowDidMove:"windows:WindowDidMove",WindowDidResize:"windows:WindowDidResize",WindowDPIChanged:"windows:WindowDPIChanged",WindowDragDrop:"windows:WindowDragDrop",WindowDragEnter:"windows:WindowDragEnter",WindowDragLeave:"windows:WindowDragLeave",WindowDragOver:"windows:WindowDragOver",WindowEndMove:"windows:WindowEndMove",WindowEndResize:"windows:WindowEndResize",WindowFullscreen:"windows:WindowFullscreen",WindowHide:"windows:WindowHide",WindowInactive:"windows:WindowInactive",WindowKeyDown:"windows:WindowKeyDown",WindowKeyUp:"windows:WindowKeyUp",WindowKillFocus:"windows:WindowKillFocus",WindowNonClientHit:"windows:WindowNonClientHit",WindowNonClientMouseDown:"windows:WindowNonClientMouseDown",WindowNonClientMouseLeave:"windows:WindowNonClientMouseLeave",WindowNonClientMouseMove:"windows:WindowNonClientMouseMove",WindowNonClientMouseUp:"windows:WindowNonClientMouseUp",WindowPaint:"windows:WindowPaint",WindowRestore:"windows:WindowRestore",WindowSetFocus:"windows:WindowSetFocus",WindowShow:"windows:WindowShow",WindowStartMove:"windows:WindowStartMove",WindowStartResize:"windows:WindowStartResize",WindowUnFullscreen:"windows:WindowUnFullscreen",WindowZOrderChanged:"windows:WindowZOrderChanged",WindowMinimise:"windows:WindowMinimise",WindowUnMinimise:"windows:WindowUnMinimise",WindowMaximise:"windows:WindowMaximise",WindowUnMaximise:"windows:WindowUnMaximise"}),Mac:Object.freeze({ApplicationDidBecomeActive:"mac:ApplicationDidBecomeActive",ApplicationDidChangeBackingProperties:"mac:ApplicationDidChangeBackingProperties",ApplicationDidChangeEffectiveAppearance:"mac:ApplicationDidChangeEffectiveAppearance",ApplicationDidChangeIcon:"mac:ApplicationDidChangeIcon",ApplicationDidChangeOcclusionState:"mac:ApplicationDidChangeOcclusionState",ApplicationDidChangeScreenParameters:"mac:ApplicationDidChangeScreenParameters",ApplicationDidChangeStatusBarFrame:"mac:ApplicationDidChangeStatusBarFrame",ApplicationDidChangeStatusBarOrientation:"mac:ApplicationDidChangeStatusBarOrientation",ApplicationDidChangeTheme:"mac:ApplicationDidChangeTheme",ApplicationDidFinishLaunching:"mac:ApplicationDidFinishLaunching",ApplicationDidHide:"mac:ApplicationDidHide",ApplicationDidResignActive:"mac:ApplicationDidResignActive",ApplicationDidUnhide:"mac:ApplicationDidUnhide",ApplicationDidUpdate:"mac:ApplicationDidUpdate",ApplicationDidWake:"mac:ApplicationDidWake",ApplicationScreensDidSleep:"mac:ApplicationScreensDidSleep",ApplicationScreensDidWake:"mac:ApplicationScreensDidWake",ApplicationShouldHandleReopen:"mac:ApplicationShouldHandleReopen",ApplicationWillBecomeActive:"mac:ApplicationWillBecomeActive",ApplicationWillFinishLaunching:"mac:ApplicationWillFinishLaunching",ApplicationWillHide:"mac:ApplicationWillHide",ApplicationWillResignActive:"mac:ApplicationWillResignActive",ApplicationWillSleep:"mac:ApplicationWillSleep",ApplicationWillTerminate:"mac:ApplicationWillTerminate",ApplicationWillUnhide:"mac:ApplicationWillUnhide",ApplicationWillUpdate:"mac:ApplicationWillUpdate",MenuDidAddItem:"mac:MenuDidAddItem",MenuDidBeginTracking:"mac:MenuDidBeginTracking",MenuDidClose:"mac:MenuDidClose",MenuDidDisplayItem:"mac:MenuDidDisplayItem",MenuDidEndTracking:"mac:MenuDidEndTracking",MenuDidHighlightItem:"mac:MenuDidHighlightItem",MenuDidOpen:"mac:MenuDidOpen",MenuDidPopUp:"mac:MenuDidPopUp",MenuDidRemoveItem:"mac:MenuDidRemoveItem",MenuDidSendAction:"mac:MenuDidSendAction",MenuDidSendActionToItem:"mac:MenuDidSendActionToItem",MenuDidUpdate:"mac:MenuDidUpdate",MenuWillAddItem:"mac:MenuWillAddItem",MenuWillBeginTracking:"mac:MenuWillBeginTracking",MenuWillDisplayItem:"mac:MenuWillDisplayItem",MenuWillEndTracking:"mac:MenuWillEndTracking",MenuWillHighlightItem:"mac:MenuWillHighlightItem",MenuWillOpen:"mac:MenuWillOpen",MenuWillPopUp:"mac:MenuWillPopUp",MenuWillRemoveItem:"mac:MenuWillRemoveItem",MenuWillSendAction:"mac:MenuWillSendAction",MenuWillSendActionToItem:"mac:MenuWillSendActionToItem",MenuWillUpdate:"mac:MenuWillUpdate",WebViewDidCommitNavigation:"mac:WebViewDidCommitNavigation",WebViewDidFinishNavigation:"mac:WebViewDidFinishNavigation",WebViewDidReceiveServerRedirectForProvisionalNavigation:"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation",WebViewDidStartProvisionalNavigation:"mac:WebViewDidStartProvisionalNavigation",WindowDidBecomeKey:"mac:WindowDidBecomeKey",WindowDidBecomeMain:"mac:WindowDidBecomeMain",WindowDidBeginSheet:"mac:WindowDidBeginSheet",WindowDidChangeAlpha:"mac:WindowDidChangeAlpha",WindowDidChangeBackingLocation:"mac:WindowDidChangeBackingLocation",WindowDidChangeBackingProperties:"mac:WindowDidChangeBackingProperties",WindowDidChangeCollectionBehavior:"mac:WindowDidChangeCollectionBehavior",WindowDidChangeEffectiveAppearance:"mac:WindowDidChangeEffectiveAppearance",WindowDidChangeOcclusionState:"mac:WindowDidChangeOcclusionState",WindowDidChangeOrderingMode:"mac:WindowDidChangeOrderingMode",WindowDidChangeScreen:"mac:WindowDidChangeScreen",WindowDidChangeScreenParameters:"mac:WindowDidChangeScreenParameters",WindowDidChangeScreenProfile:"mac:WindowDidChangeScreenProfile",WindowDidChangeScreenSpace:"mac:WindowDidChangeScreenSpace",WindowDidChangeScreenSpaceProperties:"mac:WindowDidChangeScreenSpaceProperties",WindowDidChangeSharingType:"mac:WindowDidChangeSharingType",WindowDidChangeSpace:"mac:WindowDidChangeSpace",WindowDidChangeSpaceOrderingMode:"mac:WindowDidChangeSpaceOrderingMode",WindowDidChangeTitle:"mac:WindowDidChangeTitle",WindowDidChangeToolbar:"mac:WindowDidChangeToolbar",WindowDidDeminiaturize:"mac:WindowDidDeminiaturize",WindowDidEndSheet:"mac:WindowDidEndSheet",WindowDidEnterFullScreen:"mac:WindowDidEnterFullScreen",WindowDidEnterVersionBrowser:"mac:WindowDidEnterVersionBrowser",WindowDidExitFullScreen:"mac:WindowDidExitFullScreen",WindowDidExitVersionBrowser:"mac:WindowDidExitVersionBrowser",WindowDidExpose:"mac:WindowDidExpose",WindowDidFocus:"mac:WindowDidFocus",WindowDidMiniaturize:"mac:WindowDidMiniaturize",WindowDidMove:"mac:WindowDidMove",WindowDidOrderOffScreen:"mac:WindowDidOrderOffScreen",WindowDidOrderOnScreen:"mac:WindowDidOrderOnScreen",WindowDidResignKey:"mac:WindowDidResignKey",WindowDidResignMain:"mac:WindowDidResignMain",WindowDidResize:"mac:WindowDidResize",WindowDidUpdate:"mac:WindowDidUpdate",WindowDidUpdateAlpha:"mac:WindowDidUpdateAlpha",WindowDidUpdateCollectionBehavior:"mac:WindowDidUpdateCollectionBehavior",WindowDidUpdateCollectionProperties:"mac:WindowDidUpdateCollectionProperties",WindowDidUpdateShadow:"mac:WindowDidUpdateShadow",WindowDidUpdateTitle:"mac:WindowDidUpdateTitle",WindowDidUpdateToolbar:"mac:WindowDidUpdateToolbar",WindowDidZoom:"mac:WindowDidZoom",WindowFileDraggingEntered:"mac:WindowFileDraggingEntered",WindowFileDraggingExited:"mac:WindowFileDraggingExited",WindowFileDraggingPerformed:"mac:WindowFileDraggingPerformed",WindowHide:"mac:WindowHide",WindowMaximise:"mac:WindowMaximise",WindowUnMaximise:"mac:WindowUnMaximise",WindowMinimise:"mac:WindowMinimise",WindowUnMinimise:"mac:WindowUnMinimise",WindowShouldClose:"mac:WindowShouldClose",WindowShow:"mac:WindowShow",WindowWillBecomeKey:"mac:WindowWillBecomeKey",WindowWillBecomeMain:"mac:WindowWillBecomeMain",WindowWillBeginSheet:"mac:WindowWillBeginSheet",WindowWillChangeOrderingMode:"mac:WindowWillChangeOrderingMode",WindowWillClose:"mac:WindowWillClose",WindowWillDeminiaturize:"mac:WindowWillDeminiaturize",WindowWillEnterFullScreen:"mac:WindowWillEnterFullScreen",WindowWillEnterVersionBrowser:"mac:WindowWillEnterVersionBrowser",WindowWillExitFullScreen:"mac:WindowWillExitFullScreen",WindowWillExitVersionBrowser:"mac:WindowWillExitVersionBrowser",WindowWillFocus:"mac:WindowWillFocus",WindowWillMiniaturize:"mac:WindowWillMiniaturize",WindowWillMove:"mac:WindowWillMove",WindowWillOrderOffScreen:"mac:WindowWillOrderOffScreen",WindowWillOrderOnScreen:"mac:WindowWillOrderOnScreen",WindowWillResignMain:"mac:WindowWillResignMain",WindowWillResize:"mac:WindowWillResize",WindowWillUnfocus:"mac:WindowWillUnfocus",WindowWillUpdate:"mac:WindowWillUpdate",WindowWillUpdateAlpha:"mac:WindowWillUpdateAlpha",WindowWillUpdateCollectionBehavior:"mac:WindowWillUpdateCollectionBehavior",WindowWillUpdateCollectionProperties:"mac:WindowWillUpdateCollectionProperties",WindowWillUpdateShadow:"mac:WindowWillUpdateShadow",WindowWillUpdateTitle:"mac:WindowWillUpdateTitle",WindowWillUpdateToolbar:"mac:WindowWillUpdateToolbar",WindowWillUpdateVisibility:"mac:WindowWillUpdateVisibility",WindowWillUseStandardFrame:"mac:WindowWillUseStandardFrame",WindowZoomIn:"mac:WindowZoomIn",WindowZoomOut:"mac:WindowZoomOut",WindowZoomReset:"mac:WindowZoomReset"}),Linux:Object.freeze({ApplicationStartup:"linux:ApplicationStartup",SystemDidWake:"linux:SystemDidWake",SystemThemeChanged:"linux:SystemThemeChanged",SystemWillSleep:"linux:SystemWillSleep",WindowDeleteEvent:"linux:WindowDeleteEvent",WindowDidMove:"linux:WindowDidMove",WindowDidResize:"linux:WindowDidResize",WindowFocusIn:"linux:WindowFocusIn",WindowFocusOut:"linux:WindowFocusOut",WindowLoadStarted:"linux:WindowLoadStarted",WindowLoadRedirected:"linux:WindowLoadRedirected",WindowLoadCommitted:"linux:WindowLoadCommitted",WindowLoadFinished:"linux:WindowLoadFinished"}),iOS:Object.freeze({ApplicationDidBecomeActive:"ios:ApplicationDidBecomeActive",ApplicationDidEnterBackground:"ios:ApplicationDidEnterBackground",ApplicationDidFinishLaunching:"ios:ApplicationDidFinishLaunching",ApplicationDidReceiveMemoryWarning:"ios:ApplicationDidReceiveMemoryWarning",ApplicationWillEnterForeground:"ios:ApplicationWillEnterForeground",ApplicationWillResignActive:"ios:ApplicationWillResignActive",ApplicationWillTerminate:"ios:ApplicationWillTerminate",WindowDidLoad:"ios:WindowDidLoad",WindowWillAppear:"ios:WindowWillAppear",WindowDidAppear:"ios:WindowDidAppear",WindowWillDisappear:"ios:WindowWillDisappear",WindowDidDisappear:"ios:WindowDidDisappear",WindowSafeAreaInsetsChanged:"ios:WindowSafeAreaInsetsChanged",WindowOrientationChanged:"ios:WindowOrientationChanged",WindowTouchBegan:"ios:WindowTouchBegan",WindowTouchMoved:"ios:WindowTouchMoved",WindowTouchEnded:"ios:WindowTouchEnded",WindowTouchCancelled:"ios:WindowTouchCancelled",WebViewDidStartNavigation:"ios:WebViewDidStartNavigation",WebViewDidFinishNavigation:"ios:WebViewDidFinishNavigation",WebViewDidFailNavigation:"ios:WebViewDidFailNavigation",WebViewDecidePolicyForNavigationAction:"ios:WebViewDecidePolicyForNavigationAction",BatteryChanged:"ios:BatteryChanged",NetworkChanged:"ios:NetworkChanged",ThemeChanged:"ios:ThemeChanged",ScreenLocked:"ios:ScreenLocked",ScreenUnlocked:"ios:ScreenUnlocked"}),Android:Object.freeze({ActivityCreated:"android:ActivityCreated",ActivityStarted:"android:ActivityStarted",ActivityResumed:"android:ActivityResumed",ActivityPaused:"android:ActivityPaused",ActivityStopped:"android:ActivityStopped",ActivityDestroyed:"android:ActivityDestroyed",ApplicationLowMemory:"android:ApplicationLowMemory",WebViewPageStarted:"android:WebViewPageStarted",WebViewPageFinished:"android:WebViewPageFinished",BatteryChanged:"android:BatteryChanged",NetworkChanged:"android:NetworkChanged",ThemeChanged:"android:ThemeChanged",ScreenLocked:"android:ScreenLocked",ScreenUnlocked:"android:ScreenUnlocked"}),Common:Object.freeze({ApplicationOpenedWithFile:"common:ApplicationOpenedWithFile",ApplicationStarted:"common:ApplicationStarted",ApplicationLaunchedWithUrl:"common:ApplicationLaunchedWithUrl",ThemeChanged:"common:ThemeChanged",SystemDidWake:"common:SystemDidWake",SystemWillSleep:"common:SystemWillSleep",WindowClosing:"common:WindowClosing",WindowDidMove:"common:WindowDidMove",WindowDidResize:"common:WindowDidResize",WindowDPIChanged:"common:WindowDPIChanged",WindowFilesDropped:"common:WindowFilesDropped",WindowFocus:"common:WindowFocus",WindowFullscreen:"common:WindowFullscreen",WindowHide:"common:WindowHide",WindowLostFocus:"common:WindowLostFocus",WindowMaximise:"common:WindowMaximise",WindowMinimise:"common:WindowMinimise",WindowToggleFrameless:"common:WindowToggleFrameless",WindowRestore:"common:WindowRestore",WindowRuntimeReady:"common:WindowRuntimeReady",WindowShow:"common:WindowShow",WindowUnFullscreen:"common:WindowUnFullscreen",WindowUnMaximise:"common:WindowUnMaximise",WindowUnMinimise:"common:WindowUnMinimise",WindowZoom:"common:WindowZoom",WindowZoomIn:"common:WindowZoomIn",WindowZoomOut:"common:WindowZoomOut",WindowZoomReset:"common:WindowZoomReset",BatteryChanged:"common:BatteryChanged",NetworkChanged:"common:NetworkChanged",ScreenLocked:"common:ScreenLocked",ScreenUnlocked:"common:ScreenUnlocked",LowMemory:"common:LowMemory"})});w&&(window._wails=window._wails||{},window._wails.dispatchWailsEvent=hi);var fi=u(c.Events),gi=0,V=class{constructor(e,i){this.name=e,this.data=i!=null?i:null}};function hi(n){let e=g.get(n.name);if(!e)return;let i=new V(n.name,n.name in $?$[n.name](n.data):n.data);"sender"in n&&(i.sender=n.sender);let t=new Set;for(let o of e.slice())o.dispatch(i)&&t.add(o);if(t.size>0){let o=g.get(n.name);if(o){let a=o.filter(r=>!t.has(r));a.length===0?g.delete(n.name):g.set(n.name,a)}}}function he(n,e,i){let t=g.get(n)||[],o=new q(n,e,i);return t.push(o),g.set(n,t),()=>wn(o)}function Wi(n,e){return he(n,e,-1)}function bi(n,e){return he(n,e,1)}function yi(...n){n.forEach(e=>g.delete(e))}function vi(){g.clear()}function We(n,e){return fi(gi,new V(n,e))}function pn(){return new MouseEvent("mousedown").buttons===0}function fn(){if(!EventTarget||!AbortSignal||!AbortController)return!1;let n=!0,e=new EventTarget,i=new AbortController;return e.addEventListener("test",()=>{n=!1},{signal:i.signal}),i.abort(),e.dispatchEvent(new CustomEvent("test")),n}function ee(n){var e;return n.target instanceof HTMLElement?n.target:!(n.target instanceof HTMLElement)&&n.target instanceof Node&&(e=n.target.parentElement)!=null?e:document.body}var gn=!1;w&&document.addEventListener("DOMContentLoaded",()=>{gn=!0});function hn(n){gn||document.readyState==="complete"?n():document.addEventListener("DOMContentLoaded",n)}var Di="data-file-drop-target",W="file-drop-target-active",m=null,Ci=0,Pi=1,Si=2,Ti=3,Mi=4,xi=5,Ei=6,Ai=7,Ri=8,ki=9,Oi=10,Fi=11,Li=12,Ii=13,Ui=14,Bi=15,Ni=16,ji=17,zi=18,Hi=19,Vi=20,Zi=21,_i=22,Ki=23,Gi=24,Yi=25,Xi=26,Ji=27,Qi=28,qi=29,$i=30,et=31,nt=32,it=33,tt=34,ot=35,rt=36,at=37,st=38,lt=39,dt=40,ct=41,mt=42,ut=43,wt=44,pt=45,ft=46,gt=47,ht=48,Wt=49,bt=50,yt=51,vt=52;function ne(n){return n?n.closest("[".concat(Di,"]")):null}function Dt(){var n,e,i,t;return((e=(n=window.chrome)==null?void 0:n.webview)==null?void 0:e.postMessageWithAdditionalObjects)==null?!1:((t=(i=window._wails)==null?void 0:i.flags)==null?void 0:t.enableFileDrop)===!0}function Ct(n,e,i){var t,o;(o=(t=window.chrome)==null?void 0:t.webview)!=null&&o.postMessageWithAdditionalObjects&&window.chrome.webview.postMessageWithAdditionalObjects("file:drop:".concat(n,":").concat(e),i)}var ve=!1;function Wn(){ve=!1,m&&(m.classList.remove(W),m=null)}function bn(){var n,e;((e=(n=window._wails)==null?void 0:n.flags)==null?void 0:e.enableFileDrop)!==!1&&(ve=!0)}function yn(){Wn()}function vn(n,e){var o,a;if(!ve||((a=(o=window._wails)==null?void 0:o.flags)==null?void 0:a.enableFileDrop)===!1)return;let i=document.elementFromPoint(n,e),t=ne(i);m&&m!==t&&m.classList.remove(W),t?(t.classList.add(W),m=t):m=null}var s=Symbol("caller"),ie=class ie{constructor(e=""){this[s]=u(c.Window,e);for(let i of Object.getOwnPropertyNames(ie.prototype))i!=="constructor"&&typeof this[i]=="function"&&(this[i]=this[i].bind(this))}Get(e){return new ie(e)}Position(){return this[s](Ci)}Center(){return this[s](Pi)}Close(){return this[s](Si)}DisableSizeConstraints(){return this[s](Ti)}EnableSizeConstraints(){return this[s](Mi)}Focus(){return this[s](xi)}ForceReload(){return this[s](Ei)}Fullscreen(){return this[s](Ai)}GetScreen(){return this[s](Ri)}GetZoom(){return this[s](ki)}Height(){return this[s](Oi)}Hide(){return this[s](Fi)}IsFocused(){return this[s](Li)}IsFullscreen(){return this[s](Ii)}IsMaximised(){return this[s](Ui)}IsMinimised(){return this[s](Bi)}Maximise(){return this[s](Ni)}Minimise(){return this[s](ji)}Name(){return this[s](zi)}OpenDevTools(){return this[s](Hi)}RelativePosition(){return this[s](Vi)}Reload(){return this[s](Zi)}Resizable(){return this[s](_i)}Restore(){return this[s](Ki)}SetPosition(e,i){return this[s](Gi,{x:e,y:i})}SetAlwaysOnTop(e){return this[s](Yi,{alwaysOnTop:e})}SetBackgroundColour(e,i,t,o){return this[s](Xi,{r:e,g:i,b:t,a:o})}SetFrameless(e){return this[s](Ji,{frameless:e})}SetFullscreenButtonEnabled(e){return this[s](Qi,{enabled:e})}SetMaxSize(e,i){return this[s](qi,{width:e,height:i})}SetMinSize(e,i){return this[s]($i,{width:e,height:i})}SetRelativePosition(e,i){return this[s](et,{x:e,y:i})}SetResizable(e){return this[s](nt,{resizable:e})}SetSize(e,i){return this[s](it,{width:e,height:i})}SetTitle(e){return this[s](tt,{title:e})}SetZoom(e){return this[s](ot,{zoom:e})}Show(){return this[s](rt)}Size(){return this[s](at)}ToggleFullscreen(){return this[s](st)}ToggleMaximise(){return this[s](lt)}ToggleFrameless(){return this[s](dt)}UnFullscreen(){return this[s](ct)}UnMaximise(){return this[s](mt)}UnMinimise(){return this[s](ut)}Width(){return this[s](wt)}Zoom(){return this[s](pt)}ZoomIn(){return this[s](ft)}ZoomOut(){return this[s](gt)}ZoomReset(){return this[s](ht)}HandlePlatformFileDrop(e,i,t){var d,f;if(((f=(d=window._wails)==null?void 0:d.flags)==null?void 0:f.enableFileDrop)===!1)return;let o=document.elementFromPoint(i,t),a=ne(o);if(!a)return;let r={id:a.id,classList:Array.from(a.classList),attributes:{}};for(let y=0;y<a.attributes.length;y++){let Q=a.attributes[y];r.attributes[Q.name]=Q.value}let l={filenames:e,x:i,y:t,elementDetails:r};this[s](bt,l),Wn()}SetScreen(e){return this[s](vt,{screenID:e})}SnapAssist(){return this[s](Wt)}Print(){return this[s](yt)}},ye=ie,Pt=new ye("");function St(){let n=document.documentElement,e=0;n.addEventListener("dragenter",i=>{var a,r,l;if(!((a=i.dataTransfer)!=null&&a.types.includes("Files")))return;if(i.preventDefault(),((l=(r=window._wails)==null?void 0:r.flags)==null?void 0:l.enableFileDrop)===!1){i.dataTransfer.dropEffect="none";return}e++;let t=document.elementFromPoint(i.clientX,i.clientY),o=ne(t);m&&m!==o&&m.classList.remove(W),o?(o.classList.add(W),i.dataTransfer.dropEffect="copy",m=o):(i.dataTransfer.dropEffect="none",m=null)},!1),n.addEventListener("dragover",i=>{var a,r,l;if(!((a=i.dataTransfer)!=null&&a.types.includes("Files")))return;if(i.preventDefault(),((l=(r=window._wails)==null?void 0:r.flags)==null?void 0:l.enableFileDrop)===!1){i.dataTransfer.dropEffect="none";return}let t=document.elementFromPoint(i.clientX,i.clientY),o=ne(t);m&&m!==o&&m.classList.remove(W),o?(o.classList.contains(W)||o.classList.add(W),i.dataTransfer.dropEffect="copy",m=o):(i.dataTransfer.dropEffect="none",m=null)},!1),n.addEventListener("dragleave",i=>{var t,o,a;(t=i.dataTransfer)!=null&&t.types.includes("Files")&&(i.preventDefault(),((a=(o=window._wails)==null?void 0:o.flags)==null?void 0:a.enableFileDrop)!==!1&&i.relatedTarget!==null&&(e--,(e===0||m&&!m.contains(i.relatedTarget))&&(m&&(m.classList.remove(W),m=null),e=0)))},!1),n.addEventListener("drop",i=>{var t,o,a;if((t=i.dataTransfer)!=null&&t.types.includes("Files")&&(i.preventDefault(),((a=(o=window._wails)==null?void 0:o.flags)==null?void 0:a.enableFileDrop)!==!1&&(e=0,m&&(m.classList.remove(W),m=null),Dt()))){let r=[];if(i.dataTransfer.items){for(let l of i.dataTransfer.items)if(l.kind==="file"){let d=l.getAsFile();d&&r.push(d)}}else if(i.dataTransfer.files)for(let l of i.dataTransfer.files)r.push(l);r.length>0&&Ct(i.clientX,i.clientY,r)}},!1)}typeof window<"u"&&typeof document<"u"&&St();var A=Pt;function Tt(n,e=null){We(n,e)}function Mt(n,e){let i=A.Get(n),t=i[e];if(typeof t=="function")try{t.call(i)}catch(o){}}function Dn(n){let e=n.currentTarget;function i(o="Yes"){if(o!=="Yes")return;let a=e.getAttribute("wml-event")||e.getAttribute("data-wml-event"),r=e.getAttribute("wml-target-window")||e.getAttribute("data-wml-target-window")||"",l=e.getAttribute("wml-window")||e.getAttribute("data-wml-window"),d=e.getAttribute("wml-openurl")||e.getAttribute("data-wml-openurl");a!==null&&Tt(a),l!==null&&Mt(r,l),d!==null&&ue(d)}let t=e.getAttribute("wml-confirm")||e.getAttribute("data-wml-confirm");t?pe({Title:"Confirm",Message:t,Detached:!1,Buttons:[{Label:"Yes"},{Label:"No",IsDefault:!0}]}).then(i):i()}var Z=Symbol("controller"),R=Symbol("triggerMap"),P=Symbol("elementCount"),De=class{constructor(){this[Z]=new AbortController}set(e,i){return{signal:this[Z].signal}}reset(){this[Z].abort(),this[Z]=new AbortController}},Ce=class{constructor(){this[R]=new WeakMap,this[P]=0}set(e,i){return this[R].has(e)||this[P]++,this[R].set(e,i),{}}reset(){if(!(this[P]<=0)){for(let e of document.body.querySelectorAll("*")){if(this[P]<=0)break;let i=this[R].get(e);i!=null&&this[P]--;for(let t of i||[])e.removeEventListener(t,Dn)}this[R]=new WeakMap,this[P]=0}}},Cn=fn()?new De:new Ce;function xt(n){let e=/\S+/g,i=n.getAttribute("wml-trigger")||n.getAttribute("data-wml-trigger")||"click",t=[],o;for(;(o=e.exec(i))!==null;)t.push(o[0]);let a=Cn.set(n,t);for(let r of t)n.addEventListener(r,Dn,a)}function Pe(){hn(Pn)}function Pn(){Cn.reset(),document.body.querySelectorAll("[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]").forEach(xt)}window.wails=Te;Pe();var Ae={};p(Ae,{Capabilities:()=>Ot,Environment:()=>Ft,IsAMD64:()=>Ut,IsARM:()=>Bt,IsARM64:()=>Nt,IsAndroid:()=>Mn,IsDarkMode:()=>kt,IsDebug:()=>Ee,IsDesktop:()=>It,IsIOS:()=>Tn,IsLinux:()=>te,IsMac:()=>Sn,IsMobile:()=>Lt,IsWindows:()=>_,invoke:()=>S});var xe=u(c.System),Et=0,At=1,Rt=2,Me=(function(){var n,e,i,t,o,a;try{if((e=(n=window.chrome)==null?void 0:n.webview)!=null&&e.postMessage)return window.chrome.webview.postMessage.bind(window.chrome.webview);if((o=(t=(i=window.webkit)==null?void 0:i.messageHandlers)==null?void 0:t.external)!=null&&o.postMessage)return window.webkit.messageHandlers.external.postMessage.bind(window.webkit.messageHandlers.external);if((a=window.wails)!=null&&a.invoke)return r=>window.wails.invoke(typeof r=="string"?r:JSON.stringify(r))}catch(r){}return null})();function S(n){Me==null||Me(n)}function kt(){return xe(Et)}async function Ot(){return xe(Rt)}function Ft(){return xe(At)}function _(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="windows"}function te(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="linux"}function Sn(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="darwin"}function Tn(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="ios"}function Mn(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="android"}function Lt(){return Tn()||Mn()}function It(){return Sn()||_()||te()}function Ut(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="amd64"}function Bt(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="arm"}function Nt(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="arm64"}function Ee(){var n,e;return!!((e=(n=window._wails)==null?void 0:n.environment)!=null&&e.Debug)}w&&window.addEventListener("contextmenu",Vt);var jt=u(c.ContextMenu),zt=0;function Ht(n,e,i,t){jt(zt,{id:n,x:e,y:i,data:t})}function Vt(n){let e=ee(n),i=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu").trim();if(i){n.preventDefault();let t=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu-data");Ht(i,n.clientX,n.clientY,t)}else Zt(n,e)}function Zt(n,e){if(Ee())return;switch(window.getComputedStyle(e).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":n.preventDefault();return}if(e.isContentEditable)return;let i=window.getSelection(),t=i&&i.toString().length>0;if(t)for(let o=0;o<i.rangeCount;o++){let r=i.getRangeAt(o).getClientRects();for(let l=0;l<r.length;l++){let d=r[l];if(document.elementFromPoint(d.left,d.top)===e)return}}(e instanceof HTMLInputElement||e instanceof HTMLTextAreaElement)&&(t||!e.readOnly&&!e.disabled)||n.preventDefault()}var Re={};p(Re,{GetFlag:()=>k});function k(n){try{return window._wails.flags[n]}catch(e){throw new Error("Unable to retrieve flag '"+n+"': "+e,{cause:e})}}var K=!1,G=!1,Ie=!1,F=!1,L=!1,T="",xn="auto",O=0,oe=!1;w&&(oe=pn(),window._wails=window._wails||{},window._wails.setResizable=n=>{Ie=n,Ie||(F=L=!1,h())});var Ue=!1;function _t(){var i,t;let n=(t=(i=window._wails)==null?void 0:i.environment)==null?void 0:t.OS;if(n==="ios"||n==="android")return!0;let e=navigator.userAgent||navigator.vendor||window.opera||"";return/android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(e)}function ke(){if(!Ue&&!_t()){window.addEventListener("mousedown",Le,{capture:!0}),window.addEventListener("mousemove",Le,{capture:!0}),window.addEventListener("mouseup",Le,{capture:!0});for(let n of["click","contextmenu","dblclick"])window.addEventListener(n,Kt,{capture:!0});Ue=!0}}if(w){ke(),document.addEventListener("DOMContentLoaded",ke,{once:!0});let n=0,e=window.setInterval(()=>{if(Ue){window.clearInterval(e);return}ke(),++n>100&&window.clearInterval(e)},50)}function Kt(n){(G||L)&&(n.stopImmediatePropagation(),n.stopPropagation(),n.preventDefault())}var Oe=0,Gt=1,Fe=2;function Le(n){let e,i=n.buttons;switch(n.type){case"mousedown":e=Oe,oe||(i=O|1<<n.button);break;case"mouseup":e=Gt,oe||(i=O&~(1<<n.button));break;default:e=Fe,oe||(i=O);break}let t=O&~i,o=i&~O;O=i,e===Oe&&!(o&n.button)&&(t|=1<<n.button,o|=1<<n.button),(e!==Fe&&L||G&&(e===Oe||n.button!==0))&&(n.stopImmediatePropagation(),n.stopPropagation(),n.preventDefault()),t&1&&Xt(n),o&1&&Yt(n),e===Fe&&Qt(n)}function Yt(n){if(K=!1,F=!1,!_()&&n.type==="mousedown"&&n.button===0&&n.detail!==1)return;if(T){F=!0;return}let e=ee(n),i=window.getComputedStyle(e);K=i.getPropertyValue("--wails-draggable").trim()==="drag"&&n.offsetX-parseFloat(i.paddingLeft)<e.clientWidth&&n.offsetY-parseFloat(i.paddingTop)<e.clientHeight}function Xt(n){K=!1,G=!1,F=!1,L=!1}var Jt=Object.freeze({"se-resize":"nwse-resize","sw-resize":"nesw-resize","nw-resize":"nwse-resize","ne-resize":"nesw-resize","w-resize":"ew-resize","n-resize":"ns-resize","s-resize":"ns-resize","e-resize":"ew-resize"});function h(n){n?(T||(xn=document.body.style.cursor),document.body.style.cursor=Jt[n]):!n&&T&&(document.body.style.cursor=xn),T=n||""}function Qt(n){if(F&&T?(L=!0,S("wails:resize:"+T)):K&&(G=!0,S("wails:drag")),G||L){K=F=!1;return}if(!Ie||!_()&&!(te()&&k("frameless"))){T&&h();return}let e=k("system.resizeHandleHeight")||5,i=k("system.resizeHandleWidth")||5,t=k("resizeCornerExtra")||10,o=Math.max(0,window.innerWidth-document.documentElement.clientWidth),a=Math.max(0,window.innerHeight-document.documentElement.clientHeight),r=window.innerWidth-o,l=window.innerHeight-a,d=n.clientX<r&&r-n.clientX<i,f=n.clientX<i,y=n.clientY<e,Q=n.clientY<l&&l-n.clientY<e,le=n.clientX<r&&r-n.clientX<i+t,de=n.clientX<i+t,ce=n.clientY<e+t,me=n.clientY<l&&l-n.clientY<e+t;!de&&!ce&&!me&&!le?h():le&&me?h("se-resize"):de&&me?h("sw-resize"):de&&ce?h("nw-resize"):ce&&le?h("ne-resize"):f?h("w-resize"):y?h("n-resize"):Q?h("s-resize"):d?h("e-resize"):h()}var Ne={};p(Ne,{Hide:()=>no,Quit:()=>to,Show:()=>io});var Be=u(c.Application),qt=0,$t=1,eo=2;function no(){return Be(qt)}function io(){return Be($t)}function to(){return Be(eo)}var Ge={};p(Ge,{ByID:()=>Po,ByName:()=>Co,Call:()=>Ke,RuntimeError:()=>_e});var An=Function.prototype.toString,I=typeof Reflect=="object"&&Reflect!==null&&Reflect.apply,je,re;if(typeof I=="function"&&typeof Object.defineProperty=="function")try{je=Object.defineProperty({},"length",{get:function(){throw re}}),re={},I(function(){throw 42},null,je)}catch(n){n!==re&&(I=null)}else I=null;var oo=/^\s*class\b/,He=function(e){try{var i=An.call(e);return oo.test(i)}catch(t){return!1}},ze=function(e){try{return He(e)?!1:(An.call(e),!0)}catch(i){return!1}},ae=Object.prototype.toString,ro="[object Object]",ao="[object Function]",so="[object GeneratorFunction]",lo="[object HTMLAllCollection]",co="[object HTML document.all class]",mo="[object HTMLCollection]",uo=typeof Symbol=="function"&&!!Symbol.toStringTag,wo=!(0 in[,]),Ve=function(){return!1};typeof document=="object"&&(En=document.all,ae.call(En)===ae.call(document.all)&&(Ve=function(e){if((wo||!e)&&(typeof e>"u"||typeof e=="object"))try{var i=ae.call(e);return(i===lo||i===co||i===mo||i===ro)&&e("")==null}catch(t){}return!1}));var En;function po(n){if(Ve(n))return!0;if(!n||typeof n!="function"&&typeof n!="object")return!1;try{I(n,null,je)}catch(e){if(e!==re)return!1}return!He(n)&&ze(n)}function fo(n){if(Ve(n))return!0;if(!n||typeof n!="function"&&typeof n!="object")return!1;if(uo)return ze(n);if(He(n))return!1;var e=ae.call(n);return e!==ao&&e!==so&&!/^\[object HTML/.test(e)?!1:ze(n)}var v=I?po:fo;var B=class extends Error{constructor(e,i){super(e,i),this.name="CancelError"}},D=class extends Error{constructor(e,i,t){super((t!=null?t:"Unhandled rejection in cancelled promise.")+" Reason: "+go(i),{cause:i}),this.promise=e,this.name="CancelledRejectionError"}},b=Symbol("barrier"),Ze=Symbol("cancelImpl"),Fn,Rn=(Fn=Symbol.species)!=null?Fn:Symbol("speciesPolyfill"),Y=class n extends Promise{constructor(e,i){let t,o;if(super((d,f)=>{t=d,o=f}),this.constructor[Rn]!==Promise)throw new TypeError("CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.");let a={promise:this,resolve:t,reject:o,get oncancelled(){return i!=null?i:null},set oncancelled(d){i=d!=null?d:void 0}},r={get root(){return r},resolving:!1,settled:!1};Object.defineProperties(this,{[b]:{configurable:!1,enumerable:!1,writable:!0,value:null},[Ze]:{configurable:!1,enumerable:!1,writable:!1,value:Ln(a,r)}});let l=Un(a,r);try{e(In(a,r),l)}catch(d){r.resolving||l(d)}}cancel(e){return new n(i=>{Promise.all([this[Ze](new B("Promise cancelled.",{cause:e})),ho(this)]).then(()=>i(),()=>i())})}cancelOn(e){return e.aborted?this.cancel(e.reason):e.addEventListener("abort",()=>{this.cancel(e.reason)},{capture:!0}),this}then(e,i,t){if(!(this instanceof n))throw new TypeError("CancellablePromise.prototype.then called on an invalid object.");if(v(e)||(e=kn),v(i)||(i=On),e===kn&&i==On)return new n(a=>a(this));let o={};return this[b]=o,new n((a,r)=>{super.then(l=>{var d;this[b]===o&&(this[b]=null),(d=o.resolve)==null||d.call(o);try{a(e(l))}catch(f){r(f)}},l=>{var d;this[b]===o&&(this[b]=null),(d=o.resolve)==null||d.call(o);try{a(i(l))}catch(f){r(f)}})},async a=>{try{return t==null?void 0:t(a)}finally{await this.cancel(a)}})}catch(e,i){return this.then(void 0,e,i)}finally(e,i){if(!(this instanceof n))throw new TypeError("CancellablePromise.prototype.finally called on an invalid object.");return v(e)?this.then(t=>n.resolve(e()).then(()=>t),t=>n.resolve(e()).then(()=>{throw t}),i):this.then(e,e,i)}static get[(b,Ze,Rn)](){return Promise}static all(e){let i=Array.from(e),t=i.length===0?n.resolve(i):new n((o,a)=>{Promise.all(i).then(o,a)},o=>se(t,i,o));return t}static allSettled(e){let i=Array.from(e),t=i.length===0?n.resolve(i):new n((o,a)=>{Promise.allSettled(i).then(o,a)},o=>se(t,i,o));return t}static any(e){let i=Array.from(e),t=i.length===0?n.resolve(i):new n((o,a)=>{Promise.any(i).then(o,a)},o=>se(t,i,o));return t}static race(e){let i=Array.from(e),t=new n((o,a)=>{Promise.race(i).then(o,a)},o=>se(t,i,o));return t}static cancel(e){let i=new n(()=>{});return i.cancel(e),i}static timeout(e,i){let t=new n(()=>{});return AbortSignal&&typeof AbortSignal=="function"&&AbortSignal.timeout&&typeof AbortSignal.timeout=="function"?AbortSignal.timeout(e).addEventListener("abort",()=>{t.cancel(i)}):setTimeout(()=>{t.cancel(i)},e),t}static sleep(e,i){return new n(t=>{setTimeout(()=>t(i),e)})}static reject(e){return new n((i,t)=>t(e))}static resolve(e){return e instanceof n?e:new n(i=>i(e))}static withResolvers(){let e={oncancelled:null};return e.promise=new n((i,t)=>{e.resolve=i,e.reject=t},i=>{var t;(t=e.oncancelled)==null||t.call(e,i)}),e}};function Ln(n,e){let i;return t=>{if(e.settled||(e.settled=!0,e.reason=t,n.reject(t),Promise.prototype.then.call(n.promise,void 0,o=>{if(o!==t)throw o})),!(!e.reason||!n.oncancelled))return i=new Promise(o=>{try{o(n.oncancelled(e.reason.cause))}catch(a){Promise.reject(new D(n.promise,a,"Unhandled exception in oncancelled callback."))}}).catch(o=>{Promise.reject(new D(n.promise,o,"Unhandled rejection in oncancelled callback."))}),n.oncancelled=null,i}}function In(n,e){return i=>{if(!e.resolving){if(e.resolving=!0,i===n.promise){if(e.settled)return;e.settled=!0,n.reject(new TypeError("A promise cannot be resolved with itself."));return}if(i!=null&&(typeof i=="object"||typeof i=="function")){let t;try{t=i.then}catch(o){e.settled=!0,n.reject(o);return}if(v(t)){try{let r=i.cancel;if(v(r)){let l=d=>{Reflect.apply(r,i,[d])};e.reason?Ln(j(N({},n),{oncancelled:l}),e)(e.reason):n.oncancelled=l}}catch(r){}let o={root:e.root,resolving:!1,get settled(){return this.root.settled},set settled(r){this.root.settled=r},get reason(){return this.root.reason}},a=Un(n,o);try{Reflect.apply(t,i,[In(n,o),a])}catch(r){a(r)}return}}e.settled||(e.settled=!0,n.resolve(i))}}}function Un(n,e){return i=>{if(!e.resolving)if(e.resolving=!0,e.settled){try{if(i instanceof B&&e.reason instanceof B&&Object.is(i.cause,e.reason.cause))return}catch(t){}Promise.reject(new D(n.promise,i))}else e.settled=!0,n.reject(i)}}function se(n,e,i){let t=[];for(let o of e){let a;try{if(!v(o.then)||(a=o.cancel,!v(a)))continue}catch(l){continue}let r;try{r=Reflect.apply(a,o,[i])}catch(l){Promise.reject(new D(n,l,"Unhandled exception in cancel method."));continue}r&&t.push((r instanceof Promise?r:Promise.resolve(r)).catch(l=>{Promise.reject(new D(n,l,"Unhandled rejection in cancel method."))}))}return Promise.all(t)}function kn(n){return n}function On(n){throw n}function go(n){try{if(n instanceof Error||typeof n!="object"||n.toString!==Object.prototype.toString)return""+n}catch(e){}try{return JSON.stringify(n)}catch(e){}try{return Object.prototype.toString.call(n)}catch(e){}return"<could not convert error to string>"}function ho(n){var i;let e=(i=n[b])!=null?i:{};return"promise"in e||Object.assign(e,U()),n[b]==null&&(e.resolve(),n[b]=e),e.promise}var U=Promise.withResolvers;U&&typeof U=="function"?U=U.bind(Promise):U=function(){let n,e;return{promise:new Promise((t,o)=>{n=t,e=o}),resolve:n,reject:e}};w&&(window._wails=window._wails||{});var Wo=u(c.Call),bo=u(c.CancelCall),X=new Map,yo=0,vo=0,_e=class extends Error{constructor(e,i){super(e,i),this.name="RuntimeError"}};function Do(){let n;do n=M();while(X.has(n));return n}function Ke(n){let e=Do(),i=Y.withResolvers();X.set(e,{resolve:i.resolve,reject:i.reject});let t=Wo(yo,Object.assign({"call-id":e},n)),o=!0;t.then(r=>{o=!1,X.delete(e),i.resolve(r)},r=>{o=!1,X.delete(e),i.reject(r)});let a=()=>(X.delete(e),bo(vo,{"call-id":e}).catch(r=>{}));return i.oncancelled=()=>o?a():t.then(a),i.promise}function Co(n,...e){return Ke({methodName:n,args:e})}function Po(n,...e){return Ke({methodID:n,args:e})}var Ye={};p(Ye,{SetText:()=>Mo,Text:()=>xo});var Bn=u(c.Clipboard),So=0,To=1;function Mo(n){return Bn(So,{text:n})}function xo(){return Bn(To)}var Xe={};p(Xe,{GetAll:()=>Fo,GetByID:()=>Uo,GetByIndex:()=>Bo,GetCurrent:()=>Io,GetPrimary:()=>Lo});var J=u(c.Screens),Eo=0,Ao=1,Ro=2,ko=3,Oo=4;function Fo(){return J(Eo)}function Lo(){return J(Ao)}function Io(){return J(Ro)}function Uo(n){return J(ko,{id:n})}function Bo(n){return J(Oo,{index:n})}var qe={};p(qe,{Device:()=>Qe,Haptics:()=>Je});var Nn=u(c.IOS),No=0,jo=1,Je;(e=>{function n(i="medium"){return Nn(No,{style:i})}e.Impact=n})(Je||(Je={}));var Qe;(e=>{function n(){return Nn(jo)}e.Info=n})(Qe||(Qe={}));var on={};p(on,{Device:()=>en,Haptics:()=>$e,Toast:()=>nn});var tn=u(c.Android),zo=0,Ho=1,Vo=2,$e;(e=>{function n(i=100){return tn(zo,{duration:i})}e.Vibrate=n})($e||($e={}));var en;(e=>{function n(){return tn(Ho)}e.Info=n})(en||(en={}));var nn;(e=>{function n(i){return tn(Vo,{message:i})}e.Show=n})(nn||(nn={}));var rn={};p(rn,{Events:()=>Zo});var Zo=Object.freeze({CheckStarted:"wails:updater:check-started",UpdateAvailable:"wails:updater:update-available",NoUpdate:"wails:updater:no-update",DownloadStarted:"wails:updater:download-started",DownloadProgress:"wails:updater:download-progress",DownloadComplete:"wails:updater:download-complete",Verifying:"wails:updater:verifying",Installing:"wails:updater:installing",UpdateReady:"wails:updater:update-ready",Error:"wails:updater:error",Meta:"wails:updater:meta",User:Object.freeze({Install:"wails:updater:user:install",Restart:"wails:updater:user:restart",Skip:"wails:updater:user:skip",Remind:"wails:updater:user:remind",Cancel:"wails:updater:user:cancel"}),Window:Object.freeze({Ready:"wails:updater:window:ready"})});w&&(window._wails=window._wails||{});w&&(window._wails.invoke=S,window._wails.clientId=x);w&&(window._wails.handlePlatformFileDrop=A.HandlePlatformFileDrop.bind(A));w&&(window._wails.handleDragEnter=bn,window._wails.handleDragLeave=yn,window._wails.handleDragOver=vn);w&&S("wails:runtime:ready");function jn(n){return fetch(n,{method:"HEAD"}).then(e=>{if(e.ok&&(e.headers.get("content-type")||"").toLowerCase().includes("javascript")){let t=document.createElement("script");t.src=n,document.head.appendChild(t)}}).catch(()=>{})}w&&jn("/wails/custom.js");export{on as Android,Ne as Application,we as Browser,Ge as Call,B as CancelError,Y as CancellablePromise,D as CancelledRejectionError,Ye as Clipboard,ge as Create,fe as Dialogs,be as Events,Re as Flags,qe as IOS,Xe as Screens,Ae as System,rn as Updater,Se as WML,A as Window,x as clientId,un as getTransport,jn as loadOptionalScript,c as objectNames,mn as setTransport}; +var wn=Object.defineProperty,Jn=Object.defineProperties;var qn=Object.getOwnPropertyDescriptors;var mn=Object.getOwnPropertySymbols;var Qn=Object.prototype.hasOwnProperty,$n=Object.prototype.propertyIsEnumerable;var un=(n,e,i)=>e in n?wn(n,e,{enumerable:!0,configurable:!0,writable:!0,value:i}):n[e]=i,V=(n,e)=>{for(var i in e||(e={}))Qn.call(e,i)&&un(n,i,e[i]);if(mn)for(var i of mn(e))$n.call(e,i)&&un(n,i,e[i]);return n},Z=(n,e)=>Jn(n,qn(e));var p=(n,e)=>{for(var i in e)wn(n,i,{get:e[i],enumerable:!0})};var Ae={};p(Ae,{Android:()=>dn,Application:()=>Ke,Browser:()=>he,Call:()=>Qe,CancelError:()=>H,CancellablePromise:()=>ee,CancelledRejectionError:()=>T,Clipboard:()=>$e,Create:()=>ye,Dialogs:()=>be,Events:()=>De,Flags:()=>Le,IOS:()=>on,Screens:()=>en,System:()=>Fe,Updater:()=>cn,WML:()=>xe,Window:()=>F,clientId:()=>k,getTransport:()=>hn,loadOptionalScript:()=>Xn,objectNames:()=>c,setTransport:()=>gn});var xe={};p(xe,{Enable:()=>Ee,Reload:()=>En});var he={};p(he,{OpenURL:()=>ge});var ei="useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";function R(n=21){let e="",i=n|0;for(;i--;)e+=ei[Math.random()*64|0];return e}var u=typeof window<"u"&&typeof document<"u";function ni(){return window.location.origin+"/wails/runtime"}var K=512*1024;var _=class extends Error{constructor(e,i){super(e,i),this.name="RuntimeError"}},c=Object.freeze({Call:0,Clipboard:1,Application:2,Events:3,ContextMenu:4,Dialog:5,Window:6,Screens:7,System:8,Browser:9,CancelCall:10,IOS:11,Android:12}),k=R(),G=null;function gn(n){G=n}function hn(){return G}function w(n,e=""){return function(i,t=null){return ii(n,i,e,t)}}async function ii(n,e,i,t){var f,D;if(G)return G.call(n,e,i,t);let o=new URL(ni()),r={object:n,method:e};t!=null&&(r.args=t);let a={"x-wails-client-id":k,"Content-Type":"application/json"};i&&(a["x-wails-window-name"]=i);let l=JSON.stringify(r),d;if(l.length>K?d=await ti(o,a,l):d=await fetch(o,{method:"POST",headers:a,body:l}),!d.ok){let S=d.headers.get("Content-Type");if(S!=null&&S.includes("application/json")){let W=await d.json(),b;switch(W.kind){case"ReferenceError":b=new ReferenceError(W.message);break;case"TypeError":b=new TypeError(W.message);break;case"RuntimeError":b=new _(W.message);break;default:b=new Error(W.message)}throw b.cause=W.cause,b}throw new Error(await d.text())}return((D=(f=d.headers.get("Content-Type"))==null?void 0:f.indexOf("application/json"))!=null?D:-1)!==-1?d.json():d.text()}async function ti(n,e,i){let t=R(),o=new TextEncoder().encode(i),r=Math.ceil(o.length/K);for(let a=0;a<r-1;a++){let l=o.subarray(a*K,(a+1)*K),d=await fetch(n,{method:"POST",headers:Z(V({},e),{"x-wails-chunk-id":t,"x-wails-chunk-index":String(a),"x-wails-chunk-total":String(r)}),body:l});if(!d.ok)throw new Error(await d.text())}return fetch(n,{method:"POST",headers:Z(V({},e),{"x-wails-chunk-id":t,"x-wails-chunk-index":String(r-1),"x-wails-chunk-total":String(r)}),body:o.subarray((r-1)*K)})}var fn,pn=u&&typeof((fn=window.wails)==null?void 0:fn.invokeAsync)=="function"?window.wails:null;if(pn){let n=new Map;window._wailsAndroidCallback=(e,i,t)=>{var r;let o=n.get(e);if(o){if(n.delete(e),t){o.reject(new Error(t));return}try{let a=JSON.parse(i!=null?i:"{}");if(!a.ok){o.reject(new Error((r=a.error)!=null?r:"unknown runtime call error"));return}o.resolve("text"in a?a.text:a.data)}catch(a){o.reject(a)}}},G={call(e,i,t,o){return new Promise((r,a)=>{let l=R();n.set(l,{resolve:r,reject:a});try{pn.invokeAsync(l,JSON.stringify({object:e,method:i,windowName:t,args:o!=null?o:null,clientId:k}))}catch(d){n.delete(l),a(d)}})}}}var oi=w(c.Browser),ri=0;function ge(n){return oi(ri,{url:n.toString()})}var be={};p(be,{Error:()=>fi,Info:()=>wi,OpenFile:()=>gi,Question:()=>We,SaveFile:()=>hi,Warning:()=>pi});u&&(window._wails=window._wails||{});var ai=w(c.Dialog),si=0,li=1,di=2,ci=3,mi=4,ui=5;function O(n,e={}){return ai(n,e)}function wi(n){return O(si,n)}function pi(n){return O(li,n)}function fi(n){return O(di,n)}function We(n){return O(ci,n)}function gi(n){var e;return(e=O(mi,n))!=null?e:[]}function hi(n){return O(ui,n)}var De={};p(De,{Emit:()=>Ce,Off:()=>Ai,OffAll:()=>Ri,On:()=>Ei,OnMultiple:()=>ve,Once:()=>xi,Types:()=>Si,WailsEvent:()=>Y});var g=new Map,te=class{constructor(e,i,t){this.eventName=e,this.callback=i,this.maxCallbacks=t||-1}dispatch(e){try{this.callback(e)}catch(i){}return this.maxCallbacks===-1?!1:(this.maxCallbacks-=1,this.maxCallbacks===0)}};function Wn(n){let e=g.get(n.eventName);e&&(e=e.filter(i=>i!==n),e.length===0?g.delete(n.eventName):g.set(n.eventName,e))}var ye={};p(ye,{Any:()=>M,Array:()=>bi,ByteSlice:()=>Wi,DateFromTime:()=>Di,Events:()=>oe,Map:()=>yi,Nullable:()=>vi,Struct:()=>Ci});function M(n){return n}function Wi(n){return n==null?"":n}function bi(n){return n===M?e=>e===null?[]:e:e=>{if(e===null)return[];for(let i=0;i<e.length;i++)e[i]=n(e[i]);return e}}function yi(n,e){return e===M?i=>i===null?{}:i:i=>{if(i===null)return{};for(let t in i)i[t]=e(i[t]);return i}}function vi(n){return n===M?M:e=>e===null?null:n(e)}function Ci(n){let e=!0;for(let i in n)if(n[i]!==M){e=!1;break}return e?M:i=>{for(let t in n)t in i&&(i[t]=n[t](i[t]));return i}}function Di(n){return new Date(n)}var oe={};var Si=Object.freeze({Windows:Object.freeze({APMPowerSettingChange:"windows:APMPowerSettingChange",APMPowerStatusChange:"windows:APMPowerStatusChange",APMResumeAutomatic:"windows:APMResumeAutomatic",APMResumeSuspend:"windows:APMResumeSuspend",APMSuspend:"windows:APMSuspend",ApplicationStarted:"windows:ApplicationStarted",SystemThemeChanged:"windows:SystemThemeChanged",WebViewNavigationCompleted:"windows:WebViewNavigationCompleted",WindowActive:"windows:WindowActive",WindowBackgroundErase:"windows:WindowBackgroundErase",WindowClickActive:"windows:WindowClickActive",WindowClosing:"windows:WindowClosing",WindowDidMove:"windows:WindowDidMove",WindowDidResize:"windows:WindowDidResize",WindowDPIChanged:"windows:WindowDPIChanged",WindowDragDrop:"windows:WindowDragDrop",WindowDragEnter:"windows:WindowDragEnter",WindowDragLeave:"windows:WindowDragLeave",WindowDragOver:"windows:WindowDragOver",WindowEndMove:"windows:WindowEndMove",WindowEndResize:"windows:WindowEndResize",WindowFullscreen:"windows:WindowFullscreen",WindowHide:"windows:WindowHide",WindowInactive:"windows:WindowInactive",WindowKeyDown:"windows:WindowKeyDown",WindowKeyUp:"windows:WindowKeyUp",WindowKillFocus:"windows:WindowKillFocus",WindowNonClientHit:"windows:WindowNonClientHit",WindowNonClientMouseDown:"windows:WindowNonClientMouseDown",WindowNonClientMouseLeave:"windows:WindowNonClientMouseLeave",WindowNonClientMouseMove:"windows:WindowNonClientMouseMove",WindowNonClientMouseUp:"windows:WindowNonClientMouseUp",WindowPaint:"windows:WindowPaint",WindowRestore:"windows:WindowRestore",WindowSetFocus:"windows:WindowSetFocus",WindowShow:"windows:WindowShow",WindowStartMove:"windows:WindowStartMove",WindowStartResize:"windows:WindowStartResize",WindowUnFullscreen:"windows:WindowUnFullscreen",WindowZOrderChanged:"windows:WindowZOrderChanged",WindowMinimise:"windows:WindowMinimise",WindowUnMinimise:"windows:WindowUnMinimise",WindowMaximise:"windows:WindowMaximise",WindowUnMaximise:"windows:WindowUnMaximise"}),Mac:Object.freeze({ApplicationDidBecomeActive:"mac:ApplicationDidBecomeActive",ApplicationDidChangeBackingProperties:"mac:ApplicationDidChangeBackingProperties",ApplicationDidChangeEffectiveAppearance:"mac:ApplicationDidChangeEffectiveAppearance",ApplicationDidChangeIcon:"mac:ApplicationDidChangeIcon",ApplicationDidChangeOcclusionState:"mac:ApplicationDidChangeOcclusionState",ApplicationDidChangeScreenParameters:"mac:ApplicationDidChangeScreenParameters",ApplicationDidChangeStatusBarFrame:"mac:ApplicationDidChangeStatusBarFrame",ApplicationDidChangeStatusBarOrientation:"mac:ApplicationDidChangeStatusBarOrientation",ApplicationDidChangeTheme:"mac:ApplicationDidChangeTheme",ApplicationDidFinishLaunching:"mac:ApplicationDidFinishLaunching",ApplicationDidHide:"mac:ApplicationDidHide",ApplicationDidResignActive:"mac:ApplicationDidResignActive",ApplicationDidUnhide:"mac:ApplicationDidUnhide",ApplicationDidUpdate:"mac:ApplicationDidUpdate",ApplicationDidWake:"mac:ApplicationDidWake",ApplicationScreensDidSleep:"mac:ApplicationScreensDidSleep",ApplicationScreensDidWake:"mac:ApplicationScreensDidWake",ApplicationShouldHandleReopen:"mac:ApplicationShouldHandleReopen",ApplicationWillBecomeActive:"mac:ApplicationWillBecomeActive",ApplicationWillFinishLaunching:"mac:ApplicationWillFinishLaunching",ApplicationWillHide:"mac:ApplicationWillHide",ApplicationWillResignActive:"mac:ApplicationWillResignActive",ApplicationWillSleep:"mac:ApplicationWillSleep",ApplicationWillTerminate:"mac:ApplicationWillTerminate",ApplicationWillUnhide:"mac:ApplicationWillUnhide",ApplicationWillUpdate:"mac:ApplicationWillUpdate",MenuDidAddItem:"mac:MenuDidAddItem",MenuDidBeginTracking:"mac:MenuDidBeginTracking",MenuDidClose:"mac:MenuDidClose",MenuDidDisplayItem:"mac:MenuDidDisplayItem",MenuDidEndTracking:"mac:MenuDidEndTracking",MenuDidHighlightItem:"mac:MenuDidHighlightItem",MenuDidOpen:"mac:MenuDidOpen",MenuDidPopUp:"mac:MenuDidPopUp",MenuDidRemoveItem:"mac:MenuDidRemoveItem",MenuDidSendAction:"mac:MenuDidSendAction",MenuDidSendActionToItem:"mac:MenuDidSendActionToItem",MenuDidUpdate:"mac:MenuDidUpdate",MenuWillAddItem:"mac:MenuWillAddItem",MenuWillBeginTracking:"mac:MenuWillBeginTracking",MenuWillDisplayItem:"mac:MenuWillDisplayItem",MenuWillEndTracking:"mac:MenuWillEndTracking",MenuWillHighlightItem:"mac:MenuWillHighlightItem",MenuWillOpen:"mac:MenuWillOpen",MenuWillPopUp:"mac:MenuWillPopUp",MenuWillRemoveItem:"mac:MenuWillRemoveItem",MenuWillSendAction:"mac:MenuWillSendAction",MenuWillSendActionToItem:"mac:MenuWillSendActionToItem",MenuWillUpdate:"mac:MenuWillUpdate",WebViewDidCommitNavigation:"mac:WebViewDidCommitNavigation",WebViewDidFinishNavigation:"mac:WebViewDidFinishNavigation",WebViewDidReceiveServerRedirectForProvisionalNavigation:"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation",WebViewDidStartProvisionalNavigation:"mac:WebViewDidStartProvisionalNavigation",WindowDidBecomeKey:"mac:WindowDidBecomeKey",WindowDidBecomeMain:"mac:WindowDidBecomeMain",WindowDidBeginSheet:"mac:WindowDidBeginSheet",WindowDidChangeAlpha:"mac:WindowDidChangeAlpha",WindowDidChangeBackingLocation:"mac:WindowDidChangeBackingLocation",WindowDidChangeBackingProperties:"mac:WindowDidChangeBackingProperties",WindowDidChangeCollectionBehavior:"mac:WindowDidChangeCollectionBehavior",WindowDidChangeEffectiveAppearance:"mac:WindowDidChangeEffectiveAppearance",WindowDidChangeOcclusionState:"mac:WindowDidChangeOcclusionState",WindowDidChangeOrderingMode:"mac:WindowDidChangeOrderingMode",WindowDidChangeScreen:"mac:WindowDidChangeScreen",WindowDidChangeScreenParameters:"mac:WindowDidChangeScreenParameters",WindowDidChangeScreenProfile:"mac:WindowDidChangeScreenProfile",WindowDidChangeScreenSpace:"mac:WindowDidChangeScreenSpace",WindowDidChangeScreenSpaceProperties:"mac:WindowDidChangeScreenSpaceProperties",WindowDidChangeSharingType:"mac:WindowDidChangeSharingType",WindowDidChangeSpace:"mac:WindowDidChangeSpace",WindowDidChangeSpaceOrderingMode:"mac:WindowDidChangeSpaceOrderingMode",WindowDidChangeTitle:"mac:WindowDidChangeTitle",WindowDidChangeToolbar:"mac:WindowDidChangeToolbar",WindowDidDeminiaturize:"mac:WindowDidDeminiaturize",WindowDidEndSheet:"mac:WindowDidEndSheet",WindowDidEnterFullScreen:"mac:WindowDidEnterFullScreen",WindowDidEnterVersionBrowser:"mac:WindowDidEnterVersionBrowser",WindowDidExitFullScreen:"mac:WindowDidExitFullScreen",WindowDidExitVersionBrowser:"mac:WindowDidExitVersionBrowser",WindowDidExpose:"mac:WindowDidExpose",WindowDidFocus:"mac:WindowDidFocus",WindowDidMiniaturize:"mac:WindowDidMiniaturize",WindowDidMove:"mac:WindowDidMove",WindowDidOrderOffScreen:"mac:WindowDidOrderOffScreen",WindowDidOrderOnScreen:"mac:WindowDidOrderOnScreen",WindowDidResignKey:"mac:WindowDidResignKey",WindowDidResignMain:"mac:WindowDidResignMain",WindowDidResize:"mac:WindowDidResize",WindowDidUpdate:"mac:WindowDidUpdate",WindowDidUpdateAlpha:"mac:WindowDidUpdateAlpha",WindowDidUpdateCollectionBehavior:"mac:WindowDidUpdateCollectionBehavior",WindowDidUpdateCollectionProperties:"mac:WindowDidUpdateCollectionProperties",WindowDidUpdateShadow:"mac:WindowDidUpdateShadow",WindowDidUpdateTitle:"mac:WindowDidUpdateTitle",WindowDidUpdateToolbar:"mac:WindowDidUpdateToolbar",WindowDidZoom:"mac:WindowDidZoom",WindowFileDraggingEntered:"mac:WindowFileDraggingEntered",WindowFileDraggingExited:"mac:WindowFileDraggingExited",WindowFileDraggingPerformed:"mac:WindowFileDraggingPerformed",WindowHide:"mac:WindowHide",WindowMaximise:"mac:WindowMaximise",WindowUnMaximise:"mac:WindowUnMaximise",WindowMinimise:"mac:WindowMinimise",WindowUnMinimise:"mac:WindowUnMinimise",WindowShouldClose:"mac:WindowShouldClose",WindowShow:"mac:WindowShow",WindowWillBecomeKey:"mac:WindowWillBecomeKey",WindowWillBecomeMain:"mac:WindowWillBecomeMain",WindowWillBeginSheet:"mac:WindowWillBeginSheet",WindowWillChangeOrderingMode:"mac:WindowWillChangeOrderingMode",WindowWillClose:"mac:WindowWillClose",WindowWillDeminiaturize:"mac:WindowWillDeminiaturize",WindowWillEnterFullScreen:"mac:WindowWillEnterFullScreen",WindowWillEnterVersionBrowser:"mac:WindowWillEnterVersionBrowser",WindowWillExitFullScreen:"mac:WindowWillExitFullScreen",WindowWillExitVersionBrowser:"mac:WindowWillExitVersionBrowser",WindowWillFocus:"mac:WindowWillFocus",WindowWillMiniaturize:"mac:WindowWillMiniaturize",WindowWillMove:"mac:WindowWillMove",WindowWillOrderOffScreen:"mac:WindowWillOrderOffScreen",WindowWillOrderOnScreen:"mac:WindowWillOrderOnScreen",WindowWillResignMain:"mac:WindowWillResignMain",WindowWillResize:"mac:WindowWillResize",WindowWillUnfocus:"mac:WindowWillUnfocus",WindowWillUpdate:"mac:WindowWillUpdate",WindowWillUpdateAlpha:"mac:WindowWillUpdateAlpha",WindowWillUpdateCollectionBehavior:"mac:WindowWillUpdateCollectionBehavior",WindowWillUpdateCollectionProperties:"mac:WindowWillUpdateCollectionProperties",WindowWillUpdateShadow:"mac:WindowWillUpdateShadow",WindowWillUpdateTitle:"mac:WindowWillUpdateTitle",WindowWillUpdateToolbar:"mac:WindowWillUpdateToolbar",WindowWillUpdateVisibility:"mac:WindowWillUpdateVisibility",WindowWillUseStandardFrame:"mac:WindowWillUseStandardFrame",WindowZoomIn:"mac:WindowZoomIn",WindowZoomOut:"mac:WindowZoomOut",WindowZoomReset:"mac:WindowZoomReset",WebViewWebContentProcessDidTerminate:"mac:WebViewWebContentProcessDidTerminate"}),Linux:Object.freeze({ApplicationStartup:"linux:ApplicationStartup",SystemDidWake:"linux:SystemDidWake",SystemThemeChanged:"linux:SystemThemeChanged",SystemWillSleep:"linux:SystemWillSleep",WindowDeleteEvent:"linux:WindowDeleteEvent",WindowDidMove:"linux:WindowDidMove",WindowDidResize:"linux:WindowDidResize",WindowFocusIn:"linux:WindowFocusIn",WindowFocusOut:"linux:WindowFocusOut",WindowLoadStarted:"linux:WindowLoadStarted",WindowLoadRedirected:"linux:WindowLoadRedirected",WindowLoadCommitted:"linux:WindowLoadCommitted",WindowLoadFinished:"linux:WindowLoadFinished"}),iOS:Object.freeze({ApplicationDidBecomeActive:"ios:ApplicationDidBecomeActive",ApplicationDidEnterBackground:"ios:ApplicationDidEnterBackground",ApplicationDidFinishLaunching:"ios:ApplicationDidFinishLaunching",ApplicationDidReceiveMemoryWarning:"ios:ApplicationDidReceiveMemoryWarning",ApplicationWillEnterForeground:"ios:ApplicationWillEnterForeground",ApplicationWillResignActive:"ios:ApplicationWillResignActive",ApplicationWillTerminate:"ios:ApplicationWillTerminate",WindowDidLoad:"ios:WindowDidLoad",WindowWillAppear:"ios:WindowWillAppear",WindowDidAppear:"ios:WindowDidAppear",WindowWillDisappear:"ios:WindowWillDisappear",WindowDidDisappear:"ios:WindowDidDisappear",WindowSafeAreaInsetsChanged:"ios:WindowSafeAreaInsetsChanged",WindowOrientationChanged:"ios:WindowOrientationChanged",WindowTouchBegan:"ios:WindowTouchBegan",WindowTouchMoved:"ios:WindowTouchMoved",WindowTouchEnded:"ios:WindowTouchEnded",WindowTouchCancelled:"ios:WindowTouchCancelled",WebViewDidStartNavigation:"ios:WebViewDidStartNavigation",WebViewDidFinishNavigation:"ios:WebViewDidFinishNavigation",WebViewDidFailNavigation:"ios:WebViewDidFailNavigation",WebViewDecidePolicyForNavigationAction:"ios:WebViewDecidePolicyForNavigationAction",BatteryChanged:"ios:BatteryChanged",NetworkChanged:"ios:NetworkChanged",ThemeChanged:"ios:ThemeChanged",ScreenLocked:"ios:ScreenLocked",ScreenUnlocked:"ios:ScreenUnlocked"}),Android:Object.freeze({ActivityCreated:"android:ActivityCreated",ActivityStarted:"android:ActivityStarted",ActivityResumed:"android:ActivityResumed",ActivityPaused:"android:ActivityPaused",ActivityStopped:"android:ActivityStopped",ActivityDestroyed:"android:ActivityDestroyed",ApplicationLowMemory:"android:ApplicationLowMemory",WebViewPageStarted:"android:WebViewPageStarted",WebViewPageFinished:"android:WebViewPageFinished",BatteryChanged:"android:BatteryChanged",NetworkChanged:"android:NetworkChanged",ThemeChanged:"android:ThemeChanged",ScreenLocked:"android:ScreenLocked",ScreenUnlocked:"android:ScreenUnlocked"}),Common:Object.freeze({ApplicationOpenedWithFile:"common:ApplicationOpenedWithFile",ApplicationStarted:"common:ApplicationStarted",ApplicationLaunchedWithUrl:"common:ApplicationLaunchedWithUrl",ThemeChanged:"common:ThemeChanged",SystemDidWake:"common:SystemDidWake",SystemWillSleep:"common:SystemWillSleep",WindowClosing:"common:WindowClosing",WindowDidMove:"common:WindowDidMove",WindowDidResize:"common:WindowDidResize",WindowDPIChanged:"common:WindowDPIChanged",WindowFilesDropped:"common:WindowFilesDropped",WindowFocus:"common:WindowFocus",WindowFullscreen:"common:WindowFullscreen",WindowHide:"common:WindowHide",WindowLostFocus:"common:WindowLostFocus",WindowMaximise:"common:WindowMaximise",WindowMinimise:"common:WindowMinimise",WindowToggleFrameless:"common:WindowToggleFrameless",WindowRestore:"common:WindowRestore",WindowRuntimeReady:"common:WindowRuntimeReady",WindowShow:"common:WindowShow",WindowUnFullscreen:"common:WindowUnFullscreen",WindowUnMaximise:"common:WindowUnMaximise",WindowUnMinimise:"common:WindowUnMinimise",WindowZoom:"common:WindowZoom",WindowZoomIn:"common:WindowZoomIn",WindowZoomOut:"common:WindowZoomOut",WindowZoomReset:"common:WindowZoomReset",BatteryChanged:"common:BatteryChanged",NetworkChanged:"common:NetworkChanged",ScreenLocked:"common:ScreenLocked",ScreenUnlocked:"common:ScreenUnlocked",LowMemory:"common:LowMemory"})});u&&(window._wails=window._wails||{},window._wails.dispatchWailsEvent=Mi);var Pi=w(c.Events),Ti=0,Y=class{constructor(e,i){this.name=e,this.data=i!=null?i:null}};function Mi(n){let e=g.get(n.name);if(!e)return;let i=new Y(n.name,n.name in oe?oe[n.name](n.data):n.data);"sender"in n&&(i.sender=n.sender);let t=new Set;for(let o of e.slice())o.dispatch(i)&&t.add(o);if(t.size>0){let o=g.get(n.name);if(o){let r=o.filter(a=>!t.has(a));r.length===0?g.delete(n.name):g.set(n.name,r)}}}function ve(n,e,i){let t=g.get(n)||[],o=new te(n,e,i);return t.push(o),g.set(n,t),()=>Wn(o)}function Ei(n,e){return ve(n,e,-1)}function xi(n,e){return ve(n,e,1)}function Ai(...n){n.forEach(e=>g.delete(e))}function Ri(){g.clear()}function Ce(n,e){return Pi(Ti,new Y(n,e))}function bn(){return new MouseEvent("mousedown").buttons===0}function yn(){if(!EventTarget||!AbortSignal||!AbortController)return!1;let n=!0,e=new EventTarget,i=new AbortController;return e.addEventListener("test",()=>{n=!1},{signal:i.signal}),i.abort(),e.dispatchEvent(new CustomEvent("test")),n}function re(n){var e;return n.target instanceof HTMLElement?n.target:!(n.target instanceof HTMLElement)&&n.target instanceof Node&&(e=n.target.parentElement)!=null?e:document.body}var vn=!1;u&&document.addEventListener("DOMContentLoaded",()=>{vn=!0});function ae(n){vn||document.readyState==="complete"?n():document.addEventListener("DOMContentLoaded",n)}var ki="data-file-drop-target",y="file-drop-target-active",m=null,Oi=0,Fi=1,Li=2,Ii=3,Ni=4,Ui=5,zi=6,Bi=7,ji=8,Hi=9,Vi=10,Zi=11,Ki=12,_i=13,Gi=14,Yi=15,Xi=16,Ji=17,qi=18,Qi=19,$i=20,et=21,nt=22,it=23,tt=24,ot=25,rt=26,at=27,st=28,lt=29,dt=30,ct=31,mt=32,ut=33,wt=34,pt=35,ft=36,gt=37,ht=38,Wt=39,bt=40,yt=41,vt=42,Ct=43,Dt=44,St=45,Pt=46,Tt=47,Mt=48,Et=49,xt=50,At=51,Rt=52;function se(n){return n?n.closest("[".concat(ki,"]")):null}function kt(){var n,e,i,t;return((e=(n=window.chrome)==null?void 0:n.webview)==null?void 0:e.postMessageWithAdditionalObjects)==null?!1:((t=(i=window._wails)==null?void 0:i.flags)==null?void 0:t.enableFileDrop)===!0}function Ot(n,e,i){var t,o;(o=(t=window.chrome)==null?void 0:t.webview)!=null&&o.postMessageWithAdditionalObjects&&window.chrome.webview.postMessageWithAdditionalObjects("file:drop:".concat(n,":").concat(e),i)}var Pe=!1;function Cn(){Pe=!1,m&&(m.classList.remove(y),m=null)}function Dn(){var n,e;((e=(n=window._wails)==null?void 0:n.flags)==null?void 0:e.enableFileDrop)!==!1&&(Pe=!0)}function Sn(){Cn()}function Pn(n,e){var o,r;if(!Pe||((r=(o=window._wails)==null?void 0:o.flags)==null?void 0:r.enableFileDrop)===!1)return;let i=document.elementFromPoint(n,e),t=se(i);m&&m!==t&&m.classList.remove(y),t?(t.classList.add(y),m=t):m=null}var s=Symbol("caller"),le=class le{constructor(e=""){this[s]=w(c.Window,e);for(let i of Object.getOwnPropertyNames(le.prototype))i!=="constructor"&&typeof this[i]=="function"&&(this[i]=this[i].bind(this))}Get(e){return new le(e)}Position(){return this[s](Oi)}Center(){return this[s](Fi)}Close(){return this[s](Li)}DisableSizeConstraints(){return this[s](Ii)}EnableSizeConstraints(){return this[s](Ni)}Focus(){return this[s](Ui)}ForceReload(){return this[s](zi)}Fullscreen(){return this[s](Bi)}GetScreen(){return this[s](ji)}GetZoom(){return this[s](Hi)}Height(){return this[s](Vi)}Hide(){return this[s](Zi)}IsFocused(){return this[s](Ki)}IsFullscreen(){return this[s](_i)}IsMaximised(){return this[s](Gi)}IsMinimised(){return this[s](Yi)}Maximise(){return this[s](Xi)}Minimise(){return this[s](Ji)}Name(){return this[s](qi)}OpenDevTools(){return this[s](Qi)}RelativePosition(){return this[s]($i)}Reload(){return this[s](et)}Resizable(){return this[s](nt)}Restore(){return this[s](it)}SetPosition(e,i){return this[s](tt,{x:e,y:i})}SetAlwaysOnTop(e){return this[s](ot,{alwaysOnTop:e})}SetBackgroundColour(e,i,t,o){return this[s](rt,{r:e,g:i,b:t,a:o})}SetFrameless(e){return this[s](at,{frameless:e})}SetFullscreenButtonEnabled(e){return this[s](st,{enabled:e})}SetMaxSize(e,i){return this[s](lt,{width:e,height:i})}SetMinSize(e,i){return this[s](dt,{width:e,height:i})}SetRelativePosition(e,i){return this[s](ct,{x:e,y:i})}SetResizable(e){return this[s](mt,{resizable:e})}SetSize(e,i){return this[s](ut,{width:e,height:i})}SetTitle(e){return this[s](wt,{title:e})}SetZoom(e){return this[s](pt,{zoom:e})}Show(){return this[s](ft)}Size(){return this[s](gt)}ToggleFullscreen(){return this[s](ht)}ToggleMaximise(){return this[s](Wt)}ToggleFrameless(){return this[s](bt)}UnFullscreen(){return this[s](yt)}UnMaximise(){return this[s](vt)}UnMinimise(){return this[s](Ct)}Width(){return this[s](Dt)}Zoom(){return this[s](St)}ZoomIn(){return this[s](Pt)}ZoomOut(){return this[s](Tt)}ZoomReset(){return this[s](Mt)}HandlePlatformFileDrop(e,i,t){var d,f;if(((f=(d=window._wails)==null?void 0:d.flags)==null?void 0:f.enableFileDrop)===!1)return;let o=document.elementFromPoint(i,t),r=se(o);if(!r)return;let a={id:r.id,classList:Array.from(r.classList),attributes:{}};for(let D=0;D<r.attributes.length;D++){let S=r.attributes[D];a.attributes[S.name]=S.value}let l={filenames:e,x:i,y:t,elementDetails:a};this[s](xt,l),Cn()}SetScreen(e){return this[s](Rt,{screenID:e})}SnapAssist(){return this[s](Et)}Print(){return this[s](At)}},Se=le,Ft=new Se("");function Lt(){let n=document.documentElement,e=0;n.addEventListener("dragenter",i=>{var r,a,l;if(!((r=i.dataTransfer)!=null&&r.types.includes("Files")))return;if(i.preventDefault(),((l=(a=window._wails)==null?void 0:a.flags)==null?void 0:l.enableFileDrop)===!1){i.dataTransfer.dropEffect="none";return}e++;let t=document.elementFromPoint(i.clientX,i.clientY),o=se(t);m&&m!==o&&m.classList.remove(y),o?(o.classList.add(y),i.dataTransfer.dropEffect="copy",m=o):(i.dataTransfer.dropEffect="none",m=null)},!1),n.addEventListener("dragover",i=>{var r,a,l;if(!((r=i.dataTransfer)!=null&&r.types.includes("Files")))return;if(i.preventDefault(),((l=(a=window._wails)==null?void 0:a.flags)==null?void 0:l.enableFileDrop)===!1){i.dataTransfer.dropEffect="none";return}let t=document.elementFromPoint(i.clientX,i.clientY),o=se(t);m&&m!==o&&m.classList.remove(y),o?(o.classList.contains(y)||o.classList.add(y),i.dataTransfer.dropEffect="copy",m=o):(i.dataTransfer.dropEffect="none",m=null)},!1),n.addEventListener("dragleave",i=>{var t,o,r;(t=i.dataTransfer)!=null&&t.types.includes("Files")&&(i.preventDefault(),((r=(o=window._wails)==null?void 0:o.flags)==null?void 0:r.enableFileDrop)!==!1&&i.relatedTarget!==null&&(e--,(e===0||m&&!m.contains(i.relatedTarget))&&(m&&(m.classList.remove(y),m=null),e=0)))},!1),n.addEventListener("drop",i=>{var t,o,r;if((t=i.dataTransfer)!=null&&t.types.includes("Files")&&(i.preventDefault(),((r=(o=window._wails)==null?void 0:o.flags)==null?void 0:r.enableFileDrop)!==!1&&(e=0,m&&(m.classList.remove(y),m=null),kt()))){let a=[];if(i.dataTransfer.items){for(let l of i.dataTransfer.items)if(l.kind==="file"){let d=l.getAsFile();d&&a.push(d)}}else if(i.dataTransfer.files)for(let l of i.dataTransfer.files)a.push(l);a.length>0&&Ot(i.clientX,i.clientY,a)}},!1)}typeof window<"u"&&typeof document<"u"&&Lt();var F=Ft;function It(n,e=null){Ce(n,e)}function Nt(n,e){let i=F.Get(n),t=i[e];if(typeof t=="function")try{t.call(i)}catch(o){}}function Tn(n){let e=n.currentTarget;function i(o="Yes"){if(o!=="Yes")return;let r=e.getAttribute("wml-event")||e.getAttribute("data-wml-event"),a=e.getAttribute("wml-target-window")||e.getAttribute("data-wml-target-window")||"",l=e.getAttribute("wml-window")||e.getAttribute("data-wml-window"),d=e.getAttribute("wml-openurl")||e.getAttribute("data-wml-openurl");r!==null&&It(r),l!==null&&Nt(a,l),d!==null&&ge(d)}let t=e.getAttribute("wml-confirm")||e.getAttribute("data-wml-confirm");t?We({Title:"Confirm",Message:t,Detached:!1,Buttons:[{Label:"Yes"},{Label:"No",IsDefault:!0}]}).then(i):i()}var X=Symbol("controller"),L=Symbol("triggerMap"),E=Symbol("elementCount"),Te=class{constructor(){this[X]=new AbortController}set(e,i){return{signal:this[X].signal}}reset(){this[X].abort(),this[X]=new AbortController}},Me=class{constructor(){this[L]=new WeakMap,this[E]=0}set(e,i){return this[L].has(e)||this[E]++,this[L].set(e,i),{}}reset(){if(!(this[E]<=0)){for(let e of document.body.querySelectorAll("*")){if(this[E]<=0)break;let i=this[L].get(e);i!=null&&this[E]--;for(let t of i||[])e.removeEventListener(t,Tn)}this[L]=new WeakMap,this[E]=0}}},Mn=yn()?new Te:new Me;function Ut(n){let e=/\S+/g,i=n.getAttribute("wml-trigger")||n.getAttribute("data-wml-trigger")||"click",t=[],o;for(;(o=e.exec(i))!==null;)t.push(o[0]);let r=Mn.set(n,t);for(let a of t)n.addEventListener(a,Tn,r)}function Ee(){ae(En)}function En(){Mn.reset(),document.body.querySelectorAll("[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]").forEach(Ut)}window.wails=Ae;Ee();var Fe={};p(Fe,{Capabilities:()=>Vt,Environment:()=>Zt,IsAMD64:()=>Gt,IsARM:()=>Yt,IsARM64:()=>Xt,IsAndroid:()=>Rn,IsDarkMode:()=>Ht,IsDebug:()=>Oe,IsDesktop:()=>_t,IsIOS:()=>An,IsLinux:()=>de,IsMac:()=>xn,IsMobile:()=>Kt,IsWindows:()=>J,invoke:()=>C});var ke=w(c.System),zt=0,Bt=1,jt=2,Re=(function(){var n,e,i,t,o,r;try{if((e=(n=window.chrome)==null?void 0:n.webview)!=null&&e.postMessage)return window.chrome.webview.postMessage.bind(window.chrome.webview);if((o=(t=(i=window.webkit)==null?void 0:i.messageHandlers)==null?void 0:t.external)!=null&&o.postMessage)return window.webkit.messageHandlers.external.postMessage.bind(window.webkit.messageHandlers.external);if((r=window.wails)!=null&&r.invoke)return a=>window.wails.invoke(typeof a=="string"?a:JSON.stringify(a))}catch(a){}return null})();function C(n){Re==null||Re(n)}function Ht(){return ke(zt)}async function Vt(){return ke(jt)}function Zt(){return ke(Bt)}function J(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="windows"}function de(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="linux"}function xn(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="darwin"}function An(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="ios"}function Rn(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.OS)==="android"}function Kt(){return An()||Rn()}function _t(){return xn()||J()||de()}function Gt(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="amd64"}function Yt(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="arm"}function Xt(){var n,e;return((e=(n=window._wails)==null?void 0:n.environment)==null?void 0:e.Arch)==="arm64"}function Oe(){var n,e;return!!((e=(n=window._wails)==null?void 0:n.environment)!=null&&e.Debug)}u&&window.addEventListener("contextmenu",$t);var Jt=w(c.ContextMenu),qt=0;function Qt(n,e,i,t){Jt(qt,{id:n,x:e,y:i,data:t})}function $t(n){let e=re(n),i=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu").trim();if(i){n.preventDefault();let t=window.getComputedStyle(e).getPropertyValue("--custom-contextmenu-data");Qt(i,n.clientX,n.clientY,t)}else eo(n,e)}function eo(n,e){if(Oe())return;switch(window.getComputedStyle(e).getPropertyValue("--default-contextmenu").trim()){case"show":return;case"hide":n.preventDefault();return}if(e.isContentEditable)return;let i=window.getSelection(),t=i&&i.toString().length>0;if(t)for(let o=0;o<i.rangeCount;o++){let a=i.getRangeAt(o).getClientRects();for(let l=0;l<a.length;l++){let d=a[l];if(document.elementFromPoint(d.left,d.top)===e)return}}(e instanceof HTMLInputElement||e instanceof HTMLTextAreaElement)&&(t||!e.readOnly&&!e.disabled)||n.preventDefault()}var Le={};p(Le,{GetFlag:()=>I});function I(n){try{return window._wails.flags[n]}catch(e){throw new Error("Unable to retrieve flag '"+n+"': "+e,{cause:e})}}var q=!1,Q=!1,Be=!1,U=!1,z=!1,x="",kn="auto",N=0,ce=!1;u&&(ce=bn(),window._wails=window._wails||{},window._wails.setResizable=n=>{Be=n,Be||(U=z=!1,h())});var je=!1;function no(){var i,t;let n=(t=(i=window._wails)==null?void 0:i.environment)==null?void 0:t.OS;if(n==="ios"||n==="android")return!0;let e=navigator.userAgent||navigator.vendor||window.opera||"";return/android|iphone|ipad|ipod|iemobile|wpdesktop/i.test(e)}function Ie(){if(!je&&!no()){window.addEventListener("mousedown",ze,{capture:!0}),window.addEventListener("mousemove",ze,{capture:!0}),window.addEventListener("mouseup",ze,{capture:!0});for(let n of["click","contextmenu","dblclick"])window.addEventListener(n,io,{capture:!0});je=!0}}if(u){Ie(),document.addEventListener("DOMContentLoaded",Ie,{once:!0});let n=0,e=window.setInterval(()=>{if(je){window.clearInterval(e);return}Ie(),++n>100&&window.clearInterval(e)},50)}function io(n){(Q||z)&&(n.stopImmediatePropagation(),n.stopPropagation(),n.preventDefault())}var Ne=0,to=1,Ue=2;function ze(n){let e,i=n.buttons;switch(n.type){case"mousedown":e=Ne,ce||(i=N|1<<n.button);break;case"mouseup":e=to,ce||(i=N&~(1<<n.button));break;default:e=Ue,ce||(i=N);break}let t=N&~i,o=i&~N;N=i,e===Ne&&!(o&n.button)&&(t|=1<<n.button,o|=1<<n.button),(e!==Ue&&z||Q&&(e===Ne||n.button!==0))&&(n.stopImmediatePropagation(),n.stopPropagation(),n.preventDefault()),t&1&&ro(n),o&1&&oo(n),e===Ue&&so(n)}function oo(n){if(q=!1,U=!1,!J()&&n.type==="mousedown"&&n.button===0&&n.detail!==1)return;if(x){if(n.type!=="mousedown")return;U=!0;return}let e=re(n),i=window.getComputedStyle(e);q=i.getPropertyValue("--wails-draggable").trim()==="drag"&&n.offsetX-parseFloat(i.paddingLeft)<e.clientWidth&&n.offsetY-parseFloat(i.paddingTop)<e.clientHeight}function ro(n){q=!1,Q=!1,U=!1,z=!1}var ao=Object.freeze({"se-resize":"nwse-resize","sw-resize":"nesw-resize","nw-resize":"nwse-resize","ne-resize":"nesw-resize","w-resize":"ew-resize","n-resize":"ns-resize","s-resize":"ns-resize","e-resize":"ew-resize"});function h(n){n?(x||(kn=document.body.style.cursor),document.body.style.cursor=ao[n]):!n&&x&&(document.body.style.cursor=kn),x=n||""}function so(n){if(U&&x?(z=!0,C("wails:resize:"+x)):q&&(Q=!0,C("wails:drag")),Q||z){q=U=!1;return}if(!Be||!J()&&!(de()&&I("frameless"))){x&&h();return}let e=I("system.resizeHandleHeight")||5,i=I("system.resizeHandleWidth")||5,t=I("resizeCornerExtra")||10,o=Math.max(0,window.innerWidth-document.documentElement.clientWidth),r=Math.max(0,window.innerHeight-document.documentElement.clientHeight),a=window.innerWidth-o,l=window.innerHeight-r,d=n.clientX<a&&a-n.clientX<i,f=n.clientX<i,D=n.clientY<e,S=n.clientY<l&&l-n.clientY<e,W=n.clientX<a&&a-n.clientX<i+t,b=n.clientX<i+t,pe=n.clientY<e+t,fe=n.clientY<l&&l-n.clientY<e+t;!b&&!pe&&!fe&&!W?h():W&&fe?h("se-resize"):b&&fe?h("sw-resize"):b&&pe?h("nw-resize"):pe&&W?h("ne-resize"):f?h("w-resize"):D?h("n-resize"):S?h("s-resize"):d?h("e-resize"):h()}var On="--wails-non-client-region",lo="wails:runtime-config-ready",co=new Set(["caption","minimize","maximize","close"]);u&&(window._wails=window._wails||{});var Ve=!1,Fn="",He=new Set,$,Ln=!1;function In(n){let e=n.trim().toLowerCase();if(co.has(e))return e}function mo(n){if(!(n instanceof HTMLElement))return;let e=window.getComputedStyle(n),i=In(e.getPropertyValue(On));if(!i)return;let t=n.parentElement;if(t){let o=window.getComputedStyle(t);if(In(o.getPropertyValue(On))===i)return}return i}function uo(n){let e=window.getComputedStyle(n);return e.display!=="none"&&e.visibility!=="hidden"&&e.contentVisibility!=="hidden"}function wo(n){if(!(n instanceof HTMLElement))return;let e=mo(n);if(!e||!uo(n))return;let i=n.getBoundingClientRect();if(i.width<=0||i.height<=0)return;let t=window.devicePixelRatio||1,o=Math.floor(i.left*t),r=Math.floor(i.top*t),a=Math.ceil(i.right*t),l=Math.ceil(i.bottom*t);if(!(a<=o||l<=r))return{kind:e,left:o,top:r,right:a,bottom:l}}function po(){let n=[];if(document.documentElement&&n.push(document.documentElement),document.body){n.push(document.body);for(let e of document.body.querySelectorAll("*"))n.push(e)}return n}function fo(n){if(typeof ResizeObserver>"u")return;$!=null||($=new ResizeObserver(A));let e=new Set(n);for(let i of He)e.has(i)||$.unobserve(i);for(let i of e)He.has(i)||$.observe(i);He=e}function go(){Ve=!1;let n=po(),e=[],i=[];for(let o of n){let r=wo(o);r&&(e.push(r),i.push(o))}fo(i);let t=JSON.stringify({version:1,regions:e});t!==Fn&&(Fn=t,C("wails:non-client-region:"+t))}function A(){Ve||(Ve=!0,window.requestAnimationFrame(go))}function ho(){var e,i;if(Ln)return;Ln=!0,A(),new MutationObserver(A).observe(document.documentElement,{attributes:!0,childList:!0,subtree:!0}),window.addEventListener("resize",A),window.addEventListener("scroll",A,!0),(e=window.visualViewport)==null||e.addEventListener("resize",A),(i=window.visualViewport)==null||i.addEventListener("scroll",A)}function Nn(){var i,t;let n=(i=window._wails.environment)==null?void 0:i.OS;if(n===void 0)return!1;let e=(t=window._wails.flags)==null?void 0:t.nonClientRegionTracking;return n==="windows"&&e===!0&&ae(ho),!0}u&&!Nn()&&window.addEventListener(lo,Nn,{once:!0});var Ke={};p(Ke,{Hide:()=>vo,Quit:()=>Do,Show:()=>Co});var Ze=w(c.Application),Wo=0,bo=1,yo=2;function vo(){return Ze(Wo)}function Co(){return Ze(bo)}function Do(){return Ze(yo)}var Qe={};p(Qe,{ByID:()=>Vo,ByName:()=>Ho,Call:()=>qe,RuntimeError:()=>_});var zn=Function.prototype.toString,B=typeof Reflect=="object"&&Reflect!==null&&Reflect.apply,_e,me;if(typeof B=="function"&&typeof Object.defineProperty=="function")try{_e=Object.defineProperty({},"length",{get:function(){throw me}}),me={},B(function(){throw 42},null,_e)}catch(n){n!==me&&(B=null)}else B=null;var So=/^\s*class\b/,Ye=function(e){try{var i=zn.call(e);return So.test(i)}catch(t){return!1}},Ge=function(e){try{return Ye(e)?!1:(zn.call(e),!0)}catch(i){return!1}},ue=Object.prototype.toString,Po="[object Object]",To="[object Function]",Mo="[object GeneratorFunction]",Eo="[object HTMLAllCollection]",xo="[object HTML document.all class]",Ao="[object HTMLCollection]",Ro=typeof Symbol=="function"&&!!Symbol.toStringTag,ko=!(0 in[,]),Xe=function(){return!1};typeof document=="object"&&(Un=document.all,ue.call(Un)===ue.call(document.all)&&(Xe=function(e){if((ko||!e)&&(typeof e>"u"||typeof e=="object"))try{var i=ue.call(e);return(i===Eo||i===xo||i===Ao||i===Po)&&e("")==null}catch(t){}return!1}));var Un;function Oo(n){if(Xe(n))return!0;if(!n||typeof n!="function"&&typeof n!="object")return!1;try{B(n,null,_e)}catch(e){if(e!==me)return!1}return!Ye(n)&&Ge(n)}function Fo(n){if(Xe(n))return!0;if(!n||typeof n!="function"&&typeof n!="object")return!1;if(Ro)return Ge(n);if(Ye(n))return!1;var e=ue.call(n);return e!==To&&e!==Mo&&!/^\[object HTML/.test(e)?!1:Ge(n)}var P=B?Oo:Fo;var H=class extends Error{constructor(e,i){super(e,i),this.name="CancelError"}},T=class extends Error{constructor(e,i,t){super((t!=null?t:"Unhandled rejection in cancelled promise.")+" Reason: "+Lo(i),{cause:i}),this.promise=e,this.name="CancelledRejectionError"}},v=Symbol("barrier"),Je=Symbol("cancelImpl"),Vn,Bn=(Vn=Symbol.species)!=null?Vn:Symbol("speciesPolyfill"),ee=class n extends Promise{constructor(e,i){let t,o;if(super((d,f)=>{t=d,o=f}),this.constructor[Bn]!==Promise)throw new TypeError("CancellablePromise does not support transparent subclassing. Please refrain from overriding the [Symbol.species] static property.");let r={promise:this,resolve:t,reject:o,get oncancelled(){return i!=null?i:null},set oncancelled(d){i=d!=null?d:void 0}},a={get root(){return a},resolving:!1,settled:!1};Object.defineProperties(this,{[v]:{configurable:!1,enumerable:!1,writable:!0,value:null},[Je]:{configurable:!1,enumerable:!1,writable:!1,value:Zn(r,a)}});let l=_n(r,a);try{e(Kn(r,a),l)}catch(d){a.resolving||l(d)}}cancel(e){return new n(i=>{Promise.all([this[Je](new H("Promise cancelled.",{cause:e})),Io(this)]).then(()=>i(),()=>i())})}cancelOn(e){return e.aborted?this.cancel(e.reason):e.addEventListener("abort",()=>{this.cancel(e.reason)},{capture:!0}),this}then(e,i,t){if(!(this instanceof n))throw new TypeError("CancellablePromise.prototype.then called on an invalid object.");if(P(e)||(e=jn),P(i)||(i=Hn),e===jn&&i==Hn)return new n(r=>r(this));let o={};return this[v]=o,new n((r,a)=>{super.then(l=>{var d;this[v]===o&&(this[v]=null),(d=o.resolve)==null||d.call(o);try{r(e(l))}catch(f){a(f)}},l=>{var d;this[v]===o&&(this[v]=null),(d=o.resolve)==null||d.call(o);try{r(i(l))}catch(f){a(f)}})},async r=>{try{return t==null?void 0:t(r)}finally{await this.cancel(r)}})}catch(e,i){return this.then(void 0,e,i)}finally(e,i){if(!(this instanceof n))throw new TypeError("CancellablePromise.prototype.finally called on an invalid object.");return P(e)?this.then(t=>n.resolve(e()).then(()=>t),t=>n.resolve(e()).then(()=>{throw t}),i):this.then(e,e,i)}static get[(v,Je,Bn)](){return Promise}static all(e){let i=Array.from(e),t=i.length===0?n.resolve(i):new n((o,r)=>{Promise.all(i).then(o,r)},o=>we(t,i,o));return t}static allSettled(e){let i=Array.from(e),t=i.length===0?n.resolve(i):new n((o,r)=>{Promise.allSettled(i).then(o,r)},o=>we(t,i,o));return t}static any(e){let i=Array.from(e),t=i.length===0?n.resolve(i):new n((o,r)=>{Promise.any(i).then(o,r)},o=>we(t,i,o));return t}static race(e){let i=Array.from(e),t=new n((o,r)=>{Promise.race(i).then(o,r)},o=>we(t,i,o));return t}static cancel(e){let i=new n(()=>{});return i.cancel(e),i}static timeout(e,i){let t=new n(()=>{});return AbortSignal&&typeof AbortSignal=="function"&&AbortSignal.timeout&&typeof AbortSignal.timeout=="function"?AbortSignal.timeout(e).addEventListener("abort",()=>{t.cancel(i)}):setTimeout(()=>{t.cancel(i)},e),t}static sleep(e,i){return new n(t=>{setTimeout(()=>t(i),e)})}static reject(e){return new n((i,t)=>t(e))}static resolve(e){return e instanceof n?e:new n(i=>i(e))}static withResolvers(){let e={oncancelled:null};return e.promise=new n((i,t)=>{e.resolve=i,e.reject=t},i=>{var t;(t=e.oncancelled)==null||t.call(e,i)}),e}};function Zn(n,e){let i;return t=>{if(e.settled||(e.settled=!0,e.reason=t,n.reject(t),Promise.prototype.then.call(n.promise,void 0,o=>{if(o!==t)throw o})),!(!e.reason||!n.oncancelled))return i=new Promise(o=>{try{o(n.oncancelled(e.reason.cause))}catch(r){Promise.reject(new T(n.promise,r,"Unhandled exception in oncancelled callback."))}}).catch(o=>{Promise.reject(new T(n.promise,o,"Unhandled rejection in oncancelled callback."))}),n.oncancelled=null,i}}function Kn(n,e){return i=>{if(!e.resolving){if(e.resolving=!0,i===n.promise){if(e.settled)return;e.settled=!0,n.reject(new TypeError("A promise cannot be resolved with itself."));return}if(i!=null&&(typeof i=="object"||typeof i=="function")){let t;try{t=i.then}catch(o){e.settled=!0,n.reject(o);return}if(P(t)){try{let a=i.cancel;if(P(a)){let l=d=>{Reflect.apply(a,i,[d])};e.reason?Zn(Z(V({},n),{oncancelled:l}),e)(e.reason):n.oncancelled=l}}catch(a){}let o={root:e.root,resolving:!1,get settled(){return this.root.settled},set settled(a){this.root.settled=a},get reason(){return this.root.reason}},r=_n(n,o);try{Reflect.apply(t,i,[Kn(n,o),r])}catch(a){r(a)}return}}e.settled||(e.settled=!0,n.resolve(i))}}}function _n(n,e){return i=>{if(!e.resolving)if(e.resolving=!0,e.settled){try{if(i instanceof H&&e.reason instanceof H&&Object.is(i.cause,e.reason.cause))return}catch(t){}Promise.reject(new T(n.promise,i))}else e.settled=!0,n.reject(i)}}function we(n,e,i){let t=[];for(let o of e){let r;try{if(!P(o.then)||(r=o.cancel,!P(r)))continue}catch(l){continue}let a;try{a=Reflect.apply(r,o,[i])}catch(l){Promise.reject(new T(n,l,"Unhandled exception in cancel method."));continue}a&&t.push((a instanceof Promise?a:Promise.resolve(a)).catch(l=>{Promise.reject(new T(n,l,"Unhandled rejection in cancel method."))}))}return Promise.all(t)}function jn(n){return n}function Hn(n){throw n}function Lo(n){try{if(n instanceof Error||typeof n!="object"||n.toString!==Object.prototype.toString)return""+n}catch(e){}try{return JSON.stringify(n)}catch(e){}try{return Object.prototype.toString.call(n)}catch(e){}return"<could not convert error to string>"}function Io(n){var i;let e=(i=n[v])!=null?i:{};return"promise"in e||Object.assign(e,j()),n[v]==null&&(e.resolve(),n[v]=e),e.promise}var j=Promise.withResolvers;j&&typeof j=="function"?j=j.bind(Promise):j=function(){let n,e;return{promise:new Promise((t,o)=>{n=t,e=o}),resolve:n,reject:e}};u&&(window._wails=window._wails||{});var No=w(c.Call),Uo=w(c.CancelCall),ne=new Map,zo=0,Bo=0;function jo(){let n;do n=R();while(ne.has(n));return n}function qe(n){let e=jo(),i=ee.withResolvers();ne.set(e,{resolve:i.resolve,reject:i.reject});let t=No(zo,Object.assign({"call-id":e},n)),o=!0;t.then(a=>{o=!1,ne.delete(e),i.resolve(a)},a=>{o=!1,ne.delete(e),i.reject(a)});let r=()=>(ne.delete(e),Uo(Bo,{"call-id":e}).catch(a=>{}));return i.oncancelled=()=>o?r():t.then(r),i.promise}function Ho(n,...e){return qe({methodName:n,args:e})}function Vo(n,...e){return qe({methodID:n,args:e})}var $e={};p($e,{SetText:()=>_o,Text:()=>Go});var Gn=w(c.Clipboard),Zo=0,Ko=1;function _o(n){return Gn(Zo,{text:n})}function Go(){return Gn(Ko)}var en={};p(en,{GetAll:()=>$o,GetByID:()=>ir,GetByIndex:()=>tr,GetCurrent:()=>nr,GetPrimary:()=>er});var ie=w(c.Screens),Yo=0,Xo=1,Jo=2,qo=3,Qo=4;function $o(){return ie(Yo)}function er(){return ie(Xo)}function nr(){return ie(Jo)}function ir(n){return ie(qo,{id:n})}function tr(n){return ie(Qo,{index:n})}var on={};p(on,{Device:()=>tn,Haptics:()=>nn});var Yn=w(c.IOS),or=0,rr=1,nn;(e=>{function n(i="medium"){return Yn(or,{style:i})}e.Impact=n})(nn||(nn={}));var tn;(e=>{function n(){return Yn(rr)}e.Info=n})(tn||(tn={}));var dn={};p(dn,{Device:()=>an,Haptics:()=>rn,Toast:()=>sn});var ln=w(c.Android),ar=0,sr=1,lr=2,rn;(e=>{function n(i=100){return ln(ar,{duration:i})}e.Vibrate=n})(rn||(rn={}));var an;(e=>{function n(){return ln(sr)}e.Info=n})(an||(an={}));var sn;(e=>{function n(i){return ln(lr,{message:i})}e.Show=n})(sn||(sn={}));var cn={};p(cn,{Events:()=>dr});var dr=Object.freeze({CheckStarted:"wails:updater:check-started",UpdateAvailable:"wails:updater:update-available",NoUpdate:"wails:updater:no-update",DownloadStarted:"wails:updater:download-started",DownloadProgress:"wails:updater:download-progress",DownloadComplete:"wails:updater:download-complete",Verifying:"wails:updater:verifying",Installing:"wails:updater:installing",UpdateReady:"wails:updater:update-ready",Error:"wails:updater:error",Meta:"wails:updater:meta",User:Object.freeze({Install:"wails:updater:user:install",Restart:"wails:updater:user:restart",Skip:"wails:updater:user:skip",Remind:"wails:updater:user:remind",Cancel:"wails:updater:user:cancel"}),Window:Object.freeze({Ready:"wails:updater:window:ready"})});u&&(window._wails=window._wails||{});u&&(window._wails.invoke=C,window._wails.clientId=k);u&&(window._wails.handlePlatformFileDrop=F.HandlePlatformFileDrop.bind(F));u&&(window._wails.handleDragEnter=Dn,window._wails.handleDragLeave=Sn,window._wails.handleDragOver=Pn);u&&C("wails:runtime:ready");function Xn(n){return fetch(n,{method:"HEAD"}).then(e=>{if(e.ok&&(e.headers.get("content-type")||"").toLowerCase().includes("javascript")){let t=document.createElement("script");t.src=n,document.head.appendChild(t)}}).catch(()=>{})}u&&Xn("/wails/custom.js");export{dn as Android,Ke as Application,he as Browser,Qe as Call,H as CancelError,ee as CancellablePromise,T as CancelledRejectionError,$e as Clipboard,ye as Create,be as Dialogs,De as Events,Le as Flags,on as IOS,en as Screens,Fe as System,cn as Updater,xe as WML,F as Window,k as clientId,hn as getTransport,Xn as loadOptionalScript,c as objectNames,gn as setTransport}; diff --git a/v3/internal/runtime/Taskfile.yaml b/v3/internal/runtime/Taskfile.yaml index 4a2a2ccf3af..c871d03fa12 100644 --- a/v3/internal/runtime/Taskfile.yaml +++ b/v3/internal/runtime/Taskfile.yaml @@ -2,9 +2,15 @@ version: "3" +vars: + ESBUILD: desktop/@wailsio/runtime/node_modules/.bin/esbuild + tasks: install-deps: internal: true + # once: build:debug and build:production dep on this in parallel; two + # concurrent npm installs in the same directory corrupt node_modules. + run: once dir: desktop/@wailsio/runtime sources: - package.json @@ -27,13 +33,17 @@ tasks: build:debug: internal: true + deps: + - install-deps cmds: - - npx esbuild@latest desktop/@wailsio/runtime/src/index.ts --inject:desktop/compiled/main.js --format=esm --target=safari11 --bundle --ignore-annotations --tree-shaking=true --sourcemap=inline --outfile=../assetserver/bundledassets/runtime.debug.js --define:DEBUG=true + - "{{.ESBUILD}} desktop/@wailsio/runtime/src/index.ts --inject:desktop/compiled/main.js --format=esm --target=safari11 --bundle --ignore-annotations --tree-shaking=true --sourcemap=inline --outfile=../assetserver/bundledassets/runtime.debug.js --define:DEBUG=true" build:production: internal: true + deps: + - install-deps cmds: - - npx esbuild@latest desktop/@wailsio/runtime/src/index.ts --inject:desktop/compiled/main.js --format=esm --target=safari11 --bundle --ignore-annotations --tree-shaking=true --minify --outfile=../assetserver/bundledassets/runtime.js --define:DEBUG=false --drop:console + - "{{.ESBUILD}} desktop/@wailsio/runtime/src/index.ts --inject:desktop/compiled/main.js --format=esm --target=safari11 --bundle --ignore-annotations --tree-shaking=true --minify --outfile=../assetserver/bundledassets/runtime.js --define:DEBUG=false --drop:console" build:docs: internal: true @@ -51,6 +61,12 @@ tasks: cmds: - npm run build:docs:md + build:assets: + desc: Rebuild only the embedded runtime bundles (bundledassets); CI verifies PR bundles against this exact output. + deps: + - build:debug + - build:production + build:runtime: internal: true deps: diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/hierarchy.js b/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/hierarchy.js index 846a32cf3aa..5240fa47cd8 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/hierarchy.js +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/assets/hierarchy.js @@ -1 +1 @@ -window.hierarchyData = "eJylj7EKg0AQRP9l6otB0ajXpk2RXkQuuuLhesLdpRL/PWiIpDAhkGZZdpidNxPsOHoHWcSZyJOoFLDUMtVej8ZBToizZRo1ECTOytTErG5MVzsO2tFF9wSBXpsGMkpOAnfLkNDGk21VTe64bwo6PzAEalbOQcK75rB8OWzORew0N5YMZJGG5SyQhl9pNpIwyl4ka8AuxkeE52EWyJPoLe/3ytW6G8VV8GfleX4AEQ+NYw==" \ No newline at end of file +window.hierarchyData = "eJylj80KwjAQhN9lzrFSsT/m6tWDdyklpisGtwkk8VTy7tKKxUMVwcuy7DA73wzwzsUAedrWYleUjYCnC5OOxtkAOWBbj9OqniCxV1YTszozHb3rTaCDuREEbsZ2kJuiFLh7hoSxkfxFaQrrZVN2jT1DQLMKARIxdKvxy2p2juLVcOfJQp6qvEkCVf6VZibJN/WLZApYxPiI8DwkgV1RvuX9Xrmddqu4zf6snNIDGWeNaw==" \ No newline at end of file diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/Call.RuntimeError.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/Call.RuntimeError.html index 1b8b335865c..44ea423dcf5 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/Call.RuntimeError.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/Call.RuntimeError.html @@ -1,6 +1,6 @@ <!DOCTYPE html><html class="default" lang="en" data-base="../"><head><meta charset="utf-8"/><meta http-equiv="x-ua-compatible" content="IE=edge"/><title>RuntimeError | @wailsio/runtime
@wailsio/runtime
    Preparing search index...

    Class RuntimeError

    Exception class that will be thrown in case the bound method returns an error. The value of the RuntimeError#name property is "RuntimeError".

    -

    Hierarchy

    Index

    Constructors

    Hierarchy

    Index

    Constructors

    Properties

    cause? message name @@ -12,7 +12,7 @@

    Constructors

    • Constructs a new RuntimeError instance.

      Parameters

      • Optionalmessage: string

        The error message.

      • Optionaloptions: ErrorOptions

        Options to be forwarded to the Error constructor.

        -

      Returns RuntimeError

    Properties

    cause?: unknown
    message: string
    name: string
    stack?: string
    stackTraceLimit: number

    The Error.stackTraceLimit property specifies the number of stack frames +

    Returns RuntimeError

    Properties

    cause?: unknown
    message: string
    name: string
    stack?: string
    stackTraceLimit: number

    The Error.stackTraceLimit property specifies the number of stack frames collected by a stack trace (whether generated by new Error().stack or Error.captureStackTrace(obj)).

    The default value is 10 but may be set to any valid JavaScript number. Changes diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/_internal_.Window.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/_internal_.Window.html index 88b140ec613..fd2b1aa40ba 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/_internal_.Window.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/classes/_internal_.Window.html @@ -69,8 +69,8 @@

    • Handles file drops originating from platform-specific code (e.g., macOS/Linux native drag-and-drop). Gathers information about the drop target element and sends it back to the Go backend.

      Parameters

      • filenames: string[]

        An array of file paths (strings) that were dropped.

        -
      • x: number

        The x-coordinate of the drop event (CSS pixels).

        -
      • y: number

        The y-coordinate of the drop event (CSS pixels).

        +
      • x: number

        The x-coordinate of the drop event, in logical (CSS) pixels relative to the webview.

        +
      • y: number

        The y-coordinate of the drop event, in logical (CSS) pixels relative to the webview.

      Returns void

    • Hides the window.

      diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.ByID.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.ByID.html index ecbc6cfa64a..d666003938b 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.ByID.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.ByID.html @@ -3,4 +3,4 @@

      Parameters

      • methodID: number

        The ID of the method to call.

      • ...args: any[]

        The arguments to pass to the method.

      Returns CancellablePromise<any>

      The result of the method call.

      -
    +
    diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.ByName.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.ByName.html index 73f3660d1ae..3063a66efeb 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.ByName.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.ByName.html @@ -3,4 +3,4 @@

    Parameters

    Returns CancellablePromise<any>

    The result of the method call.

    -
    +
    diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.Call.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.Call.html index c533a4537a5..b676d1b7f41 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.Call.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/Call.Call.html @@ -6,4 +6,4 @@ by the application- or service-level error marshaling functions.

    Parameters

    Returns CancellablePromise<any>

    The result of the call.

    -
    +
    diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/getTransport.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/getTransport.html index e0069b934d5..9d2e24f1a20 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/getTransport.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/getTransport.html @@ -1,2 +1,2 @@ getTransport | @wailsio/runtime
    @wailsio/runtime
      Preparing search index...

      Function getTransport

      +

      Returns RuntimeTransport | null

      diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/setTransport.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/setTransport.html index d6aef327174..a1618820b29 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/setTransport.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/functions/setTransport.html @@ -5,4 +5,4 @@

      Returns void

      import { setTransport } from '/wails/runtime.js';

      const wsTransport = {
      call: async (objectID, method, windowName, args) => {
      // Your WebSocket implementation
      }
      };

      setTransport(wsTransport);
      -
      +
      diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/hierarchy.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/hierarchy.html index 280f8921da6..dde2eb5948a 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/hierarchy.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/hierarchy.html @@ -1 +1 @@ -@wailsio/runtime
      @wailsio/runtime
        Preparing search index...
        +@wailsio/runtime
        @wailsio/runtime
          Preparing search index...
          diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/RuntimeTransport.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/RuntimeTransport.html index 695ed07bf80..f92ec78f6ad 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/RuntimeTransport.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/interfaces/RuntimeTransport.html @@ -1,11 +1,11 @@ RuntimeTransport | @wailsio/runtime
          @wailsio/runtime
            Preparing search index...

            Interface RuntimeTransport

            RuntimeTransport defines the interface for custom IPC transport implementations. Implement this interface to use WebSockets, custom protocols, or any other transport mechanism instead of the default HTTP fetch.

            -
            interface RuntimeTransport {
                call(
                    objectID: number,
                    method: number,
                    windowName: string,
                    args: any,
                ): Promise<any>;
            }
            Index

            Methods

            interface RuntimeTransport {
                call(
                    objectID: number,
                    method: number,
                    windowName: string,
                    args: any,
                ): Promise<any>;
            }
            Index

            Methods

            Methods

            • Send a runtime call and return the response.

              Parameters

              • objectID: number

                The Wails object ID (0=Call, 1=Clipboard, etc.)

              • method: number

                The method ID to call

              • windowName: string

                Optional window name

              • args: any

                Arguments to pass (will be JSON stringified if present)

              Returns Promise<any>

              Promise that resolves with the response data

              -
            +
            diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Events.Types.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Events.Types.html index 6c808e97f30..61d84b5b349 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Events.Types.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/Events.Types.html @@ -1 +1 @@ -Types | @wailsio/runtime
            @wailsio/runtime
              Preparing search index...

              Variable TypesConst

              Types: Readonly<
                  {
                      Android: Readonly<
                          {
                              ActivityCreated: "android:ActivityCreated";
                              ActivityDestroyed: "android:ActivityDestroyed";
                              ActivityPaused: "android:ActivityPaused";
                              ActivityResumed: "android:ActivityResumed";
                              ActivityStarted: "android:ActivityStarted";
                              ActivityStopped: "android:ActivityStopped";
                              ApplicationLowMemory: "android:ApplicationLowMemory";
                              BatteryChanged: "android:BatteryChanged";
                              NetworkChanged: "android:NetworkChanged";
                              ScreenLocked: "android:ScreenLocked";
                              ScreenUnlocked: "android:ScreenUnlocked";
                              ThemeChanged: "android:ThemeChanged";
                              WebViewPageFinished: "android:WebViewPageFinished";
                              WebViewPageStarted: "android:WebViewPageStarted";
                          },
                      >;
                      Common: Readonly<
                          {
                              ApplicationLaunchedWithUrl: "common:ApplicationLaunchedWithUrl";
                              ApplicationOpenedWithFile: "common:ApplicationOpenedWithFile";
                              ApplicationStarted: "common:ApplicationStarted";
                              BatteryChanged: "common:BatteryChanged";
                              LowMemory: "common:LowMemory";
                              NetworkChanged: "common:NetworkChanged";
                              ScreenLocked: "common:ScreenLocked";
                              ScreenUnlocked: "common:ScreenUnlocked";
                              SystemDidWake: "common:SystemDidWake";
                              SystemWillSleep: "common:SystemWillSleep";
                              ThemeChanged: "common:ThemeChanged";
                              WindowClosing: "common:WindowClosing";
                              WindowDidMove: "common:WindowDidMove";
                              WindowDidResize: "common:WindowDidResize";
                              WindowDPIChanged: "common:WindowDPIChanged";
                              WindowFilesDropped: "common:WindowFilesDropped";
                              WindowFocus: "common:WindowFocus";
                              WindowFullscreen: "common:WindowFullscreen";
                              WindowHide: "common:WindowHide";
                              WindowLostFocus: "common:WindowLostFocus";
                              WindowMaximise: "common:WindowMaximise";
                              WindowMinimise: "common:WindowMinimise";
                              WindowRestore: "common:WindowRestore";
                              WindowRuntimeReady: "common:WindowRuntimeReady";
                              WindowShow: "common:WindowShow";
                              WindowToggleFrameless: "common:WindowToggleFrameless";
                              WindowUnFullscreen: "common:WindowUnFullscreen";
                              WindowUnMaximise: "common:WindowUnMaximise";
                              WindowUnMinimise: "common:WindowUnMinimise";
                              WindowZoom: "common:WindowZoom";
                              WindowZoomIn: "common:WindowZoomIn";
                              WindowZoomOut: "common:WindowZoomOut";
                              WindowZoomReset: "common:WindowZoomReset";
                          },
                      >;
                      iOS: Readonly<
                          {
                              ApplicationDidBecomeActive: "ios:ApplicationDidBecomeActive";
                              ApplicationDidEnterBackground: "ios:ApplicationDidEnterBackground";
                              ApplicationDidFinishLaunching: "ios:ApplicationDidFinishLaunching";
                              ApplicationDidReceiveMemoryWarning: "ios:ApplicationDidReceiveMemoryWarning";
                              ApplicationWillEnterForeground: "ios:ApplicationWillEnterForeground";
                              ApplicationWillResignActive: "ios:ApplicationWillResignActive";
                              ApplicationWillTerminate: "ios:ApplicationWillTerminate";
                              BatteryChanged: "ios:BatteryChanged";
                              NetworkChanged: "ios:NetworkChanged";
                              ScreenLocked: "ios:ScreenLocked";
                              ScreenUnlocked: "ios:ScreenUnlocked";
                              ThemeChanged: "ios:ThemeChanged";
                              WebViewDecidePolicyForNavigationAction: "ios:WebViewDecidePolicyForNavigationAction";
                              WebViewDidFailNavigation: "ios:WebViewDidFailNavigation";
                              WebViewDidFinishNavigation: "ios:WebViewDidFinishNavigation";
                              WebViewDidStartNavigation: "ios:WebViewDidStartNavigation";
                              WindowDidAppear: "ios:WindowDidAppear";
                              WindowDidDisappear: "ios:WindowDidDisappear";
                              WindowDidLoad: "ios:WindowDidLoad";
                              WindowOrientationChanged: "ios:WindowOrientationChanged";
                              WindowSafeAreaInsetsChanged: "ios:WindowSafeAreaInsetsChanged";
                              WindowTouchBegan: "ios:WindowTouchBegan";
                              WindowTouchCancelled: "ios:WindowTouchCancelled";
                              WindowTouchEnded: "ios:WindowTouchEnded";
                              WindowTouchMoved: "ios:WindowTouchMoved";
                              WindowWillAppear: "ios:WindowWillAppear";
                              WindowWillDisappear: "ios:WindowWillDisappear";
                          },
                      >;
                      Linux: Readonly<
                          {
                              ApplicationStartup: "linux:ApplicationStartup";
                              SystemDidWake: "linux:SystemDidWake";
                              SystemThemeChanged: "linux:SystemThemeChanged";
                              SystemWillSleep: "linux:SystemWillSleep";
                              WindowDeleteEvent: "linux:WindowDeleteEvent";
                              WindowDidMove: "linux:WindowDidMove";
                              WindowDidResize: "linux:WindowDidResize";
                              WindowFocusIn: "linux:WindowFocusIn";
                              WindowFocusOut: "linux:WindowFocusOut";
                              WindowLoadCommitted: "linux:WindowLoadCommitted";
                              WindowLoadFinished: "linux:WindowLoadFinished";
                              WindowLoadRedirected: "linux:WindowLoadRedirected";
                              WindowLoadStarted: "linux:WindowLoadStarted";
                          },
                      >;
                      Mac: Readonly<
                          {
                              ApplicationDidBecomeActive: "mac:ApplicationDidBecomeActive";
                              ApplicationDidChangeBackingProperties: "mac:ApplicationDidChangeBackingProperties";
                              ApplicationDidChangeEffectiveAppearance: "mac:ApplicationDidChangeEffectiveAppearance";
                              ApplicationDidChangeIcon: "mac:ApplicationDidChangeIcon";
                              ApplicationDidChangeOcclusionState: "mac:ApplicationDidChangeOcclusionState";
                              ApplicationDidChangeScreenParameters: "mac:ApplicationDidChangeScreenParameters";
                              ApplicationDidChangeStatusBarFrame: "mac:ApplicationDidChangeStatusBarFrame";
                              ApplicationDidChangeStatusBarOrientation: "mac:ApplicationDidChangeStatusBarOrientation";
                              ApplicationDidChangeTheme: "mac:ApplicationDidChangeTheme";
                              ApplicationDidFinishLaunching: "mac:ApplicationDidFinishLaunching";
                              ApplicationDidHide: "mac:ApplicationDidHide";
                              ApplicationDidResignActive: "mac:ApplicationDidResignActive";
                              ApplicationDidUnhide: "mac:ApplicationDidUnhide";
                              ApplicationDidUpdate: "mac:ApplicationDidUpdate";
                              ApplicationDidWake: "mac:ApplicationDidWake";
                              ApplicationScreensDidSleep: "mac:ApplicationScreensDidSleep";
                              ApplicationScreensDidWake: "mac:ApplicationScreensDidWake";
                              ApplicationShouldHandleReopen: "mac:ApplicationShouldHandleReopen";
                              ApplicationWillBecomeActive: "mac:ApplicationWillBecomeActive";
                              ApplicationWillFinishLaunching: "mac:ApplicationWillFinishLaunching";
                              ApplicationWillHide: "mac:ApplicationWillHide";
                              ApplicationWillResignActive: "mac:ApplicationWillResignActive";
                              ApplicationWillSleep: "mac:ApplicationWillSleep";
                              ApplicationWillTerminate: "mac:ApplicationWillTerminate";
                              ApplicationWillUnhide: "mac:ApplicationWillUnhide";
                              ApplicationWillUpdate: "mac:ApplicationWillUpdate";
                              MenuDidAddItem: "mac:MenuDidAddItem";
                              MenuDidBeginTracking: "mac:MenuDidBeginTracking";
                              MenuDidClose: "mac:MenuDidClose";
                              MenuDidDisplayItem: "mac:MenuDidDisplayItem";
                              MenuDidEndTracking: "mac:MenuDidEndTracking";
                              MenuDidHighlightItem: "mac:MenuDidHighlightItem";
                              MenuDidOpen: "mac:MenuDidOpen";
                              MenuDidPopUp: "mac:MenuDidPopUp";
                              MenuDidRemoveItem: "mac:MenuDidRemoveItem";
                              MenuDidSendAction: "mac:MenuDidSendAction";
                              MenuDidSendActionToItem: "mac:MenuDidSendActionToItem";
                              MenuDidUpdate: "mac:MenuDidUpdate";
                              MenuWillAddItem: "mac:MenuWillAddItem";
                              MenuWillBeginTracking: "mac:MenuWillBeginTracking";
                              MenuWillDisplayItem: "mac:MenuWillDisplayItem";
                              MenuWillEndTracking: "mac:MenuWillEndTracking";
                              MenuWillHighlightItem: "mac:MenuWillHighlightItem";
                              MenuWillOpen: "mac:MenuWillOpen";
                              MenuWillPopUp: "mac:MenuWillPopUp";
                              MenuWillRemoveItem: "mac:MenuWillRemoveItem";
                              MenuWillSendAction: "mac:MenuWillSendAction";
                              MenuWillSendActionToItem: "mac:MenuWillSendActionToItem";
                              MenuWillUpdate: "mac:MenuWillUpdate";
                              WebViewDidCommitNavigation: "mac:WebViewDidCommitNavigation";
                              WebViewDidFinishNavigation: "mac:WebViewDidFinishNavigation";
                              WebViewDidReceiveServerRedirectForProvisionalNavigation: "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation";
                              WebViewDidStartProvisionalNavigation: "mac:WebViewDidStartProvisionalNavigation";
                              WindowDidBecomeKey: "mac:WindowDidBecomeKey";
                              WindowDidBecomeMain: "mac:WindowDidBecomeMain";
                              WindowDidBeginSheet: "mac:WindowDidBeginSheet";
                              WindowDidChangeAlpha: "mac:WindowDidChangeAlpha";
                              WindowDidChangeBackingLocation: "mac:WindowDidChangeBackingLocation";
                              WindowDidChangeBackingProperties: "mac:WindowDidChangeBackingProperties";
                              WindowDidChangeCollectionBehavior: "mac:WindowDidChangeCollectionBehavior";
                              WindowDidChangeEffectiveAppearance: "mac:WindowDidChangeEffectiveAppearance";
                              WindowDidChangeOcclusionState: "mac:WindowDidChangeOcclusionState";
                              WindowDidChangeOrderingMode: "mac:WindowDidChangeOrderingMode";
                              WindowDidChangeScreen: "mac:WindowDidChangeScreen";
                              WindowDidChangeScreenParameters: "mac:WindowDidChangeScreenParameters";
                              WindowDidChangeScreenProfile: "mac:WindowDidChangeScreenProfile";
                              WindowDidChangeScreenSpace: "mac:WindowDidChangeScreenSpace";
                              WindowDidChangeScreenSpaceProperties: "mac:WindowDidChangeScreenSpaceProperties";
                              WindowDidChangeSharingType: "mac:WindowDidChangeSharingType";
                              WindowDidChangeSpace: "mac:WindowDidChangeSpace";
                              WindowDidChangeSpaceOrderingMode: "mac:WindowDidChangeSpaceOrderingMode";
                              WindowDidChangeTitle: "mac:WindowDidChangeTitle";
                              WindowDidChangeToolbar: "mac:WindowDidChangeToolbar";
                              WindowDidDeminiaturize: "mac:WindowDidDeminiaturize";
                              WindowDidEndSheet: "mac:WindowDidEndSheet";
                              WindowDidEnterFullScreen: "mac:WindowDidEnterFullScreen";
                              WindowDidEnterVersionBrowser: "mac:WindowDidEnterVersionBrowser";
                              WindowDidExitFullScreen: "mac:WindowDidExitFullScreen";
                              WindowDidExitVersionBrowser: "mac:WindowDidExitVersionBrowser";
                              WindowDidExpose: "mac:WindowDidExpose";
                              WindowDidFocus: "mac:WindowDidFocus";
                              WindowDidMiniaturize: "mac:WindowDidMiniaturize";
                              WindowDidMove: "mac:WindowDidMove";
                              WindowDidOrderOffScreen: "mac:WindowDidOrderOffScreen";
                              WindowDidOrderOnScreen: "mac:WindowDidOrderOnScreen";
                              WindowDidResignKey: "mac:WindowDidResignKey";
                              WindowDidResignMain: "mac:WindowDidResignMain";
                              WindowDidResize: "mac:WindowDidResize";
                              WindowDidUpdate: "mac:WindowDidUpdate";
                              WindowDidUpdateAlpha: "mac:WindowDidUpdateAlpha";
                              WindowDidUpdateCollectionBehavior: "mac:WindowDidUpdateCollectionBehavior";
                              WindowDidUpdateCollectionProperties: "mac:WindowDidUpdateCollectionProperties";
                              WindowDidUpdateShadow: "mac:WindowDidUpdateShadow";
                              WindowDidUpdateTitle: "mac:WindowDidUpdateTitle";
                              WindowDidUpdateToolbar: "mac:WindowDidUpdateToolbar";
                              WindowDidZoom: "mac:WindowDidZoom";
                              WindowFileDraggingEntered: "mac:WindowFileDraggingEntered";
                              WindowFileDraggingExited: "mac:WindowFileDraggingExited";
                              WindowFileDraggingPerformed: "mac:WindowFileDraggingPerformed";
                              WindowHide: "mac:WindowHide";
                              WindowMaximise: "mac:WindowMaximise";
                              WindowMinimise: "mac:WindowMinimise";
                              WindowShouldClose: "mac:WindowShouldClose";
                              WindowShow: "mac:WindowShow";
                              WindowUnMaximise: "mac:WindowUnMaximise";
                              WindowUnMinimise: "mac:WindowUnMinimise";
                              WindowWillBecomeKey: "mac:WindowWillBecomeKey";
                              WindowWillBecomeMain: "mac:WindowWillBecomeMain";
                              WindowWillBeginSheet: "mac:WindowWillBeginSheet";
                              WindowWillChangeOrderingMode: "mac:WindowWillChangeOrderingMode";
                              WindowWillClose: "mac:WindowWillClose";
                              WindowWillDeminiaturize: "mac:WindowWillDeminiaturize";
                              WindowWillEnterFullScreen: "mac:WindowWillEnterFullScreen";
                              WindowWillEnterVersionBrowser: "mac:WindowWillEnterVersionBrowser";
                              WindowWillExitFullScreen: "mac:WindowWillExitFullScreen";
                              WindowWillExitVersionBrowser: "mac:WindowWillExitVersionBrowser";
                              WindowWillFocus: "mac:WindowWillFocus";
                              WindowWillMiniaturize: "mac:WindowWillMiniaturize";
                              WindowWillMove: "mac:WindowWillMove";
                              WindowWillOrderOffScreen: "mac:WindowWillOrderOffScreen";
                              WindowWillOrderOnScreen: "mac:WindowWillOrderOnScreen";
                              WindowWillResignMain: "mac:WindowWillResignMain";
                              WindowWillResize: "mac:WindowWillResize";
                              WindowWillUnfocus: "mac:WindowWillUnfocus";
                              WindowWillUpdate: "mac:WindowWillUpdate";
                              WindowWillUpdateAlpha: "mac:WindowWillUpdateAlpha";
                              WindowWillUpdateCollectionBehavior: "mac:WindowWillUpdateCollectionBehavior";
                              WindowWillUpdateCollectionProperties: "mac:WindowWillUpdateCollectionProperties";
                              WindowWillUpdateShadow: "mac:WindowWillUpdateShadow";
                              WindowWillUpdateTitle: "mac:WindowWillUpdateTitle";
                              WindowWillUpdateToolbar: "mac:WindowWillUpdateToolbar";
                              WindowWillUpdateVisibility: "mac:WindowWillUpdateVisibility";
                              WindowWillUseStandardFrame: "mac:WindowWillUseStandardFrame";
                              WindowZoomIn: "mac:WindowZoomIn";
                              WindowZoomOut: "mac:WindowZoomOut";
                              WindowZoomReset: "mac:WindowZoomReset";
                          },
                      >;
                      Windows: Readonly<
                          {
                              APMPowerSettingChange: "windows:APMPowerSettingChange";
                              APMPowerStatusChange: "windows:APMPowerStatusChange";
                              APMResumeAutomatic: "windows:APMResumeAutomatic";
                              APMResumeSuspend: "windows:APMResumeSuspend";
                              APMSuspend: "windows:APMSuspend";
                              ApplicationStarted: "windows:ApplicationStarted";
                              SystemThemeChanged: "windows:SystemThemeChanged";
                              WebViewNavigationCompleted: "windows:WebViewNavigationCompleted";
                              WindowActive: "windows:WindowActive";
                              WindowBackgroundErase: "windows:WindowBackgroundErase";
                              WindowClickActive: "windows:WindowClickActive";
                              WindowClosing: "windows:WindowClosing";
                              WindowDidMove: "windows:WindowDidMove";
                              WindowDidResize: "windows:WindowDidResize";
                              WindowDPIChanged: "windows:WindowDPIChanged";
                              WindowDragDrop: "windows:WindowDragDrop";
                              WindowDragEnter: "windows:WindowDragEnter";
                              WindowDragLeave: "windows:WindowDragLeave";
                              WindowDragOver: "windows:WindowDragOver";
                              WindowEndMove: "windows:WindowEndMove";
                              WindowEndResize: "windows:WindowEndResize";
                              WindowFullscreen: "windows:WindowFullscreen";
                              WindowHide: "windows:WindowHide";
                              WindowInactive: "windows:WindowInactive";
                              WindowKeyDown: "windows:WindowKeyDown";
                              WindowKeyUp: "windows:WindowKeyUp";
                              WindowKillFocus: "windows:WindowKillFocus";
                              WindowMaximise: "windows:WindowMaximise";
                              WindowMinimise: "windows:WindowMinimise";
                              WindowNonClientHit: "windows:WindowNonClientHit";
                              WindowNonClientMouseDown: "windows:WindowNonClientMouseDown";
                              WindowNonClientMouseLeave: "windows:WindowNonClientMouseLeave";
                              WindowNonClientMouseMove: "windows:WindowNonClientMouseMove";
                              WindowNonClientMouseUp: "windows:WindowNonClientMouseUp";
                              WindowPaint: "windows:WindowPaint";
                              WindowRestore: "windows:WindowRestore";
                              WindowSetFocus: "windows:WindowSetFocus";
                              WindowShow: "windows:WindowShow";
                              WindowStartMove: "windows:WindowStartMove";
                              WindowStartResize: "windows:WindowStartResize";
                              WindowUnFullscreen: "windows:WindowUnFullscreen";
                              WindowUnMaximise: "windows:WindowUnMaximise";
                              WindowUnMinimise: "windows:WindowUnMinimise";
                              WindowZOrderChanged: "windows:WindowZOrderChanged";
                          },
                      >;
                  },
              > = ...
              +Types | @wailsio/runtime
              @wailsio/runtime
                Preparing search index...

                Variable TypesConst

                Types: Readonly<
                    {
                        Android: Readonly<
                            {
                                ActivityCreated: "android:ActivityCreated";
                                ActivityDestroyed: "android:ActivityDestroyed";
                                ActivityPaused: "android:ActivityPaused";
                                ActivityResumed: "android:ActivityResumed";
                                ActivityStarted: "android:ActivityStarted";
                                ActivityStopped: "android:ActivityStopped";
                                ApplicationLowMemory: "android:ApplicationLowMemory";
                                BatteryChanged: "android:BatteryChanged";
                                NetworkChanged: "android:NetworkChanged";
                                ScreenLocked: "android:ScreenLocked";
                                ScreenUnlocked: "android:ScreenUnlocked";
                                ThemeChanged: "android:ThemeChanged";
                                WebViewPageFinished: "android:WebViewPageFinished";
                                WebViewPageStarted: "android:WebViewPageStarted";
                            },
                        >;
                        Common: Readonly<
                            {
                                ApplicationLaunchedWithUrl: "common:ApplicationLaunchedWithUrl";
                                ApplicationOpenedWithFile: "common:ApplicationOpenedWithFile";
                                ApplicationStarted: "common:ApplicationStarted";
                                BatteryChanged: "common:BatteryChanged";
                                LowMemory: "common:LowMemory";
                                NetworkChanged: "common:NetworkChanged";
                                ScreenLocked: "common:ScreenLocked";
                                ScreenUnlocked: "common:ScreenUnlocked";
                                SystemDidWake: "common:SystemDidWake";
                                SystemWillSleep: "common:SystemWillSleep";
                                ThemeChanged: "common:ThemeChanged";
                                WindowClosing: "common:WindowClosing";
                                WindowDidMove: "common:WindowDidMove";
                                WindowDidResize: "common:WindowDidResize";
                                WindowDPIChanged: "common:WindowDPIChanged";
                                WindowFilesDropped: "common:WindowFilesDropped";
                                WindowFocus: "common:WindowFocus";
                                WindowFullscreen: "common:WindowFullscreen";
                                WindowHide: "common:WindowHide";
                                WindowLostFocus: "common:WindowLostFocus";
                                WindowMaximise: "common:WindowMaximise";
                                WindowMinimise: "common:WindowMinimise";
                                WindowRestore: "common:WindowRestore";
                                WindowRuntimeReady: "common:WindowRuntimeReady";
                                WindowShow: "common:WindowShow";
                                WindowToggleFrameless: "common:WindowToggleFrameless";
                                WindowUnFullscreen: "common:WindowUnFullscreen";
                                WindowUnMaximise: "common:WindowUnMaximise";
                                WindowUnMinimise: "common:WindowUnMinimise";
                                WindowZoom: "common:WindowZoom";
                                WindowZoomIn: "common:WindowZoomIn";
                                WindowZoomOut: "common:WindowZoomOut";
                                WindowZoomReset: "common:WindowZoomReset";
                            },
                        >;
                        iOS: Readonly<
                            {
                                ApplicationDidBecomeActive: "ios:ApplicationDidBecomeActive";
                                ApplicationDidEnterBackground: "ios:ApplicationDidEnterBackground";
                                ApplicationDidFinishLaunching: "ios:ApplicationDidFinishLaunching";
                                ApplicationDidReceiveMemoryWarning: "ios:ApplicationDidReceiveMemoryWarning";
                                ApplicationWillEnterForeground: "ios:ApplicationWillEnterForeground";
                                ApplicationWillResignActive: "ios:ApplicationWillResignActive";
                                ApplicationWillTerminate: "ios:ApplicationWillTerminate";
                                BatteryChanged: "ios:BatteryChanged";
                                NetworkChanged: "ios:NetworkChanged";
                                ScreenLocked: "ios:ScreenLocked";
                                ScreenUnlocked: "ios:ScreenUnlocked";
                                ThemeChanged: "ios:ThemeChanged";
                                WebViewDecidePolicyForNavigationAction: "ios:WebViewDecidePolicyForNavigationAction";
                                WebViewDidFailNavigation: "ios:WebViewDidFailNavigation";
                                WebViewDidFinishNavigation: "ios:WebViewDidFinishNavigation";
                                WebViewDidStartNavigation: "ios:WebViewDidStartNavigation";
                                WindowDidAppear: "ios:WindowDidAppear";
                                WindowDidDisappear: "ios:WindowDidDisappear";
                                WindowDidLoad: "ios:WindowDidLoad";
                                WindowOrientationChanged: "ios:WindowOrientationChanged";
                                WindowSafeAreaInsetsChanged: "ios:WindowSafeAreaInsetsChanged";
                                WindowTouchBegan: "ios:WindowTouchBegan";
                                WindowTouchCancelled: "ios:WindowTouchCancelled";
                                WindowTouchEnded: "ios:WindowTouchEnded";
                                WindowTouchMoved: "ios:WindowTouchMoved";
                                WindowWillAppear: "ios:WindowWillAppear";
                                WindowWillDisappear: "ios:WindowWillDisappear";
                            },
                        >;
                        Linux: Readonly<
                            {
                                ApplicationStartup: "linux:ApplicationStartup";
                                SystemDidWake: "linux:SystemDidWake";
                                SystemThemeChanged: "linux:SystemThemeChanged";
                                SystemWillSleep: "linux:SystemWillSleep";
                                WindowDeleteEvent: "linux:WindowDeleteEvent";
                                WindowDidMove: "linux:WindowDidMove";
                                WindowDidResize: "linux:WindowDidResize";
                                WindowFocusIn: "linux:WindowFocusIn";
                                WindowFocusOut: "linux:WindowFocusOut";
                                WindowLoadCommitted: "linux:WindowLoadCommitted";
                                WindowLoadFinished: "linux:WindowLoadFinished";
                                WindowLoadRedirected: "linux:WindowLoadRedirected";
                                WindowLoadStarted: "linux:WindowLoadStarted";
                            },
                        >;
                        Mac: Readonly<
                            {
                                ApplicationDidBecomeActive: "mac:ApplicationDidBecomeActive";
                                ApplicationDidChangeBackingProperties: "mac:ApplicationDidChangeBackingProperties";
                                ApplicationDidChangeEffectiveAppearance: "mac:ApplicationDidChangeEffectiveAppearance";
                                ApplicationDidChangeIcon: "mac:ApplicationDidChangeIcon";
                                ApplicationDidChangeOcclusionState: "mac:ApplicationDidChangeOcclusionState";
                                ApplicationDidChangeScreenParameters: "mac:ApplicationDidChangeScreenParameters";
                                ApplicationDidChangeStatusBarFrame: "mac:ApplicationDidChangeStatusBarFrame";
                                ApplicationDidChangeStatusBarOrientation: "mac:ApplicationDidChangeStatusBarOrientation";
                                ApplicationDidChangeTheme: "mac:ApplicationDidChangeTheme";
                                ApplicationDidFinishLaunching: "mac:ApplicationDidFinishLaunching";
                                ApplicationDidHide: "mac:ApplicationDidHide";
                                ApplicationDidResignActive: "mac:ApplicationDidResignActive";
                                ApplicationDidUnhide: "mac:ApplicationDidUnhide";
                                ApplicationDidUpdate: "mac:ApplicationDidUpdate";
                                ApplicationDidWake: "mac:ApplicationDidWake";
                                ApplicationScreensDidSleep: "mac:ApplicationScreensDidSleep";
                                ApplicationScreensDidWake: "mac:ApplicationScreensDidWake";
                                ApplicationShouldHandleReopen: "mac:ApplicationShouldHandleReopen";
                                ApplicationWillBecomeActive: "mac:ApplicationWillBecomeActive";
                                ApplicationWillFinishLaunching: "mac:ApplicationWillFinishLaunching";
                                ApplicationWillHide: "mac:ApplicationWillHide";
                                ApplicationWillResignActive: "mac:ApplicationWillResignActive";
                                ApplicationWillSleep: "mac:ApplicationWillSleep";
                                ApplicationWillTerminate: "mac:ApplicationWillTerminate";
                                ApplicationWillUnhide: "mac:ApplicationWillUnhide";
                                ApplicationWillUpdate: "mac:ApplicationWillUpdate";
                                MenuDidAddItem: "mac:MenuDidAddItem";
                                MenuDidBeginTracking: "mac:MenuDidBeginTracking";
                                MenuDidClose: "mac:MenuDidClose";
                                MenuDidDisplayItem: "mac:MenuDidDisplayItem";
                                MenuDidEndTracking: "mac:MenuDidEndTracking";
                                MenuDidHighlightItem: "mac:MenuDidHighlightItem";
                                MenuDidOpen: "mac:MenuDidOpen";
                                MenuDidPopUp: "mac:MenuDidPopUp";
                                MenuDidRemoveItem: "mac:MenuDidRemoveItem";
                                MenuDidSendAction: "mac:MenuDidSendAction";
                                MenuDidSendActionToItem: "mac:MenuDidSendActionToItem";
                                MenuDidUpdate: "mac:MenuDidUpdate";
                                MenuWillAddItem: "mac:MenuWillAddItem";
                                MenuWillBeginTracking: "mac:MenuWillBeginTracking";
                                MenuWillDisplayItem: "mac:MenuWillDisplayItem";
                                MenuWillEndTracking: "mac:MenuWillEndTracking";
                                MenuWillHighlightItem: "mac:MenuWillHighlightItem";
                                MenuWillOpen: "mac:MenuWillOpen";
                                MenuWillPopUp: "mac:MenuWillPopUp";
                                MenuWillRemoveItem: "mac:MenuWillRemoveItem";
                                MenuWillSendAction: "mac:MenuWillSendAction";
                                MenuWillSendActionToItem: "mac:MenuWillSendActionToItem";
                                MenuWillUpdate: "mac:MenuWillUpdate";
                                WebViewDidCommitNavigation: "mac:WebViewDidCommitNavigation";
                                WebViewDidFinishNavigation: "mac:WebViewDidFinishNavigation";
                                WebViewDidReceiveServerRedirectForProvisionalNavigation: "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation";
                                WebViewDidStartProvisionalNavigation: "mac:WebViewDidStartProvisionalNavigation";
                                WebViewWebContentProcessDidTerminate: "mac:WebViewWebContentProcessDidTerminate";
                                WindowDidBecomeKey: "mac:WindowDidBecomeKey";
                                WindowDidBecomeMain: "mac:WindowDidBecomeMain";
                                WindowDidBeginSheet: "mac:WindowDidBeginSheet";
                                WindowDidChangeAlpha: "mac:WindowDidChangeAlpha";
                                WindowDidChangeBackingLocation: "mac:WindowDidChangeBackingLocation";
                                WindowDidChangeBackingProperties: "mac:WindowDidChangeBackingProperties";
                                WindowDidChangeCollectionBehavior: "mac:WindowDidChangeCollectionBehavior";
                                WindowDidChangeEffectiveAppearance: "mac:WindowDidChangeEffectiveAppearance";
                                WindowDidChangeOcclusionState: "mac:WindowDidChangeOcclusionState";
                                WindowDidChangeOrderingMode: "mac:WindowDidChangeOrderingMode";
                                WindowDidChangeScreen: "mac:WindowDidChangeScreen";
                                WindowDidChangeScreenParameters: "mac:WindowDidChangeScreenParameters";
                                WindowDidChangeScreenProfile: "mac:WindowDidChangeScreenProfile";
                                WindowDidChangeScreenSpace: "mac:WindowDidChangeScreenSpace";
                                WindowDidChangeScreenSpaceProperties: "mac:WindowDidChangeScreenSpaceProperties";
                                WindowDidChangeSharingType: "mac:WindowDidChangeSharingType";
                                WindowDidChangeSpace: "mac:WindowDidChangeSpace";
                                WindowDidChangeSpaceOrderingMode: "mac:WindowDidChangeSpaceOrderingMode";
                                WindowDidChangeTitle: "mac:WindowDidChangeTitle";
                                WindowDidChangeToolbar: "mac:WindowDidChangeToolbar";
                                WindowDidDeminiaturize: "mac:WindowDidDeminiaturize";
                                WindowDidEndSheet: "mac:WindowDidEndSheet";
                                WindowDidEnterFullScreen: "mac:WindowDidEnterFullScreen";
                                WindowDidEnterVersionBrowser: "mac:WindowDidEnterVersionBrowser";
                                WindowDidExitFullScreen: "mac:WindowDidExitFullScreen";
                                WindowDidExitVersionBrowser: "mac:WindowDidExitVersionBrowser";
                                WindowDidExpose: "mac:WindowDidExpose";
                                WindowDidFocus: "mac:WindowDidFocus";
                                WindowDidMiniaturize: "mac:WindowDidMiniaturize";
                                WindowDidMove: "mac:WindowDidMove";
                                WindowDidOrderOffScreen: "mac:WindowDidOrderOffScreen";
                                WindowDidOrderOnScreen: "mac:WindowDidOrderOnScreen";
                                WindowDidResignKey: "mac:WindowDidResignKey";
                                WindowDidResignMain: "mac:WindowDidResignMain";
                                WindowDidResize: "mac:WindowDidResize";
                                WindowDidUpdate: "mac:WindowDidUpdate";
                                WindowDidUpdateAlpha: "mac:WindowDidUpdateAlpha";
                                WindowDidUpdateCollectionBehavior: "mac:WindowDidUpdateCollectionBehavior";
                                WindowDidUpdateCollectionProperties: "mac:WindowDidUpdateCollectionProperties";
                                WindowDidUpdateShadow: "mac:WindowDidUpdateShadow";
                                WindowDidUpdateTitle: "mac:WindowDidUpdateTitle";
                                WindowDidUpdateToolbar: "mac:WindowDidUpdateToolbar";
                                WindowDidZoom: "mac:WindowDidZoom";
                                WindowFileDraggingEntered: "mac:WindowFileDraggingEntered";
                                WindowFileDraggingExited: "mac:WindowFileDraggingExited";
                                WindowFileDraggingPerformed: "mac:WindowFileDraggingPerformed";
                                WindowHide: "mac:WindowHide";
                                WindowMaximise: "mac:WindowMaximise";
                                WindowMinimise: "mac:WindowMinimise";
                                WindowShouldClose: "mac:WindowShouldClose";
                                WindowShow: "mac:WindowShow";
                                WindowUnMaximise: "mac:WindowUnMaximise";
                                WindowUnMinimise: "mac:WindowUnMinimise";
                                WindowWillBecomeKey: "mac:WindowWillBecomeKey";
                                WindowWillBecomeMain: "mac:WindowWillBecomeMain";
                                WindowWillBeginSheet: "mac:WindowWillBeginSheet";
                                WindowWillChangeOrderingMode: "mac:WindowWillChangeOrderingMode";
                                WindowWillClose: "mac:WindowWillClose";
                                WindowWillDeminiaturize: "mac:WindowWillDeminiaturize";
                                WindowWillEnterFullScreen: "mac:WindowWillEnterFullScreen";
                                WindowWillEnterVersionBrowser: "mac:WindowWillEnterVersionBrowser";
                                WindowWillExitFullScreen: "mac:WindowWillExitFullScreen";
                                WindowWillExitVersionBrowser: "mac:WindowWillExitVersionBrowser";
                                WindowWillFocus: "mac:WindowWillFocus";
                                WindowWillMiniaturize: "mac:WindowWillMiniaturize";
                                WindowWillMove: "mac:WindowWillMove";
                                WindowWillOrderOffScreen: "mac:WindowWillOrderOffScreen";
                                WindowWillOrderOnScreen: "mac:WindowWillOrderOnScreen";
                                WindowWillResignMain: "mac:WindowWillResignMain";
                                WindowWillResize: "mac:WindowWillResize";
                                WindowWillUnfocus: "mac:WindowWillUnfocus";
                                WindowWillUpdate: "mac:WindowWillUpdate";
                                WindowWillUpdateAlpha: "mac:WindowWillUpdateAlpha";
                                WindowWillUpdateCollectionBehavior: "mac:WindowWillUpdateCollectionBehavior";
                                WindowWillUpdateCollectionProperties: "mac:WindowWillUpdateCollectionProperties";
                                WindowWillUpdateShadow: "mac:WindowWillUpdateShadow";
                                WindowWillUpdateTitle: "mac:WindowWillUpdateTitle";
                                WindowWillUpdateToolbar: "mac:WindowWillUpdateToolbar";
                                WindowWillUpdateVisibility: "mac:WindowWillUpdateVisibility";
                                WindowWillUseStandardFrame: "mac:WindowWillUseStandardFrame";
                                WindowZoomIn: "mac:WindowZoomIn";
                                WindowZoomOut: "mac:WindowZoomOut";
                                WindowZoomReset: "mac:WindowZoomReset";
                            },
                        >;
                        Windows: Readonly<
                            {
                                APMPowerSettingChange: "windows:APMPowerSettingChange";
                                APMPowerStatusChange: "windows:APMPowerStatusChange";
                                APMResumeAutomatic: "windows:APMResumeAutomatic";
                                APMResumeSuspend: "windows:APMResumeSuspend";
                                APMSuspend: "windows:APMSuspend";
                                ApplicationStarted: "windows:ApplicationStarted";
                                SystemThemeChanged: "windows:SystemThemeChanged";
                                WebViewNavigationCompleted: "windows:WebViewNavigationCompleted";
                                WindowActive: "windows:WindowActive";
                                WindowBackgroundErase: "windows:WindowBackgroundErase";
                                WindowClickActive: "windows:WindowClickActive";
                                WindowClosing: "windows:WindowClosing";
                                WindowDidMove: "windows:WindowDidMove";
                                WindowDidResize: "windows:WindowDidResize";
                                WindowDPIChanged: "windows:WindowDPIChanged";
                                WindowDragDrop: "windows:WindowDragDrop";
                                WindowDragEnter: "windows:WindowDragEnter";
                                WindowDragLeave: "windows:WindowDragLeave";
                                WindowDragOver: "windows:WindowDragOver";
                                WindowEndMove: "windows:WindowEndMove";
                                WindowEndResize: "windows:WindowEndResize";
                                WindowFullscreen: "windows:WindowFullscreen";
                                WindowHide: "windows:WindowHide";
                                WindowInactive: "windows:WindowInactive";
                                WindowKeyDown: "windows:WindowKeyDown";
                                WindowKeyUp: "windows:WindowKeyUp";
                                WindowKillFocus: "windows:WindowKillFocus";
                                WindowMaximise: "windows:WindowMaximise";
                                WindowMinimise: "windows:WindowMinimise";
                                WindowNonClientHit: "windows:WindowNonClientHit";
                                WindowNonClientMouseDown: "windows:WindowNonClientMouseDown";
                                WindowNonClientMouseLeave: "windows:WindowNonClientMouseLeave";
                                WindowNonClientMouseMove: "windows:WindowNonClientMouseMove";
                                WindowNonClientMouseUp: "windows:WindowNonClientMouseUp";
                                WindowPaint: "windows:WindowPaint";
                                WindowRestore: "windows:WindowRestore";
                                WindowSetFocus: "windows:WindowSetFocus";
                                WindowShow: "windows:WindowShow";
                                WindowStartMove: "windows:WindowStartMove";
                                WindowStartResize: "windows:WindowStartResize";
                                WindowUnFullscreen: "windows:WindowUnFullscreen";
                                WindowUnMaximise: "windows:WindowUnMaximise";
                                WindowUnMinimise: "windows:WindowUnMinimise";
                                WindowZOrderChanged: "windows:WindowZOrderChanged";
                            },
                        >;
                    },
                > = ...
                diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/clientId.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/clientId.html index b8623df0e1c..79907791766 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/clientId.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/clientId.html @@ -1 +1 @@ -clientId | @wailsio/runtime
                @wailsio/runtime
                  Preparing search index...

                  Variable clientId

                  clientId: string = ...
                  +clientId | @wailsio/runtime
                  @wailsio/runtime
                    Preparing search index...

                    Variable clientId

                    clientId: string = ...
                    diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/objectNames.html b/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/objectNames.html index 6e2cd5d357b..c8f1e7b95f0 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/objectNames.html +++ b/v3/internal/runtime/desktop/@wailsio/runtime/docs/variables/objectNames.html @@ -1 +1 @@ -objectNames | @wailsio/runtime
                    @wailsio/runtime
                      Preparing search index...

                      Variable objectNamesConst

                      objectNames: Readonly<
                          {
                              Android: 12;
                              Application: 2;
                              Browser: 9;
                              Call: 0;
                              CancelCall: 10;
                              Clipboard: 1;
                              ContextMenu: 4;
                              Dialog: 5;
                              Events: 3;
                              IOS: 11;
                              Screens: 7;
                              System: 8;
                              Window: 6;
                          },
                      > = ...
                      +objectNames | @wailsio/runtime
                      @wailsio/runtime
                        Preparing search index...

                        Variable objectNamesConst

                        objectNames: Readonly<
                            {
                                Android: 12;
                                Application: 2;
                                Browser: 9;
                                Call: 0;
                                CancelCall: 10;
                                Clipboard: 1;
                                ContextMenu: 4;
                                Dialog: 5;
                                Events: 3;
                                IOS: 11;
                                Screens: 7;
                                System: 8;
                                Window: 6;
                            },
                        > = ...
                        diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json b/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json index c12ca8e5e2d..5acda88d971 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json +++ b/v3/internal/runtime/desktop/@wailsio/runtime/package-lock.json @@ -1,14 +1,15 @@ { "name": "@wailsio/runtime", - "version": "3.0.0-alpha.95", + "version": "3.0.0-alpha.97", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "@wailsio/runtime", - "version": "3.0.0-alpha.95", + "version": "3.0.0-alpha.97", "license": "MIT", "devDependencies": { + "esbuild": "0.28.1", "happy-dom": "^20.9.0", "promises-aplus-tests": "2.1.2", "rimraf": "^6.0.1", @@ -55,6 +56,448 @@ "tslib": "^2.4.0" } }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz", + "integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz", + "integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz", + "integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz", + "integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz", + "integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz", + "integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz", + "integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz", + "integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz", + "integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz", + "integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz", + "integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz", + "integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz", + "integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz", + "integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz", + "integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz", + "integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz", + "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz", + "integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz", + "integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz", + "integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz", + "integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz", + "integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz", + "integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz", + "integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz", + "integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz", + "integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, "node_modules/@gerrit0/mini-shiki": { "version": "3.23.0", "resolved": "https://registry.npmjs.org/@gerrit0/mini-shiki/-/mini-shiki-3.23.0.tgz", @@ -1032,6 +1475,48 @@ "dev": true, "license": "MIT" }, + "node_modules/esbuild": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz", + "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.28.1", + "@esbuild/android-arm": "0.28.1", + "@esbuild/android-arm64": "0.28.1", + "@esbuild/android-x64": "0.28.1", + "@esbuild/darwin-arm64": "0.28.1", + "@esbuild/darwin-x64": "0.28.1", + "@esbuild/freebsd-arm64": "0.28.1", + "@esbuild/freebsd-x64": "0.28.1", + "@esbuild/linux-arm": "0.28.1", + "@esbuild/linux-arm64": "0.28.1", + "@esbuild/linux-ia32": "0.28.1", + "@esbuild/linux-loong64": "0.28.1", + "@esbuild/linux-mips64el": "0.28.1", + "@esbuild/linux-ppc64": "0.28.1", + "@esbuild/linux-riscv64": "0.28.1", + "@esbuild/linux-s390x": "0.28.1", + "@esbuild/linux-x64": "0.28.1", + "@esbuild/netbsd-arm64": "0.28.1", + "@esbuild/netbsd-x64": "0.28.1", + "@esbuild/openbsd-arm64": "0.28.1", + "@esbuild/openbsd-x64": "0.28.1", + "@esbuild/openharmony-arm64": "0.28.1", + "@esbuild/sunos-x64": "0.28.1", + "@esbuild/win32-arm64": "0.28.1", + "@esbuild/win32-ia32": "0.28.1", + "@esbuild/win32-x64": "0.28.1" + } + }, "node_modules/escalade": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/package.json b/v3/internal/runtime/desktop/@wailsio/runtime/package.json index 50ca01b8fe5..ec1ed4a5eee 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/package.json +++ b/v3/internal/runtime/desktop/@wailsio/runtime/package.json @@ -1,7 +1,7 @@ { "name": "@wailsio/runtime", "type": "module", - "version": "3.0.0-alpha.95", + "version": "3.0.0-alpha.97", "description": "Wails Runtime", "types": "types/index.d.ts", "exports": { @@ -31,6 +31,7 @@ ], "sideEffects": [ "./dist/index.js", + "./dist/appregion.js", "./dist/contextmenu.js", "./dist/drag.js" ], @@ -48,6 +49,7 @@ "prepack": "npm run build" }, "devDependencies": { + "esbuild": "0.28.1", "happy-dom": "^20.9.0", "promises-aplus-tests": "2.1.2", "rimraf": "^6.0.1", diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/appregion.ts b/v3/internal/runtime/desktop/@wailsio/runtime/src/appregion.ts new file mode 100644 index 00000000000..7f284546aed --- /dev/null +++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/appregion.ts @@ -0,0 +1,235 @@ +/* + _ __ _ __ +| | / /___(_) /____ +| | /| / / __ `/ / / ___/ +| |/ |/ / /_/ / / (__ ) +|__/|__/\__,_/_/_/____/ +The electron alternative for Go +(c) Lea Anthony 2019-present +*/ + +import { invoke } from "./system.js"; +import { whenReady } from "./utils.js"; +import { hasDOM } from "./environment.js"; + +type NonClientRegionKind = "caption" | "minimize" | "maximize" | "close"; + +interface NonClientRegion { + kind: NonClientRegionKind; + left: number; + top: number; + right: number; + bottom: number; +} + +/* +--wails-non-client-region: caption; marks an area that can drag the window +--wails-non-client-region: minimize; marks a custom minimize button +--wails-non-client-region: maximize; marks a custom maximize button +--wails-non-client-region: close; marks a custom close button +*/ +const regionProperty = "--wails-non-client-region"; +const runtimeConfigReadyEvent = "wails:runtime-config-ready"; +const validRegions = new Set(["caption", "minimize", "maximize", "close"]); + +// Setup +if (hasDOM) { + window._wails = window._wails || {}; +} + +let updatePending = false; +let lastPayload = ""; +let observedElements = new Set(); +let resizeObserver: ResizeObserver | undefined; +let trackingStarted = false; + +function normaliseRegionKind(value: string): NonClientRegionKind | undefined { + const region = value.trim().toLowerCase(); + if (validRegions.has(region as NonClientRegionKind)) { + return region as NonClientRegionKind; + } + return undefined; +} + +function nonClientRegionForElement(element: Element): NonClientRegionKind | undefined { + if (!(element instanceof HTMLElement)) { + return undefined; + } + + const style = window.getComputedStyle(element); + const region = normaliseRegionKind(style.getPropertyValue(regionProperty)); + if (!region) { + return undefined; + } + + const parent = element.parentElement; + if (parent) { + const parentStyle = window.getComputedStyle(parent); + // The CSS property is inherited. Only report the outermost element for + // each contiguous region so native hit testing sees stable rectangles. + if (normaliseRegionKind(parentStyle.getPropertyValue(regionProperty)) === region) { + return undefined; + } + } + + return region; +} + +function isVisible(element: HTMLElement): boolean { + const style = window.getComputedStyle(element); + return style.display !== "none" && + style.visibility !== "hidden" && + style.contentVisibility !== "hidden"; +} + +function elementRegion(element: Element): NonClientRegion | undefined { + if (!(element instanceof HTMLElement)) { + return undefined; + } + + const kind = nonClientRegionForElement(element); + if (!kind || !isVisible(element)) { + return undefined; + } + + const rect = element.getBoundingClientRect(); + if (rect.width <= 0 || rect.height <= 0) { + return undefined; + } + + // Native hit testing runs in physical pixels, while DOM geometry is in CSS pixels. + const scale = window.devicePixelRatio || 1; + const left = Math.floor(rect.left * scale); + const top = Math.floor(rect.top * scale); + const right = Math.ceil(rect.right * scale); + const bottom = Math.ceil(rect.bottom * scale); + + if (right <= left || bottom <= top) { + return undefined; + } + + return { kind, left, top, right, bottom }; +} + +function regionElements(): Element[] { + const elements: Element[] = []; + + if (document.documentElement) { + elements.push(document.documentElement); + } + if (document.body) { + elements.push(document.body); + // Append via a loop: spreading a huge NodeList into push() overflows + // the engine's argument limit on very large documents. + for (const element of document.body.querySelectorAll("*")) { + elements.push(element); + } + } + + return elements; +} + +function observeRegionElements(elements: Element[]): void { + if (typeof ResizeObserver === "undefined") { + return; + } + + // Track size changes only for active region elements. DOM structure and style + // changes are covered by MutationObserver in startNonClientRegionTracking(). + resizeObserver ??= new ResizeObserver(scheduleUpdate); + const nextElements = new Set(elements); + + for (const element of observedElements) { + if (!nextElements.has(element)) { + resizeObserver.unobserve(element); + } + } + + for (const element of nextElements) { + if (!observedElements.has(element)) { + resizeObserver.observe(element); + } + } + + observedElements = nextElements; +} + +function updateNonClientRegions(): void { + updatePending = false; + + const elements = regionElements(); + const regions: NonClientRegion[] = []; + const activeElements: Element[] = []; + + for (const element of elements) { + const region = elementRegion(element); + if (region) { + regions.push(region); + activeElements.push(element); + } + } + + observeRegionElements(activeElements); + + const payload = JSON.stringify({ version: 1, regions }); + if (payload === lastPayload) { + // Avoid sending duplicate native messages during resize or style churn. + return; + } + + lastPayload = payload; + invoke("wails:non-client-region:" + payload); +} + +function scheduleUpdate(): void { + if (updatePending) { + return; + } + + // Batch region updates to animation frames so layout is measured once per frame. + updatePending = true; + window.requestAnimationFrame(updateNonClientRegions); +} + +function startNonClientRegionTracking(): void { + if (trackingStarted) { + return; + } + + trackingStarted = true; + // Send an initial empty or populated region list once the DOM is ready. + scheduleUpdate(); + + const mutationObserver = new MutationObserver(scheduleUpdate); + mutationObserver.observe(document.documentElement, { + attributes: true, + childList: true, + subtree: true, + }); + + window.addEventListener("resize", scheduleUpdate); + window.addEventListener("scroll", scheduleUpdate, true); + window.visualViewport?.addEventListener("resize", scheduleUpdate); + window.visualViewport?.addEventListener("scroll", scheduleUpdate); +} + +function tryStartNonClientRegionTracking(): boolean { + const os = window._wails.environment?.OS; + if (os === undefined) { + return false; + } + + const enabled = window._wails.flags?.nonClientRegionTracking; + if (os === "windows") { + if (enabled === true) { + whenReady(startNonClientRegionTracking); + } + return true; + } + + return true; +} + +if (hasDOM && !tryStartNonClientRegionTracking()) { + window.addEventListener(runtimeConfigReadyEvent, tryStartNonClientRegionTracking, { once: true }); +} diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/calls.ts b/v3/internal/runtime/desktop/@wailsio/runtime/src/calls.ts index d6e245d8713..4dc39fbbcd6 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/src/calls.ts +++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/calls.ts @@ -48,21 +48,10 @@ export type CallOptions = { args: any[]; }; -/** - * Exception class that will be thrown in case the bound method returns an error. - * The value of the {@link RuntimeError#name} property is "RuntimeError". - */ -export class RuntimeError extends Error { - /** - * Constructs a new RuntimeError instance. - * @param message - The error message. - * @param options - Options to be forwarded to the Error constructor. - */ - constructor(message?: string, options?: ErrorOptions) { - super(message, options); - this.name = "RuntimeError"; - } -} +// runtime.js needs to use RuntimeError internally to properly parse and return +// errors for binding calls, so it had to move there. Exporting here again to +// keep from breaking the public Call interface. +export { RuntimeError } from "./runtime.js"; /** * Generates a unique ID using the nanoid library. diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/drag.ts b/v3/internal/runtime/desktop/@wailsio/runtime/src/drag.ts index db12127267d..f21b942355c 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/src/drag.ts +++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/drag.ts @@ -159,6 +159,13 @@ function primaryDown(event: MouseEvent): void { } if (resizeEdge) { + // Do not arm edge resize from synthesized presses observed on move/up: + // entering the window with the primary button already held should not + // steal another gesture into a resize. + if (event.type !== 'mousedown') { + return; + } + // Ready to resize if the primary button was pressed for the first time. canResize = true; // Do not start drag operations when on resize edges. diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/index.ts b/v3/internal/runtime/desktop/@wailsio/runtime/src/index.ts index f07e0cce471..bb18c181b0e 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/src/index.ts +++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/index.ts @@ -17,6 +17,7 @@ if (hasDOM) { import "./contextmenu.js"; import "./drag.js"; +import "./appregion.js"; // Re-export public API import * as Application from "./application.js"; diff --git a/v3/internal/runtime/desktop/@wailsio/runtime/src/runtime.ts b/v3/internal/runtime/desktop/@wailsio/runtime/src/runtime.ts index f48c701ec3d..7704f563b2b 100644 --- a/v3/internal/runtime/desktop/@wailsio/runtime/src/runtime.ts +++ b/v3/internal/runtime/desktop/@wailsio/runtime/src/runtime.ts @@ -23,6 +23,28 @@ const CHUNK_THRESHOLD = 512 * 1024; // Re-export nanoid for custom transport implementations export { nanoid }; +type CallErrorType = { + message: string, + cause?: unknown, + kind: "ReferenceError" | "TypeError" | "RuntimeError" +} + +/** + * Exception class that will be thrown in case the bound method returns an error. + * The value of the {@link RuntimeError#name} property is "RuntimeError". + */ +export class RuntimeError extends Error { + /** + * Constructs a new RuntimeError instance. + * @param message - The error message. + * @param options - Options to be forwarded to the Error constructor. + */ + constructor(message?: string, options?: ErrorOptions) { + super(message, options); + this.name = "RuntimeError"; + } +} + // Object Names export const objectNames = Object.freeze({ Call: 0, @@ -141,7 +163,20 @@ async function runtimeCallWithID(objectID: number, method: number, windowName: s response = await fetch(url, { method: 'POST', headers, body: bodyStr }); } if (!response.ok) { - throw new Error(await response.text()); + const ct = response.headers.get("Content-Type"); + if (ct?.includes("application/json")) { + const json: CallErrorType = await response.json(); + let err; + switch (json.kind) { + case "ReferenceError": err = new ReferenceError(json.message); break; + case "TypeError": err = new TypeError(json.message); break; + case "RuntimeError": err = new RuntimeError(json.message); break; + default: err = new Error(json.message); + } + err.cause = json.cause; + throw err + } + throw new Error(await response.text()); } if ((response.headers.get("Content-Type")?.indexOf("application/json") ?? -1) !== -1) { diff --git a/v3/internal/runtime/runtime.go b/v3/internal/runtime/runtime.go index d35ff05524c..bbd165fc539 100644 --- a/v3/internal/runtime/runtime.go +++ b/v3/internal/runtime/runtime.go @@ -7,6 +7,7 @@ import ( ) var runtimeInit = `window._wails=window._wails||{};window._wails.flags=window._wails.flags||{};window.wails=window.wails||{};` +var runtimeConfigReady = `Promise.resolve().then(function(){window.dispatchEvent(new Event("wails:runtime-config-ready"));});` func Core(flags map[string]any) string { flagsStr := "" @@ -17,5 +18,5 @@ func Core(flags map[string]any) string { } } - return runtimeInit + flagsStr + invoke + environment + return runtimeInit + flagsStr + invoke + environment + runtimeConfigReady } diff --git a/v3/internal/webview2/pkg/edge/COREWEBVIEW2_MOUSE_EVENT_KIND.go b/v3/internal/webview2/pkg/edge/COREWEBVIEW2_MOUSE_EVENT_KIND.go new file mode 100644 index 00000000000..e610931b2f9 --- /dev/null +++ b/v3/internal/webview2/pkg/edge/COREWEBVIEW2_MOUSE_EVENT_KIND.go @@ -0,0 +1,26 @@ +//go:build windows + +package edge + +type COREWEBVIEW2_MOUSE_EVENT_KIND uint32 + +const ( + COREWEBVIEW2_MOUSE_EVENT_KIND_HORIZONTAL_WHEEL = 526 + COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_DOUBLE_CLICK = 515 + COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_DOWN = 513 + COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_UP = 514 + COREWEBVIEW2_MOUSE_EVENT_KIND_LEAVE = 675 + COREWEBVIEW2_MOUSE_EVENT_KIND_MIDDLE_BUTTON_DOUBLE_CLICK = 521 + COREWEBVIEW2_MOUSE_EVENT_KIND_MIDDLE_BUTTON_DOWN = 519 + COREWEBVIEW2_MOUSE_EVENT_KIND_MIDDLE_BUTTON_UP = 520 + COREWEBVIEW2_MOUSE_EVENT_KIND_MOVE = 512 + COREWEBVIEW2_MOUSE_EVENT_KIND_RIGHT_BUTTON_DOUBLE_CLICK = 518 + COREWEBVIEW2_MOUSE_EVENT_KIND_RIGHT_BUTTON_DOWN = 516 + COREWEBVIEW2_MOUSE_EVENT_KIND_RIGHT_BUTTON_UP = 517 + COREWEBVIEW2_MOUSE_EVENT_KIND_WHEEL = 522 + COREWEBVIEW2_MOUSE_EVENT_KIND_X_BUTTON_DOUBLE_CLICK = 525 + COREWEBVIEW2_MOUSE_EVENT_KIND_X_BUTTON_DOWN = 523 + COREWEBVIEW2_MOUSE_EVENT_KIND_X_BUTTON_UP = 524 + COREWEBVIEW2_MOUSE_EVENT_KIND_NON_CLIENT_RIGHT_BUTTON_DOWN = 164 + COREWEBVIEW2_MOUSE_EVENT_KIND_NON_CLIENT_RIGHT_BUTTON_UP = 165 +) diff --git a/v3/internal/webview2/pkg/edge/COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS.go b/v3/internal/webview2/pkg/edge/COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS.go new file mode 100644 index 00000000000..363edbae068 --- /dev/null +++ b/v3/internal/webview2/pkg/edge/COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS.go @@ -0,0 +1,16 @@ +//go:build windows + +package edge + +type COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS uint32 + +const ( + COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_NONE COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS = 0 + COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_LEFT_BUTTON COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS = 1 + COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_RIGHT_BUTTON COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS = 2 + COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_SHIFT COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS = 4 + COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_CONTROL COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS = 8 + COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_MIDDLE_BUTTON COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS = 16 + COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_X_BUTTON1 COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS = 32 + COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_X_BUTTON2 COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS = 64 +) diff --git a/v3/internal/webview2/pkg/edge/COREWEBVIEW2_NON_CLIENT_REGION_KIND.go b/v3/internal/webview2/pkg/edge/COREWEBVIEW2_NON_CLIENT_REGION_KIND.go new file mode 100644 index 00000000000..2cda60b0253 --- /dev/null +++ b/v3/internal/webview2/pkg/edge/COREWEBVIEW2_NON_CLIENT_REGION_KIND.go @@ -0,0 +1,14 @@ +//go:build windows + +package edge + +type COREWEBVIEW2_NON_CLIENT_REGION_KIND uint32 + +const ( + COREWEBVIEW2_NON_CLIENT_REGION_KIND_NOWHERE = 0 + COREWEBVIEW2_NON_CLIENT_REGION_KIND_CLIENT = 1 + COREWEBVIEW2_NON_CLIENT_REGION_KIND_CAPTION = 2 + COREWEBVIEW2_NON_CLIENT_REGION_KIND_MINIMIZE = 8 + COREWEBVIEW2_NON_CLIENT_REGION_KIND_MAXIMIZE = 9 + COREWEBVIEW2_NON_CLIENT_REGION_KIND_CLOSE = 20 +) diff --git a/v3/internal/webview2/pkg/edge/ICoreWebView2CompositionController.go b/v3/internal/webview2/pkg/edge/ICoreWebView2CompositionController.go new file mode 100644 index 00000000000..60295f90b3a --- /dev/null +++ b/v3/internal/webview2/pkg/edge/ICoreWebView2CompositionController.go @@ -0,0 +1,109 @@ +//go:build windows + +package edge + +import ( + "syscall" + "unsafe" +) + +type ICoreWebView2CompositionControllerVtbl struct { + _IUnknownVtbl + GetRootVisualTarget ComProc + PutRootVisualTarget ComProc + SendMouseInput ComProc + SendPointerInput ComProc + GetCursor ComProc + GetSystemCursorId ComProc + AddCursorChanged ComProc + RemoveCursorChanged ComProc +} + +type ICoreWebView2CompositionController struct { + Vtbl *ICoreWebView2CompositionControllerVtbl +} + +func (i *ICoreWebView2CompositionController) AddRef() uintptr { + ret, _, _ := i.Vtbl.AddRef.Call(uintptr(unsafe.Pointer(i))) + + return ret +} + +func (i *ICoreWebView2CompositionController) Release() uintptr { + ret, _, _ := i.Vtbl.Release.Call(uintptr(unsafe.Pointer(i))) + + return ret +} + +func (i *ICoreWebView2CompositionController) GetICoreWebView2Controller() *ICoreWebView2Controller { + var result *ICoreWebView2Controller + + iidICoreWebView2Controller := NewGUID("{4D00C0D1-9434-4EB6-8078-8697A560334F}") + _, _, _ = i.Vtbl.QueryInterface.Call( + uintptr(unsafe.Pointer(i)), + uintptr(unsafe.Pointer(iidICoreWebView2Controller)), + uintptr(unsafe.Pointer(&result))) + + return result +} + +func (i *ICoreWebView2CompositionController) PutRootVisualTarget(target *IUnknown) error { + hr, _, _ := i.Vtbl.PutRootVisualTarget.Call( + uintptr(unsafe.Pointer(i)), + uintptr(unsafe.Pointer(target)), + ) + if int32(hr) < 0 { + return syscall.Errno(hr) + } + return nil +} + +func (i *ICoreWebView2CompositionController) SendMouseInput(eventKind COREWEBVIEW2_MOUSE_EVENT_KIND, virtualKeys COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS, mouseData uint32, point POINT) error { + hr, _, _ := i.Vtbl.SendMouseInput.Call( + uintptr(unsafe.Pointer(i)), + uintptr(eventKind), + uintptr(virtualKeys), + uintptr(mouseData), + point.uintptr(), + ) + if int32(hr) < 0 { + return syscall.Errno(hr) + } + return nil +} + +func (i *ICoreWebView2CompositionController) GetCursor() (HCURSOR, error) { + var cursor HCURSOR + hr, _, _ := i.Vtbl.GetCursor.Call( + uintptr(unsafe.Pointer(i)), + uintptr(unsafe.Pointer(&cursor)), + ) + if int32(hr) < 0 { + return 0, syscall.Errno(hr) + } + return cursor, nil +} + +func (i *ICoreWebView2CompositionController) GetSystemCursorId() (uint32, error) { + var cursorID uint32 + hr, _, _ := i.Vtbl.GetSystemCursorId.Call( + uintptr(unsafe.Pointer(i)), + uintptr(unsafe.Pointer(&cursorID)), + ) + if int32(hr) < 0 { + return 0, syscall.Errno(hr) + } + return cursorID, nil +} + +func (i *ICoreWebView2CompositionController) AddCursorChanged(eventHandler *iCoreWebView2CursorChangedEventHandler, token *_EventRegistrationToken) error { + hr, _, _ := i.Vtbl.AddCursorChanged.Call( + uintptr(unsafe.Pointer(i)), + uintptr(unsafe.Pointer(eventHandler)), + uintptr(unsafe.Pointer(token)), + ) + if int32(hr) < 0 { + return syscall.Errno(hr) + } + return nil +} diff --git a/v3/internal/webview2/pkg/edge/ICoreWebView2CompositionController4.go b/v3/internal/webview2/pkg/edge/ICoreWebView2CompositionController4.go new file mode 100644 index 00000000000..3b710281ede --- /dev/null +++ b/v3/internal/webview2/pkg/edge/ICoreWebView2CompositionController4.go @@ -0,0 +1,73 @@ +//go:build windows + +package edge + +import ( + "syscall" + "unsafe" + + "golang.org/x/sys/windows" +) + +type ICoreWebView2CompositionController4Vtbl struct { + _IUnknownVtbl + GetRootVisualTarget ComProc + PutRootVisualTarget ComProc + SendMouseInput ComProc + SendPointerInput ComProc + GetCursor ComProc + GetSystemCursorId ComProc + AddCursorChanged ComProc + RemoveCursorChanged ComProc + GetUIAProvider ComProc + DragEnter ComProc + DragLeave ComProc + DragOver ComProc + Drop ComProc + GetNonClientRegionAtPoint ComProc + QueryNonClientRegion ComProc + AddNonClientRegionChanged ComProc + RemoveNonClientRegionChanged ComProc +} + +type ICoreWebView2CompositionController4 struct { + Vtbl *ICoreWebView2CompositionController4Vtbl +} + +func (i *ICoreWebView2CompositionController4) AddRef() uintptr { + ret, _, _ := i.Vtbl.AddRef.Call(uintptr(unsafe.Pointer(i))) + + return ret +} + +func (i *ICoreWebView2CompositionController4) Release() uintptr { + ret, _, _ := i.Vtbl.Release.Call(uintptr(unsafe.Pointer(i))) + + return ret +} + +func (i *ICoreWebView2CompositionController) GetICoreWebView2CompositionController4() *ICoreWebView2CompositionController4 { + var result *ICoreWebView2CompositionController4 + + iidICoreWebView2CompositionController4 := NewGUID("{7C367B9B-3D2B-450F-9E58-D61A20F486AA}") + _, _, _ = i.Vtbl.QueryInterface.Call( + uintptr(unsafe.Pointer(i)), + uintptr(unsafe.Pointer(iidICoreWebView2CompositionController4)), + uintptr(unsafe.Pointer(&result))) + + return result +} + +func (i *ICoreWebView2CompositionController4) GetNonClientRegionAtPoint(point POINT) (COREWEBVIEW2_NON_CLIENT_REGION_KIND, error) { + var value COREWEBVIEW2_NON_CLIENT_REGION_KIND + + hr, _, _ := i.Vtbl.GetNonClientRegionAtPoint.Call( + uintptr(unsafe.Pointer(i)), + point.uintptr(), + uintptr(unsafe.Pointer(&value)), + ) + if windows.Handle(hr) != windows.S_OK { + return 0, syscall.Errno(hr) + } + return value, nil +} diff --git a/v3/internal/webview2/pkg/edge/ICoreWebView2Controller.go b/v3/internal/webview2/pkg/edge/ICoreWebView2Controller.go index 08038b0b9fb..1625efb84a4 100644 --- a/v3/internal/webview2/pkg/edge/ICoreWebView2Controller.go +++ b/v3/internal/webview2/pkg/edge/ICoreWebView2Controller.go @@ -150,6 +150,14 @@ func (i *ICoreWebView2Controller) NotifyParentWindowPositionChanged() error { return nil } +func (i *ICoreWebView2Controller) Close() error { + hr, _, _ := i.vtbl.Close.Call(uintptr(unsafe.Pointer(i))) + if windows.Handle(hr) != windows.S_OK { + return windows.Errno(hr) + } + return nil +} + func (i *ICoreWebView2Controller) PutZoomFactor(zoomFactor float64) error { // put_ZoomFactor takes the double BY VALUE; the per-arch appendDoubleArg // helpers pass it correctly for the target ABI. diff --git a/v3/internal/webview2/pkg/edge/ICoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler.go b/v3/internal/webview2/pkg/edge/ICoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler.go new file mode 100644 index 00000000000..b9ac1587d1a --- /dev/null +++ b/v3/internal/webview2/pkg/edge/ICoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler.go @@ -0,0 +1,50 @@ +//go:build windows + +package edge + +type iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerVtbl struct { + _IUnknownVtbl + Invoke ComProc +} + +type iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler struct { + vtbl *iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerVtbl + impl iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerImpl +} + +func iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerIUnknownQueryInterface(this *iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler, refiid, object uintptr) uintptr { + return this.impl.QueryInterface(refiid, object) +} + +func iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerIUnknownAddRef(this *iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler) uintptr { + return this.impl.AddRef() +} + +func iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerIUnknownRelease(this *iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler) uintptr { + return this.impl.Release() +} + +func iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerInvoke(this *iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler, errorCode uintptr, result *ICoreWebView2CompositionController) uintptr { + return this.impl.CreateCoreWebView2CompositionControllerCompleted(errorCode, result) +} + +type iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerImpl interface { + _IUnknownImpl + CreateCoreWebView2CompositionControllerCompleted(errorCode uintptr, result *ICoreWebView2CompositionController) uintptr +} + +var iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerFn = iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerVtbl{ + _IUnknownVtbl{ + NewComProc(iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerIUnknownQueryInterface), + NewComProc(iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerIUnknownAddRef), + NewComProc(iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerIUnknownRelease), + }, + NewComProc(iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerInvoke), +} + +func newICoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler(impl iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerImpl) *iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler { + return &iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler{ + vtbl: &iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandlerFn, + impl: impl, + } +} diff --git a/v3/internal/webview2/pkg/edge/ICoreWebView2CursorChangedEventHandler.go b/v3/internal/webview2/pkg/edge/ICoreWebView2CursorChangedEventHandler.go new file mode 100644 index 00000000000..7c816d36639 --- /dev/null +++ b/v3/internal/webview2/pkg/edge/ICoreWebView2CursorChangedEventHandler.go @@ -0,0 +1,50 @@ +//go:build windows + +package edge + +type iCoreWebView2CursorChangedEventHandlerVtbl struct { + _IUnknownVtbl + Invoke ComProc +} + +type iCoreWebView2CursorChangedEventHandler struct { + vtbl *iCoreWebView2CursorChangedEventHandlerVtbl + impl iCoreWebView2CursorChangedEventHandlerImpl +} + +func iCoreWebView2CursorChangedEventHandlerIUnknownQueryInterface(this *iCoreWebView2CursorChangedEventHandler, refiid, object uintptr) uintptr { + return this.impl.QueryInterface(refiid, object) +} + +func iCoreWebView2CursorChangedEventHandlerIUnknownAddRef(this *iCoreWebView2CursorChangedEventHandler) uintptr { + return this.impl.AddRef() +} + +func iCoreWebView2CursorChangedEventHandlerIUnknownRelease(this *iCoreWebView2CursorChangedEventHandler) uintptr { + return this.impl.Release() +} + +func iCoreWebView2CursorChangedEventHandlerInvoke(this *iCoreWebView2CursorChangedEventHandler, sender *ICoreWebView2CompositionController, args *IUnknown) uintptr { + return this.impl.CursorChanged(sender, args) +} + +type iCoreWebView2CursorChangedEventHandlerImpl interface { + _IUnknownImpl + CursorChanged(sender *ICoreWebView2CompositionController, args *IUnknown) uintptr +} + +var iCoreWebView2CursorChangedEventHandlerFn = iCoreWebView2CursorChangedEventHandlerVtbl{ + _IUnknownVtbl{ + NewComProc(iCoreWebView2CursorChangedEventHandlerIUnknownQueryInterface), + NewComProc(iCoreWebView2CursorChangedEventHandlerIUnknownAddRef), + NewComProc(iCoreWebView2CursorChangedEventHandlerIUnknownRelease), + }, + NewComProc(iCoreWebView2CursorChangedEventHandlerInvoke), +} + +func newICoreWebView2CursorChangedEventHandler(impl iCoreWebView2CursorChangedEventHandlerImpl) *iCoreWebView2CursorChangedEventHandler { + return &iCoreWebView2CursorChangedEventHandler{ + vtbl: &iCoreWebView2CursorChangedEventHandlerFn, + impl: impl, + } +} diff --git a/v3/internal/webview2/pkg/edge/ICoreWebView2Environment3.go b/v3/internal/webview2/pkg/edge/ICoreWebView2Environment3.go new file mode 100644 index 00000000000..992278ee4c7 --- /dev/null +++ b/v3/internal/webview2/pkg/edge/ICoreWebView2Environment3.go @@ -0,0 +1,63 @@ +//go:build windows + +package edge + +import ( + "syscall" + "unsafe" + + "golang.org/x/sys/windows" +) + +type iCoreWebView2Environment3Vtbl struct { + _IUnknownVtbl + CreateCoreWebView2Controller ComProc + CreateWebResourceResponse ComProc + GetBrowserVersionString ComProc + AddNewBrowserVersionAvailable ComProc + RemoveNewBrowserVersionAvailable ComProc + CreateWebResourceRequest ComProc + CreateCoreWebView2CompositionController ComProc + CreateCoreWebView2PointerInfo ComProc +} + +type ICoreWebView2Environment3 struct { + vtbl *iCoreWebView2Environment3Vtbl +} + +func (e *ICoreWebView2Environment3) AddRef() uintptr { + ret, _, _ := e.vtbl.AddRef.Call(uintptr(unsafe.Pointer(e))) + + return ret +} + +func (e *ICoreWebView2Environment3) Release() uintptr { + ret, _, _ := e.vtbl.Release.Call(uintptr(unsafe.Pointer(e))) + + return ret +} + +func (e *ICoreWebView2Environment) GetICoreWebView2Environment3() *ICoreWebView2Environment3 { + var result *ICoreWebView2Environment3 + + iidICoreWebView2Environment3 := NewGUID("{80a22ae3-be7c-4ce2-afe1-5a50056cdeeb}") + _, _, _ = e.vtbl.QueryInterface.Call( + uintptr(unsafe.Pointer(e)), + uintptr(unsafe.Pointer(iidICoreWebView2Environment3)), + uintptr(unsafe.Pointer(&result))) + + return result +} + +func (e *ICoreWebView2Environment3) CreateCoreWebView2CompositionController(parentWindow uintptr, handler *iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler) error { + hr, _, _ := e.vtbl.CreateCoreWebView2CompositionController.Call( + uintptr(unsafe.Pointer(e)), + parentWindow, + uintptr(unsafe.Pointer(handler)), + ) + if windows.Handle(hr) != windows.S_OK { + return syscall.Errno(hr) + } + + return nil +} diff --git a/v3/internal/webview2/pkg/edge/ICoreWebView2NavigationStartingEventHandler.go b/v3/internal/webview2/pkg/edge/ICoreWebView2NavigationStartingEventHandler.go new file mode 100644 index 00000000000..7cf3c32b9f6 --- /dev/null +++ b/v3/internal/webview2/pkg/edge/ICoreWebView2NavigationStartingEventHandler.go @@ -0,0 +1,58 @@ +//go:build windows + +package edge + +import "unsafe" + +type _ICoreWebView2NavigationStartingEventHandlerVtbl struct { + _IUnknownVtbl + Invoke ComProc +} + +type ICoreWebView2NavigationStartingEventHandler struct { + vtbl *_ICoreWebView2NavigationStartingEventHandlerVtbl + impl _ICoreWebView2NavigationStartingEventHandlerImpl +} + +func (i *ICoreWebView2NavigationStartingEventHandler) AddRef() uintptr { + ret, _, _ := i.vtbl.AddRef.Call(uintptr(unsafe.Pointer(i))) + + return ret +} + +func _ICoreWebView2NavigationStartingEventHandlerIUnknownQueryInterface(this *ICoreWebView2NavigationStartingEventHandler, refiid, object uintptr) uintptr { + return this.impl.QueryInterface(refiid, object) +} + +func _ICoreWebView2NavigationStartingEventHandlerIUnknownAddRef(this *ICoreWebView2NavigationStartingEventHandler) uintptr { + return this.impl.AddRef() +} + +func _ICoreWebView2NavigationStartingEventHandlerIUnknownRelease(this *ICoreWebView2NavigationStartingEventHandler) uintptr { + return this.impl.Release() +} + +func _ICoreWebView2NavigationStartingEventHandlerInvoke(this *ICoreWebView2NavigationStartingEventHandler, sender *ICoreWebView2, args *IUnknown) uintptr { + return this.impl.NavigationStarting(sender, args) +} + +type _ICoreWebView2NavigationStartingEventHandlerImpl interface { + _IUnknownImpl + NavigationStarting(sender *ICoreWebView2, args *IUnknown) uintptr +} + +var _ICoreWebView2NavigationStartingEventHandlerFn = _ICoreWebView2NavigationStartingEventHandlerVtbl{ + _IUnknownVtbl{ + NewComProc(_ICoreWebView2NavigationStartingEventHandlerIUnknownQueryInterface), + NewComProc(_ICoreWebView2NavigationStartingEventHandlerIUnknownAddRef), + NewComProc(_ICoreWebView2NavigationStartingEventHandlerIUnknownRelease), + }, + NewComProc(_ICoreWebView2NavigationStartingEventHandlerInvoke), +} + +func newICoreWebView2NavigationStartingEventHandler(impl _ICoreWebView2NavigationStartingEventHandlerImpl) *ICoreWebView2NavigationStartingEventHandler { + return &ICoreWebView2NavigationStartingEventHandler{ + vtbl: &_ICoreWebView2NavigationStartingEventHandlerFn, + impl: impl, + } +} diff --git a/v3/internal/webview2/pkg/edge/ICoreWebView2Settings9.go b/v3/internal/webview2/pkg/edge/ICoreWebView2Settings9.go new file mode 100644 index 00000000000..e80ba2e0950 --- /dev/null +++ b/v3/internal/webview2/pkg/edge/ICoreWebView2Settings9.go @@ -0,0 +1,95 @@ +//go:build windows + +package edge + +import ( + "syscall" + "unsafe" + + "golang.org/x/sys/windows" +) + +type ICoreWebView2Settings9Vtbl struct { + _IUnknownVtbl + GetIsScriptEnabled ComProc + PutIsScriptEnabled ComProc + GetIsWebMessageEnabled ComProc + PutIsWebMessageEnabled ComProc + GetAreDefaultScriptDialogsEnabled ComProc + PutAreDefaultScriptDialogsEnabled ComProc + GetIsStatusBarEnabled ComProc + PutIsStatusBarEnabled ComProc + GetAreDevToolsEnabled ComProc + PutAreDevToolsEnabled ComProc + GetAreDefaultContextMenusEnabled ComProc + PutAreDefaultContextMenusEnabled ComProc + GetAreHostObjectsAllowed ComProc + PutAreHostObjectsAllowed ComProc + GetIsZoomControlEnabled ComProc + PutIsZoomControlEnabled ComProc + GetIsBuiltInErrorPageEnabled ComProc + PutIsBuiltInErrorPageEnabled ComProc + GetUserAgent ComProc + PutUserAgent ComProc + GetAreBrowserAcceleratorKeysEnabled ComProc + PutAreBrowserAcceleratorKeysEnabled ComProc + GetIsPasswordAutosaveEnabled ComProc + PutIsPasswordAutosaveEnabled ComProc + GetIsGeneralAutofillEnabled ComProc + PutIsGeneralAutofillEnabled ComProc + GetIsPinchZoomEnabled ComProc + PutIsPinchZoomEnabled ComProc + GetIsSwipeNavigationEnabled ComProc + PutIsSwipeNavigationEnabled ComProc + GetHiddenPdfToolbarItems ComProc + PutHiddenPdfToolbarItems ComProc + GetIsReputationCheckingRequired ComProc + PutIsReputationCheckingRequired ComProc + GetIsNonClientRegionSupportEnabled ComProc + PutIsNonClientRegionSupportEnabled ComProc +} + +type ICoreWebView2Settings9 struct { + Vtbl *ICoreWebView2Settings9Vtbl +} + +func (i *ICoreWebView2Settings9) AddRef() uintptr { + refCounter, _, _ := i.Vtbl.AddRef.Call(uintptr(unsafe.Pointer(i))) + return refCounter +} + +func (i *ICoreWebViewSettings) GetICoreWebView2Settings9() *ICoreWebView2Settings9 { + var result *ICoreWebView2Settings9 + + iidICoreWebView2Settings9 := NewGUID("{0528a73b-e92d-49f4-927a-e547dddaa37d}") + _, _, _ = i.vtbl.QueryInterface.Call( + uintptr(unsafe.Pointer(i)), + uintptr(unsafe.Pointer(iidICoreWebView2Settings9)), + uintptr(unsafe.Pointer(&result))) + + return result +} + +func (i *ICoreWebView2Settings9) GetIsNonClientRegionSupportEnabled() (bool, error) { + var value int32 + + hr, _, _ := i.Vtbl.GetIsNonClientRegionSupportEnabled.Call( + uintptr(unsafe.Pointer(i)), + uintptr(unsafe.Pointer(&value)), + ) + if windows.Handle(hr) != windows.S_OK { + return false, syscall.Errno(hr) + } + return value != 0, nil +} + +func (i *ICoreWebView2Settings9) PutIsNonClientRegionSupportEnabled(value bool) error { + hr, _, _ := i.Vtbl.PutIsNonClientRegionSupportEnabled.Call( + uintptr(unsafe.Pointer(i)), + uintptr(boolToInt(value)), + ) + if windows.Handle(hr) != windows.S_OK { + return syscall.Errno(hr) + } + return nil +} diff --git a/v3/internal/webview2/pkg/edge/IDCompositionDevice.go b/v3/internal/webview2/pkg/edge/IDCompositionDevice.go new file mode 100644 index 00000000000..f6910df3098 --- /dev/null +++ b/v3/internal/webview2/pkg/edge/IDCompositionDevice.go @@ -0,0 +1,86 @@ +//go:build windows + +package edge + +import ( + "syscall" + "unsafe" + + "golang.org/x/sys/windows" +) + +var procDCompositionCreateDevice2 = windows.NewLazySystemDLL("dcomp.dll").NewProc("DCompositionCreateDevice2") + +type iDCompositionDeviceVtbl struct { + _IUnknownVtbl + Commit ComProc + WaitForCommitCompletion ComProc + GetFrameStatistics ComProc + CreateTargetForHwnd ComProc + CreateVisual ComProc +} + +type iDCompositionDevice struct { + vtbl *iDCompositionDeviceVtbl +} + +func (d *iDCompositionDevice) AddRef() uintptr { + ret, _, _ := d.vtbl.AddRef.Call(uintptr(unsafe.Pointer(d))) + + return ret +} + +func (d *iDCompositionDevice) Release() uintptr { + ret, _, _ := d.vtbl.Release.Call(uintptr(unsafe.Pointer(d))) + + return ret +} + +func dCompositionCreateDevice2() (*iDCompositionDevice, error) { + var device *iDCompositionDevice + iidIDCompositionDevice := NewGUID("{C37EA93A-E7AA-450D-B16F-9746CB0407F3}") + + hr, _, _ := procDCompositionCreateDevice2.Call( + 0, + uintptr(unsafe.Pointer(iidIDCompositionDevice)), + uintptr(unsafe.Pointer(&device)), + ) + if windows.Handle(hr) != windows.S_OK { + return nil, syscall.Errno(hr) + } + return device, nil +} + +func (d *iDCompositionDevice) CreateTargetForHwnd(hwnd uintptr, topmost bool) (*iDCompositionTarget, error) { + var target *iDCompositionTarget + hr, _, _ := d.vtbl.CreateTargetForHwnd.Call( + uintptr(unsafe.Pointer(d)), + hwnd, + uintptr(boolToInt(topmost)), + uintptr(unsafe.Pointer(&target)), + ) + if windows.Handle(hr) != windows.S_OK { + return nil, syscall.Errno(hr) + } + return target, nil +} + +func (d *iDCompositionDevice) CreateVisual() (*iDCompositionVisual, error) { + var visual *iDCompositionVisual + hr, _, _ := d.vtbl.CreateVisual.Call( + uintptr(unsafe.Pointer(d)), + uintptr(unsafe.Pointer(&visual)), + ) + if windows.Handle(hr) != windows.S_OK { + return nil, syscall.Errno(hr) + } + return visual, nil +} + +func (d *iDCompositionDevice) Commit() error { + hr, _, _ := d.vtbl.Commit.Call(uintptr(unsafe.Pointer(d))) + if windows.Handle(hr) != windows.S_OK { + return syscall.Errno(hr) + } + return nil +} diff --git a/v3/internal/webview2/pkg/edge/IDCompositionTarget.go b/v3/internal/webview2/pkg/edge/IDCompositionTarget.go new file mode 100644 index 00000000000..b5b1c131408 --- /dev/null +++ b/v3/internal/webview2/pkg/edge/IDCompositionTarget.go @@ -0,0 +1,42 @@ +//go:build windows + +package edge + +import ( + "syscall" + "unsafe" + + "golang.org/x/sys/windows" +) + +type iDCompositionTargetVtbl struct { + _IUnknownVtbl + SetRoot ComProc +} + +type iDCompositionTarget struct { + vtbl *iDCompositionTargetVtbl +} + +func (t *iDCompositionTarget) AddRef() uintptr { + ret, _, _ := t.vtbl.AddRef.Call(uintptr(unsafe.Pointer(t))) + + return ret +} + +func (t *iDCompositionTarget) Release() uintptr { + ret, _, _ := t.vtbl.Release.Call(uintptr(unsafe.Pointer(t))) + + return ret +} + +func (t *iDCompositionTarget) SetRoot(visual *iDCompositionVisual) error { + hr, _, _ := t.vtbl.SetRoot.Call( + uintptr(unsafe.Pointer(t)), + uintptr(unsafe.Pointer(visual)), + ) + if windows.Handle(hr) != windows.S_OK { + return syscall.Errno(hr) + } + return nil +} diff --git a/v3/internal/webview2/pkg/edge/IDCompositionVisual.go b/v3/internal/webview2/pkg/edge/IDCompositionVisual.go new file mode 100644 index 00000000000..9e7444ab18d --- /dev/null +++ b/v3/internal/webview2/pkg/edge/IDCompositionVisual.go @@ -0,0 +1,25 @@ +//go:build windows + +package edge + +import "unsafe" + +type iDCompositionVisualVtbl struct { + _IUnknownVtbl +} + +type iDCompositionVisual struct { + vtbl *iDCompositionVisualVtbl +} + +func (v *iDCompositionVisual) AddRef() uintptr { + ret, _, _ := v.vtbl.AddRef.Call(uintptr(unsafe.Pointer(v))) + + return ret +} + +func (v *iDCompositionVisual) Release() uintptr { + ret, _, _ := v.vtbl.Release.Call(uintptr(unsafe.Pointer(v))) + + return ret +} diff --git a/v3/internal/webview2/pkg/edge/chromium.go b/v3/internal/webview2/pkg/edge/chromium.go index 2440d3e417a..7b3d39b02b7 100644 --- a/v3/internal/webview2/pkg/edge/chromium.go +++ b/v3/internal/webview2/pkg/edge/chromium.go @@ -56,26 +56,34 @@ type Chromium struct { } controller *ICoreWebView2Controller + compositionController *ICoreWebView2CompositionController + compositionController4 *ICoreWebView2CompositionController4 webview *ICoreWebView2 inited uintptr envCompleted *iCoreWebView2CreateCoreWebView2EnvironmentCompletedHandler controllerCompleted *iCoreWebView2CreateCoreWebView2ControllerCompletedHandler + compositionControllerCompleted *iCoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler webMessageReceived *iCoreWebView2WebMessageReceivedEventHandler containsFullScreenElementChanged *ICoreWebView2ContainsFullScreenElementChangedEventHandler permissionRequested *iCoreWebView2PermissionRequestedEventHandler webResourceRequested *iCoreWebView2WebResourceRequestedEventHandler acceleratorKeyPressed *ICoreWebView2AcceleratorKeyPressedEventHandler + cursorChanged *iCoreWebView2CursorChangedEventHandler + navigationStarting *ICoreWebView2NavigationStartingEventHandler navigationCompleted *ICoreWebView2NavigationCompletedEventHandler processFailed *ICoreWebView2ProcessFailedEventHandler environment *ICoreWebView2Environment webview2RuntimeVersion string + compositionHost *compositionHost // Settings - Debug bool - DataPath string - BrowserPath string - AdditionalBrowserArgs []string + Debug bool + DataPath string + BrowserPath string + AdditionalBrowserArgs []string + NonClientRegionSupportEnabled bool + CompositionControllerEnabled bool // permissions permissions map[CoreWebView2PermissionKind]CoreWebView2PermissionState @@ -85,10 +93,12 @@ type Chromium struct { MessageCallback func(message string, sender *ICoreWebView2, args *ICoreWebView2WebMessageReceivedEventArgs) MessageWithAdditionalObjectsCallback func(message string, sender *ICoreWebView2, args *ICoreWebView2WebMessageReceivedEventArgs) WebResourceRequestedCallback func(request *ICoreWebView2WebResourceRequest, args *ICoreWebView2WebResourceRequestedEventArgs) + NavigationStartingCallback func(sender *ICoreWebView2) NavigationCompletedCallback func(sender *ICoreWebView2, args *ICoreWebView2NavigationCompletedEventArgs) ProcessFailedCallback func(sender *ICoreWebView2, args *ICoreWebView2ProcessFailedEventArgs) ContainsFullScreenElementChangedCallback func(sender *ICoreWebView2, args *ICoreWebView2ContainsFullScreenElementChangedEventArgs) AcceleratorKeyCallback func(uint) bool + CursorChangedCallback func(cursor HCURSOR, systemCursorID uint32) // Error handling globalErrorCallback func(error) @@ -115,10 +125,13 @@ func NewChromium() *Chromium { */ e.envCompleted = newICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler(e) e.controllerCompleted = newICoreWebView2CreateCoreWebView2ControllerCompletedHandler(e) + e.compositionControllerCompleted = newICoreWebView2CreateCoreWebView2CompositionControllerCompletedHandler(e) e.webMessageReceived = newICoreWebView2WebMessageReceivedEventHandler(e) e.permissionRequested = newICoreWebView2PermissionRequestedEventHandler(e) e.webResourceRequested = newICoreWebView2WebResourceRequestedEventHandler(e) e.acceleratorKeyPressed = newICoreWebView2AcceleratorKeyPressedEventHandler(e) + e.cursorChanged = newICoreWebView2CursorChangedEventHandler(e) + e.navigationStarting = newICoreWebView2NavigationStartingEventHandler(e) e.navigationCompleted = newICoreWebView2NavigationCompletedEventHandler(e) e.processFailed = newICoreWebView2ProcessFailedEventHandler(e) e.containsFullScreenElementChanged = newICoreWebView2ContainsFullScreenElementChangedEventHandler(e) @@ -158,6 +171,12 @@ func (e *Chromium) SetErrorCallback(callback func(error)) { } } +func (e *Chromium) SetCursorChangedCallback(callback func(cursor HCURSOR, systemCursorID uint32)) { + if callback != nil { + e.CursorChangedCallback = callback + } +} + func (e *Chromium) Embed(hwnd uintptr) bool { var err error @@ -328,10 +347,18 @@ func (e *Chromium) EnvironmentCompleted(res uintptr, env *ICoreWebView2Environme log.Printf("[WebView2] Environment created successfully\n") - env.vtbl.AddRef.Call(uintptr(unsafe.Pointer(env))) + env.AddRef() e.environment = env - err := env.CreateCoreWebView2Controller(e.hwnd, e.controllerCompleted) + var err error + if !e.CompositionControllerEnabled { + err = env.CreateCoreWebView2Controller(e.hwnd, e.controllerCompleted) + } else { + err = e.createCoreWebView2CompositionController(env) + if err != nil { + err = e.fallbackToCoreWebView2Controller(fmt.Errorf("composition controller setup failed: %w", err)) + } + } if err != nil { e.errorCallback(err) } @@ -343,29 +370,130 @@ func (e *Chromium) CreateCoreWebView2ControllerCompleted(res uintptr, controller e.errorCallback(fmt.Errorf("error creating controller with %08x: %s", res, syscall.Errno(res))) } + return e.initializeController(controller) +} + +func (e *Chromium) createCoreWebView2CompositionController(env *ICoreWebView2Environment) error { + env3 := env.GetICoreWebView2Environment3() + if env3 == nil { + return UnsupportedCapabilityError + } + defer env3.Release() + + host, err := newCompositionHost(e.hwnd) + if err != nil { + return err + } + e.compositionHost = host + + return env3.CreateCoreWebView2CompositionController(e.hwnd, e.compositionControllerCompleted) +} + +func (e *Chromium) CreateCoreWebView2CompositionControllerCompleted(res uintptr, compositionController *ICoreWebView2CompositionController) uintptr { + if int32(res) < 0 { + if err := e.fallbackToCoreWebView2Controller(fmt.Errorf("error creating composition controller with %08x: %s", res, syscall.Errno(res))); err != nil { + e.errorCallback(err) + } + return 0 + } + + if compositionController == nil { + if err := e.fallbackToCoreWebView2Controller(fmt.Errorf("composition controller completed without a controller")); err != nil { + e.errorCallback(err) + } + return 0 + } + + compositionController.AddRef() + e.compositionController = compositionController + e.compositionController4 = compositionController.GetICoreWebView2CompositionController4() + + if err := e.compositionHost.attachController(e.compositionController); err != nil { + if fallbackErr := e.fallbackToCoreWebView2Controller(fmt.Errorf("attaching composition controller failed: %w", err)); fallbackErr != nil { + e.errorCallback(fallbackErr) + } + return 0 + } + + controller := compositionController.GetICoreWebView2Controller() + if controller == nil { + if err := e.fallbackToCoreWebView2Controller(fmt.Errorf("error getting controller from composition controller")); err != nil { + e.errorCallback(err) + } + return 0 + } + + return e.initializeController(controller) +} + +func (e *Chromium) fallbackToCoreWebView2Controller(reason error) error { + log.Printf("[WebView2] Composition hosting unavailable, falling back to HWND controller: %v\n", reason) + + e.releaseCompositionController() + e.releaseCompositionHost() + e.CompositionControllerEnabled = false + + if e.environment == nil { + return fmt.Errorf("cannot fall back to WebView2 HWND controller without an environment: %w", reason) + } + if err := e.environment.CreateCoreWebView2Controller(e.hwnd, e.controllerCompleted); err != nil { + return fmt.Errorf("composition hosting failed (%v), and HWND controller fallback failed: %w", reason, err) + } + return nil +} + +func (e *Chromium) releaseCompositionController() { + if e.compositionController4 != nil { + e.compositionController4.Release() + e.compositionController4 = nil + } + if e.compositionController != nil { + if controller := e.compositionController.GetICoreWebView2Controller(); controller != nil { + _ = controller.Close() + controller.Release() + } + e.compositionController.Release() + e.compositionController = nil + } +} + +func (e *Chromium) releaseCompositionHost() { + if e.compositionHost != nil { + e.compositionHost.release() + e.compositionHost = nil + } +} + +func (e *Chromium) initializeController(controller *ICoreWebView2Controller) uintptr { var err error - controller.vtbl.AddRef.Call(uintptr(unsafe.Pointer(controller))) + controller.AddRef() e.controller = controller - // Try to get ICoreWebView2Controller3 interface for better performance + // Try to get ICoreWebView2Controller3 interface for better performance. + // Keep composition-hosted WebViews on WebView2-managed scale detection: + // the DirectComposition surface is owned by WebView2, and manually + // reasserting RasterizationScale during monitor transitions can leave that + // surface black after DPI increases. if controller3 := e.controller.GetICoreWebView2Controller3(); controller3 != nil { - // Use raw pixels mode for better performance during resize - if err := controller3.PutBoundsMode(COREWEBVIEW2_BOUNDS_MODE_USE_RAW_PIXELS); err != nil { - e.errorCallback(err) - } + if !e.CompositionControllerEnabled { + // Use raw pixels mode for better performance during resize. + if err := controller3.PutBoundsMode(COREWEBVIEW2_BOUNDS_MODE_USE_RAW_PIXELS); err != nil { + e.errorCallback(err) + } - // ShouldDetectMonitorScaleChanges is deliberately left at its default - // (enabled): WebView2 tracks monitor DPI changes and updates its own - // rasterization scale. This module previously disabled it and left the - // scale to the host's WM_DPICHANGED handling, but an externally - // written scale races the browser process's internal display - // bookkeeping during a mixed-DPI monitor cross — the browser can land - // on a degenerate scale(0,0) compositor transform, which kills the - // GPU process on every frame until the browser process itself exits - // (wailsapp/wails#5732). Detection stays on so the scale has exactly - // one writer, on the code path every mainstream embedder exercises; - // bounds remain raw pixels, which is orthogonal. + // ShouldDetectMonitorScaleChanges is deliberately left at its default + // (enabled): WebView2 tracks monitor DPI changes and updates its own + // rasterization scale. This module previously disabled it and left the + // scale to the host's WM_DPICHANGED handling, but an externally + // written scale races the browser process's internal display + // bookkeeping during a mixed-DPI monitor cross — the browser can land + // on a degenerate scale(0,0) compositor transform, which kills the + // GPU process on every frame until the browser process itself exits + // (wailsapp/wails#5732). Detection stays on so the scale has exactly + // one writer, on the code path every mainstream embedder exercises; + // bounds remain raw pixels, which is orthogonal. + } } var token _EventRegistrationToken e.webview, err = e.controller.GetCoreWebView2() @@ -373,7 +501,14 @@ func (e *Chromium) CreateCoreWebView2ControllerCompleted(res uintptr, controller e.errorCallback(err) } - e.webview.vtbl.AddRef.Call(uintptr(unsafe.Pointer(e.webview))) + e.webview.AddRef() + if e.NonClientRegionSupportEnabled { + if err := e.PutIsNonClientRegionSupportEnabled(true); err != nil { + if !errors.Is(err, UnsupportedCapabilityError) { + e.errorCallback(err) + } + } + } err = e.webview.AddWebMessageReceived(e.webMessageReceived, &token) if err != nil { e.errorCallback(err) @@ -386,6 +521,10 @@ func (e *Chromium) CreateCoreWebView2ControllerCompleted(res uintptr, controller if err != nil { e.errorCallback(err) } + err = e.webview.AddNavigationStarting(e.navigationStarting, &token) + if err != nil { + e.errorCallback(err) + } err = e.webview.AddNavigationCompleted(e.navigationCompleted, &token) if err != nil { e.errorCallback(err) @@ -398,11 +537,16 @@ func (e *Chromium) CreateCoreWebView2ControllerCompleted(res uintptr, controller if err != nil { e.errorCallback(err) } - err = e.controller.AddAcceleratorKeyPressed(e.acceleratorKeyPressed, &token) if err != nil { e.errorCallback(err) } + if e.compositionController != nil { + err = e.compositionController.AddCursorChanged(e.cursorChanged, &token) + if err != nil { + e.errorCallback(err) + } + } atomic.StoreUintptr(&e.inited, 1) @@ -416,6 +560,27 @@ func (e *Chromium) ContainsFullScreenElementChanged(sender *ICoreWebView2, args return 0 } +func (e *Chromium) CursorChanged(sender *ICoreWebView2CompositionController, _ *IUnknown) uintptr { + if e.CursorChangedCallback == nil { + return 0 + } + + cursor, err := sender.GetCursor() + if err != nil { + e.errorCallback(err) + return 0 + } + + systemCursorID, err := sender.GetSystemCursorId() + if err != nil { + e.errorCallback(err) + return 0 + } + + e.CursorChangedCallback(cursor, systemCursorID) + return 0 +} + func (e *Chromium) MessageReceived(sender *ICoreWebView2, args *ICoreWebView2WebMessageReceivedEventArgs) uintptr { message, err := args.TryGetWebMessageAsString() if err != nil { @@ -581,6 +746,13 @@ func boolToInt(input bool) int { return 0 } +func (e *Chromium) NavigationStarting(sender *ICoreWebView2, _ *IUnknown) uintptr { + if e.NavigationStartingCallback != nil { + e.NavigationStartingCallback(sender) + } + return 0 +} + func (e *Chromium) NavigationCompleted(sender *ICoreWebView2, args *ICoreWebView2NavigationCompletedEventArgs) uintptr { if e.NavigationCompletedCallback != nil { e.NavigationCompletedCallback(sender, args) @@ -595,6 +767,19 @@ func (e *Chromium) ProcessFailed(sender *ICoreWebView2, args *ICoreWebView2Proce return 0 } +func (e *Chromium) Bounds() *Rect { + if e == nil || e.controller == nil { + return nil + } + + rect, err := e.controller.GetBounds() + if err != nil { + e.errorCallback(err) + return nil + } + return rect +} + func (e *Chromium) NotifyParentWindowPositionChanged() error { //It looks like the wndproc function is called before the controller initialization is complete. //Because of this the controller is nil @@ -643,6 +828,16 @@ func (e *Chromium) HasCapability(c Capability) bool { return HasCapability(e.webview2RuntimeVersion, c) } +func (e *Chromium) CompositionControllerReady() bool { + return e != nil && e.compositionController != nil +} + +func (e *Chromium) NonClientRegionHitTestReady() bool { + return e != nil && + e.compositionController4 != nil && + HasCapability(e.webview2RuntimeVersion, NonClientRegion) +} + func (e *Chromium) GetIsSwipeNavigationEnabled() (bool, error) { if !HasCapability(e.webview2RuntimeVersion, SwipeNavigation) { return false, UnsupportedCapabilityError @@ -711,6 +906,46 @@ func (e *Chromium) PutIsSwipeNavigationEnabled(enabled bool) error { return nil } +func (e *Chromium) PutIsNonClientRegionSupportEnabled(enabled bool) error { + if !HasCapability(e.webview2RuntimeVersion, NonClientRegion) { + return UnsupportedCapabilityError + } + webview2Settings, err := e.webview.GetSettings() + if err != nil { + return err + } + webview2Settings9 := webview2Settings.GetICoreWebView2Settings9() + if webview2Settings9 == nil { + return UnsupportedCapabilityError + } + return webview2Settings9.PutIsNonClientRegionSupportEnabled(enabled) +} + +func (e *Chromium) GetNonClientRegionAtPoint(x, y int32) (COREWEBVIEW2_NON_CLIENT_REGION_KIND, bool, error) { + if !e.NonClientRegionHitTestReady() { + return COREWEBVIEW2_NON_CLIENT_REGION_KIND_NOWHERE, false, nil + } + + region, err := e.compositionController4.GetNonClientRegionAtPoint(POINT{X: x, Y: y}) + if err != nil { + return COREWEBVIEW2_NON_CLIENT_REGION_KIND_NOWHERE, false, err + } + return region, true, nil +} + +func (e *Chromium) SendMouseInput( + eventKind COREWEBVIEW2_MOUSE_EVENT_KIND, + virtualKeys COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS, + mouseData uint32, + x, y int, +) error { + if !e.CompositionControllerReady() { + return errors.New("webview2 composition controller is not initialized") + } + + return e.compositionController.SendMouseInput(eventKind, virtualKeys, mouseData, POINT{X: int32(x), Y: int32(y)}) +} + func (e *Chromium) AllowExternalDrag(allow bool) error { if !HasCapability(e.webview2RuntimeVersion, AllowExternalDrop) { return UnsupportedCapabilityError diff --git a/v3/internal/webview2/pkg/edge/com.go b/v3/internal/webview2/pkg/edge/com.go index 72cb64d9d12..43b1807f9ba 100644 --- a/v3/internal/webview2/pkg/edge/com.go +++ b/v3/internal/webview2/pkg/edge/com.go @@ -39,6 +39,11 @@ type IUnknownImpl interface { type POINT struct { X, Y int32 } + +func (p POINT) uintptr() uintptr { + return uintptr(uint32(p.X)) | uintptr(uint64(uint32(p.Y))<<32) +} + type RECT struct { Left int32 Top int32 diff --git a/v3/internal/webview2/pkg/edge/composition_host.go b/v3/internal/webview2/pkg/edge/composition_host.go new file mode 100644 index 00000000000..7d91d96e37d --- /dev/null +++ b/v3/internal/webview2/pkg/edge/composition_host.go @@ -0,0 +1,68 @@ +//go:build windows + +package edge + +import ( + "errors" + "unsafe" +) + +type compositionHost struct { + device *iDCompositionDevice + target *iDCompositionTarget + visual *iDCompositionVisual +} + +func newCompositionHost(hwnd uintptr) (*compositionHost, error) { + device, err := dCompositionCreateDevice2() + if err != nil { + return nil, err + } + target, err := device.CreateTargetForHwnd(hwnd, true) + if err != nil { + device.Release() + return nil, err + } + visual, err := device.CreateVisual() + if err != nil { + target.Release() + device.Release() + return nil, err + } + return &compositionHost{ + device: device, + target: target, + visual: visual, + }, nil +} + +func (h *compositionHost) attachController(controller *ICoreWebView2CompositionController) error { + if h == nil || h.device == nil || h.target == nil || h.visual == nil || controller == nil { + return errors.New("direct composition host is not initialized") + } + if err := controller.PutRootVisualTarget((*IUnknown)(unsafe.Pointer(h.visual))); err != nil { + return err + } + if err := h.target.SetRoot(h.visual); err != nil { + return err + } + return h.device.Commit() +} + +func (h *compositionHost) release() { + if h == nil { + return + } + if h.visual != nil { + h.visual.Release() + h.visual = nil + } + if h.target != nil { + h.target.Release() + h.target = nil + } + if h.device != nil { + h.device.Release() + h.device = nil + } +} diff --git a/v3/internal/webview2/pkg/edge/corewebview2.go b/v3/internal/webview2/pkg/edge/corewebview2.go index d99d2825954..4c0cf013c55 100644 --- a/v3/internal/webview2/pkg/edge/corewebview2.go +++ b/v3/internal/webview2/pkg/edge/corewebview2.go @@ -209,6 +209,19 @@ func (i *ICoreWebView2) AddContainsFullScreenElementChanged(eventHandler *ICoreW return nil } +func (i *ICoreWebView2) AddNavigationStarting(eventHandler *ICoreWebView2NavigationStartingEventHandler, token *_EventRegistrationToken) error { + hr, _, _ := i.vtbl.AddNavigationStarting.Call( + uintptr(unsafe.Pointer(i)), + uintptr(unsafe.Pointer(eventHandler)), + uintptr(unsafe.Pointer(token)), + ) + if windows.Handle(hr) != windows.S_OK { + return windows.Errno(hr) + } + + return nil +} + func (i *ICoreWebView2) AddNavigationCompleted(eventHandler *ICoreWebView2NavigationCompletedEventHandler, token *_EventRegistrationToken) error { hr, _, _ := i.vtbl.AddNavigationCompleted.Call( uintptr(unsafe.Pointer(i)), @@ -434,6 +447,18 @@ type ICoreWebView2Environment struct { vtbl *iCoreWebView2EnvironmentVtbl } +func (e *ICoreWebView2Environment) AddRef() uintptr { + ret, _, _ := e.vtbl.AddRef.Call(uintptr(unsafe.Pointer(e))) + + return ret +} + +func (e *ICoreWebView2Environment) Release() uintptr { + ret, _, _ := e.vtbl.Release.Call(uintptr(unsafe.Pointer(e))) + + return ret +} + // CreateCoreWebView2Controller asynchronously creates a new WebView. func (e *ICoreWebView2Environment) CreateCoreWebView2Controller(parentWindow uintptr, handler *iCoreWebView2CreateCoreWebView2ControllerCompletedHandler) error { hr, _, _ := e.vtbl.CreateCoreWebView2Controller.Call( diff --git a/v3/pkg/application/application_server.go b/v3/pkg/application/application_server.go index c7ed9696ac2..353f2cabe94 100644 --- a/v3/pkg/application/application_server.go +++ b/v3/pkg/application/application_server.go @@ -533,37 +533,38 @@ func (w *serverWebviewWindow) startDrag() error { func (w *serverWebviewWindow) startResize(border string) error { return errors.New("resize not available in server mode") } -func (w *serverWebviewWindow) print() error { return errors.New("print not available in server mode") } -func (w *serverWebviewWindow) setEnabled(enabled bool) {} -func (w *serverWebviewWindow) physicalBounds() Rect { return Rect{} } -func (w *serverWebviewWindow) setPhysicalBounds(bounds Rect) {} -func (w *serverWebviewWindow) bounds() Rect { return Rect{} } -func (w *serverWebviewWindow) setBounds(bounds Rect) {} -func (w *serverWebviewWindow) position() (int, int) { return 0, 0 } -func (w *serverWebviewWindow) setPosition(x int, y int) {} -func (w *serverWebviewWindow) centerOnScreen(_ *Screen) {} -func (w *serverWebviewWindow) relativePosition() (int, int) { return 0, 0 } -func (w *serverWebviewWindow) setRelativePosition(x int, y int) {} -func (w *serverWebviewWindow) flash(enabled bool) {} -func (w *serverWebviewWindow) handleKeyEvent(acceleratorString string) {} -func (w *serverWebviewWindow) getBorderSizes() *LRTB { return &LRTB{} } -func (w *serverWebviewWindow) setMinimiseButtonState(state ButtonState) {} -func (w *serverWebviewWindow) setMaximiseButtonState(state ButtonState) {} -func (w *serverWebviewWindow) setCloseButtonState(state ButtonState) {} -func (w *serverWebviewWindow) setFullscreenButtonState(state ButtonState) {} -func (w *serverWebviewWindow) isIgnoreMouseEvents() bool { return false } -func (w *serverWebviewWindow) setIgnoreMouseEvents(ignore bool) {} -func (w *serverWebviewWindow) cut() {} -func (w *serverWebviewWindow) copy() {} -func (w *serverWebviewWindow) paste() {} -func (w *serverWebviewWindow) undo() {} -func (w *serverWebviewWindow) delete() {} -func (w *serverWebviewWindow) selectAll() {} -func (w *serverWebviewWindow) redo() {} -func (w *serverWebviewWindow) showMenuBar() {} -func (w *serverWebviewWindow) hideMenuBar() {} -func (w *serverWebviewWindow) toggleMenuBar() {} -func (w *serverWebviewWindow) setMenu(menu *Menu) {} -func (w *serverWebviewWindow) snapAssist() {} -func (w *serverWebviewWindow) attachModal(modalWindow *WebviewWindow) {} -func (w *serverWebviewWindow) setContentProtection(enabled bool) {} +func (w *serverWebviewWindow) print() error { return errors.New("print not available in server mode") } +func (w *serverWebviewWindow) setEnabled(enabled bool) {} +func (w *serverWebviewWindow) physicalBounds() Rect { return Rect{} } +func (w *serverWebviewWindow) setPhysicalBounds(bounds Rect) {} +func (w *serverWebviewWindow) bounds() Rect { return Rect{} } +func (w *serverWebviewWindow) setBounds(bounds Rect) {} +func (w *serverWebviewWindow) position() (int, int) { return 0, 0 } +func (w *serverWebviewWindow) setPosition(x int, y int) {} +func (w *serverWebviewWindow) centerOnScreen(_ *Screen) {} +func (w *serverWebviewWindow) relativePosition() (int, int) { return 0, 0 } +func (w *serverWebviewWindow) setRelativePosition(x int, y int) {} +func (w *serverWebviewWindow) flash(enabled bool) {} +func (w *serverWebviewWindow) handleKeyEvent(acceleratorString string) {} +func (w *serverWebviewWindow) getBorderSizes() *LRTB { return &LRTB{} } +func (w *serverWebviewWindow) setMinimiseButtonState(state ButtonState) {} +func (w *serverWebviewWindow) setMaximiseButtonState(state ButtonState) {} +func (w *serverWebviewWindow) setCloseButtonState(state ButtonState) {} +func (w *serverWebviewWindow) setFullscreenButtonState(state ButtonState) {} +func (w *serverWebviewWindow) isIgnoreMouseEvents() bool { return false } +func (w *serverWebviewWindow) setIgnoreMouseEvents(ignore bool) {} +func (w *serverWebviewWindow) cut() {} +func (w *serverWebviewWindow) copy() {} +func (w *serverWebviewWindow) paste() {} +func (w *serverWebviewWindow) undo() {} +func (w *serverWebviewWindow) delete() {} +func (w *serverWebviewWindow) selectAll() {} +func (w *serverWebviewWindow) redo() {} +func (w *serverWebviewWindow) showMenuBar() {} +func (w *serverWebviewWindow) hideMenuBar() {} +func (w *serverWebviewWindow) toggleMenuBar() {} +func (w *serverWebviewWindow) setMenu(menu *Menu) {} +func (w *serverWebviewWindow) snapAssist() {} +func (w *serverWebviewWindow) attachModal(modalWindow *WebviewWindow) {} +func (w *serverWebviewWindow) setContentProtection(enabled bool) {} +func (w *serverWebviewWindow) setNonClientHitTestRegions([]nonClientHitTestRegion) {} diff --git a/v3/pkg/application/clipboard_windows.go b/v3/pkg/application/clipboard_windows.go index 507eac3da3e..e8c76bda423 100644 --- a/v3/pkg/application/clipboard_windows.go +++ b/v3/pkg/application/clipboard_windows.go @@ -1,4 +1,4 @@ -//go:build windows +//go:build windows && !server package application diff --git a/v3/pkg/application/dialogs_windows.go b/v3/pkg/application/dialogs_windows.go index 789c6278ffd..1185117e1f4 100644 --- a/v3/pkg/application/dialogs_windows.go +++ b/v3/pkg/application/dialogs_windows.go @@ -1,4 +1,4 @@ -//go:build windows +//go:build windows && !server package application diff --git a/v3/pkg/application/events_common_windows.go b/v3/pkg/application/events_common_windows.go index f0bcd4d84e8..66db1ba3df4 100644 --- a/v3/pkg/application/events_common_windows.go +++ b/v3/pkg/application/events_common_windows.go @@ -1,4 +1,4 @@ -//go:build windows +//go:build windows && !server package application diff --git a/v3/pkg/application/icon_windows.go b/v3/pkg/application/icon_windows.go new file mode 100644 index 00000000000..e6f17dda2fa --- /dev/null +++ b/v3/pkg/application/icon_windows.go @@ -0,0 +1,22 @@ +//go:build windows + +package application + +import ( + "fmt" + + "github.com/wailsapp/wails/v3/pkg/w32" +) + +// NewIconFromResource loads an icon from an embedded Windows resource. It is +// available in both desktop and server builds so that services which only need +// the icon helper (e.g. notifications) compile under the `server` tag, matching +// the behaviour on macOS and Linux. +func NewIconFromResource(instance w32.HINSTANCE, resId uint16) (w32.HICON, error) { + var err error + var result w32.HICON + if result = w32.LoadIconWithResourceID(instance, resId); result == 0 { + err = fmt.Errorf("cannot load icon from resource with id %v", resId) + } + return result, err +} diff --git a/v3/pkg/application/keys_windows.go b/v3/pkg/application/keys_windows.go index 8011a837dfd..a299e432483 100644 --- a/v3/pkg/application/keys_windows.go +++ b/v3/pkg/application/keys_windows.go @@ -1,4 +1,4 @@ -//go:build windows +//go:build windows && !server package application diff --git a/v3/pkg/application/mainthread_windows.go b/v3/pkg/application/mainthread_windows.go index ddee96339f8..575450a027d 100644 --- a/v3/pkg/application/mainthread_windows.go +++ b/v3/pkg/application/mainthread_windows.go @@ -1,4 +1,4 @@ -//go:build windows +//go:build windows && !server package application diff --git a/v3/pkg/application/menuitem_windows.go b/v3/pkg/application/menuitem_windows.go index c7c6f5f7a36..633c757929e 100644 --- a/v3/pkg/application/menuitem_windows.go +++ b/v3/pkg/application/menuitem_windows.go @@ -1,4 +1,4 @@ -//go:build windows +//go:build windows && !server package application diff --git a/v3/pkg/application/popupmenu_windows.go b/v3/pkg/application/popupmenu_windows.go index 75bd951cae1..4280d6d1f01 100644 --- a/v3/pkg/application/popupmenu_windows.go +++ b/v3/pkg/application/popupmenu_windows.go @@ -1,3 +1,5 @@ +//go:build windows && !server + package application import ( diff --git a/v3/pkg/application/screen_windows.go b/v3/pkg/application/screen_windows.go index 772618d4b97..1f70dd56974 100644 --- a/v3/pkg/application/screen_windows.go +++ b/v3/pkg/application/screen_windows.go @@ -1,4 +1,4 @@ -//go:build windows +//go:build windows && !server package application diff --git a/v3/pkg/application/single_instance_windows.go b/v3/pkg/application/single_instance_windows.go index b92b2749a8e..6940c301c37 100644 --- a/v3/pkg/application/single_instance_windows.go +++ b/v3/pkg/application/single_instance_windows.go @@ -1,4 +1,4 @@ -//go:build windows +//go:build windows && !server package application diff --git a/v3/pkg/application/systemtray_windows.go b/v3/pkg/application/systemtray_windows.go index a692ea42014..695b20c29da 100644 --- a/v3/pkg/application/systemtray_windows.go +++ b/v3/pkg/application/systemtray_windows.go @@ -1,4 +1,4 @@ -//go:build windows +//go:build windows && !server package application diff --git a/v3/pkg/application/webview_window.go b/v3/pkg/application/webview_window.go index 224bab96f6d..bbeabae6aa0 100644 --- a/v3/pkg/application/webview_window.go +++ b/v3/pkg/application/webview_window.go @@ -1,6 +1,7 @@ package application import ( + "encoding/json" "fmt" "runtime" "slices" @@ -9,8 +10,6 @@ import ( "sync/atomic" "unsafe" - "encoding/json" - "github.com/wailsapp/wails/v3/internal/assetserver" "github.com/wailsapp/wails/v3/internal/optional" "github.com/wailsapp/wails/v3/pkg/events" @@ -116,9 +115,33 @@ type ( snapAssist() setContentProtection(enabled bool) attachModal(modalWindow *WebviewWindow) + setNonClientHitTestRegions([]nonClientHitTestRegion) + } + + nonClientHitTestKind string + + // nonClientHitTestRegion is a frontend-owned client-area rectangle in physical pixels. + nonClientHitTestRegion struct { + Kind nonClientHitTestKind `json:"kind,omitempty"` + Left int `json:"left"` + Top int `json:"top"` + Right int `json:"right"` + Bottom int `json:"bottom"` + } + + nonClientHitTestRegionsMessage struct { + Version int `json:"version,omitempty"` + Regions []nonClientHitTestRegion `json:"regions"` } ) +const ( + nonClientHitTestKindCaption nonClientHitTestKind = "caption" + nonClientHitTestKindMinimize nonClientHitTestKind = "minimize" + nonClientHitTestKindMaximize nonClientHitTestKind = "maximize" + nonClientHitTestKindClose nonClientHitTestKind = "close" +) + type WindowEvent struct { ctx *WindowEventContext cancelled atomic.Bool @@ -774,6 +797,9 @@ func (w *WebviewWindow) HandleMessage(message string) { w.Error("%w", err) } } + case strings.HasPrefix(message, "wails:non-client-region:"): + message = strings.Replace(message, "wails:non-client-region:", "", 1) + w.handleNonClientRegionMessage(message) case message == "wails:runtime:ready": w.emit(events.Common.WindowRuntimeReady) w.pendingJSMutex.Lock() @@ -815,6 +841,46 @@ func (w *WebviewWindow) HandleMessage(message string) { } } +func (w *WebviewWindow) handleNonClientRegionMessage(payload string) { + var message nonClientHitTestRegionsMessage + if err := json.Unmarshal([]byte(payload), &message); err != nil { + w.Error("failed to parse non-client regions: %w", err) + return + } + + regions := make([]nonClientHitTestRegion, 0, len(message.Regions)) + for i, region := range message.Regions { + normalised, err := normaliseNonClientHitTestRegion(region) + if err != nil { + w.Error("region %d: %w", i, err) + continue + } + regions = append(regions, normalised) + } + + InvokeSync(func() { + w.impl.setNonClientHitTestRegions(regions) + }) +} + +func normaliseNonClientHitTestRegion(region nonClientHitTestRegion) (nonClientHitTestRegion, error) { + if region.Right <= region.Left || region.Bottom <= region.Top { + return nonClientHitTestRegion{}, fmt.Errorf("invalid rectangle") + } + + kind := nonClientHitTestKind(strings.ToLower(string(region.Kind))) + switch kind { + case nonClientHitTestKindCaption, + nonClientHitTestKindMinimize, + nonClientHitTestKindMaximize, + nonClientHitTestKindClose: + region.Kind = kind + return region, nil + default: + return nonClientHitTestRegion{}, fmt.Errorf("unknown region kind %q", region.Kind) + } +} + func (w *WebviewWindow) startResize(border string) error { if w.impl == nil || w.isDestroyed() { return nil diff --git a/v3/pkg/application/webview_window_android.go b/v3/pkg/application/webview_window_android.go index b94dd87f8da..a7e77d917b0 100644 --- a/v3/pkg/application/webview_window_android.go +++ b/v3/pkg/application/webview_window_android.go @@ -341,6 +341,9 @@ func (w *androidWebviewWindow) setContentProtection(_ bool) { // Android content protection - could be implemented with FLAG_SECURE } +func (w *androidWebviewWindow) setNonClientHitTestRegions([]nonClientHitTestRegion) { +} + func (w *androidWebviewWindow) setHTML(_ string) { // Not supported: the WebView always loads from the asset server } diff --git a/v3/pkg/application/webview_window_darwin.go b/v3/pkg/application/webview_window_darwin.go index fd4278fd402..6f2995a162a 100644 --- a/v3/pkg/application/webview_window_darwin.go +++ b/v3/pkg/application/webview_window_darwin.go @@ -1759,6 +1759,9 @@ func (w *macosWebviewWindow) setContentProtection(enabled bool) { C.setContentProtection(w.nsWindow, C.bool(enabled)) } +func (w *macosWebviewWindow) setNonClientHitTestRegions([]nonClientHitTestRegion) { +} + func (w *macosWebviewWindow) attachModal(modalWindow *WebviewWindow) { if modalWindow == nil || modalWindow.impl == nil || modalWindow.isDestroyed() { return diff --git a/v3/pkg/application/webview_window_darwin_drag.m b/v3/pkg/application/webview_window_darwin_drag.m index 3dc2cf9ea1f..9adcf4632cb 100644 --- a/v3/pkg/application/webview_window_darwin_drag.m +++ b/v3/pkg/application/webview_window_darwin_drag.m @@ -22,6 +22,13 @@ - (instancetype)initWithFrame:(NSRect)frameRect { return self; } +// Pass mouse events through to the WKWebView underneath so CSS :hover, +// mousemove, and cursor updates work. Drag-and-drop delivery uses +// registerForDraggedTypes + geometry, not hitTest, so file drop is unaffected. +- (NSView *)hitTest:(NSPoint)point { + return nil; +} + // draggingEntered: - (NSDragOperation)draggingEntered:(id)sender { NSPasteboard *pasteboard = [sender draggingPasteboard]; diff --git a/v3/pkg/application/webview_window_ios.go b/v3/pkg/application/webview_window_ios.go index b77923d365c..5453b707f8d 100644 --- a/v3/pkg/application/webview_window_ios.go +++ b/v3/pkg/application/webview_window_ios.go @@ -390,6 +390,9 @@ func (w *iosWebviewWindow) setContentProtection(_ bool) { // iOS content protection - could be implemented with UIScreen captured notifications } +func (w *iosWebviewWindow) setNonClientHitTestRegions([]nonClientHitTestRegion) { +} + func (w *iosWebviewWindow) setHTML(html string) { if w.nativeHandle == nil || html == "" { return diff --git a/v3/pkg/application/webview_window_linux.go b/v3/pkg/application/webview_window_linux.go index 09903796b3d..e6288f43cac 100644 --- a/v3/pkg/application/webview_window_linux.go +++ b/v3/pkg/application/webview_window_linux.go @@ -466,3 +466,5 @@ func (w *linuxWebviewWindow) hideMenuBar() {} func (w *linuxWebviewWindow) toggleMenuBar() {} func (w *linuxWebviewWindow) snapAssist() {} // No-op on Linux func (w *linuxWebviewWindow) setContentProtection(enabled bool) {} +func (w *linuxWebviewWindow) setNonClientHitTestRegions([]nonClientHitTestRegion) { +} diff --git a/v3/pkg/application/webview_window_options.go b/v3/pkg/application/webview_window_options.go index 78f5b721519..0baa9a4bd9e 100644 --- a/v3/pkg/application/webview_window_options.go +++ b/v3/pkg/application/webview_window_options.go @@ -344,6 +344,21 @@ type WindowsWindow struct { // Default: false WindowMaskDraggable bool + // NonClientRegionSupport enables WebView2's native non-client region support + // for this window when the installed WebView2 Runtime supports it. This is + // primarily intended to make app-region: drag style custom titlebars work + // with native non-client hit testing. + // Default: false + NonClientRegionSupport bool + + // WebView2CompositionHosting creates WebView2 with visual hosting using + // ICoreWebView2CompositionController and DirectComposition instead of the + // HWND-hosted controller. This is intended for custom host-owned non-client + // hit-testing, for example manual caption-button regions rendered in web + // content and resolved through GetNonClientRegionAtPoint / SendMouseInput. + // Default: false + WebView2CompositionHosting bool + // WindowDidMoveDebounceMS is the amount of time to debounce the WindowDidMove event // when moving the window // Default: 0 diff --git a/v3/pkg/application/webview_window_windows.go b/v3/pkg/application/webview_window_windows.go index d5173253315..c3f1a78b642 100644 --- a/v3/pkg/application/webview_window_windows.go +++ b/v3/pkg/application/webview_window_windows.go @@ -1,4 +1,4 @@ -//go:build windows +//go:build windows && !server package application @@ -70,11 +70,8 @@ type windowsWebviewWindow struct { // Track whether content protection has been applied to the native window yet contentProtectionApplied bool - // resizeBorder* is the width/height of the resize border in pixels. - resizeBorderWidth int32 - resizeBorderHeight int32 - focusingChromium bool - onceDo sync.Once + focusingChromium bool + onceDo sync.Once // Window move debouncer moveDebouncer func(func()) @@ -89,6 +86,14 @@ type windowsWebviewWindow struct { // cannot be used for this because keyboard snap (Win+Left) bypasses those messages. lastSizeWParam uintptr + nonClientHitTest nonClientHitTestState + // Tracks the caption button currently pressed through forwarded non-client input. + // Once capture is active, Windows reports movement as normal client mouse input, + // so we need this state to keep WebView hover/pressed transitions native-like. + activeNonClientButton uintptr + activeNonClientButtonHovered bool + compositionCursor w32.HCURSOR + // lastKnownDPI is the window's DPI the last time it was in a non-minimised // state. It is used on the un-minimise path to decide whether the WebView2 // rasterization scale actually needs resyncing: when the DPI is unchanged @@ -362,6 +367,21 @@ func (w *windowsWebviewWindow) framelessWithDecorations() bool { return w.parent.options.Frameless && !w.parent.options.Windows.DisableFramelessWindowDecorations } +func (w *windowsWebviewWindow) extendFrameIntoClientArea(extend bool) error { + if !extend || !w.chromium.CompositionControllerEnabled { + return w32.ExtendFrameIntoClientArea(w.hwnd, extend) + } + + // Leave the top edge unextended for composition-hosted non-client regions so + // the Windows 11 Snap Layout flyout does not cover custom HTMAXBUTTON areas. + return w32.ExtendFrameIntoClientAreaWithMargins(w.hwnd, w32.MARGINS{ + CxLeftWidth: 1, + CxRightWidth: 1, + CyTopHeight: 0, + CyBottomHeight: 1, + }) +} + func (w *windowsWebviewWindow) run() { options := w.parent.options @@ -371,6 +391,9 @@ func (w *windowsWebviewWindow) run() { w.showRequested = !options.Hidden w.chromium = edge.NewChromium() + w.chromium.NonClientRegionSupportEnabled = options.Windows.NonClientRegionSupport + w.chromium.CompositionControllerEnabled = options.Windows.WebView2CompositionHosting + w.chromium.SetCursorChangedCallback(w.applyCompositionCursor) if globalApplication.options.ErrorHandler != nil { w.chromium.SetErrorCallback(globalApplication.options.ErrorHandler) } @@ -967,7 +990,7 @@ func (w *windowsWebviewWindow) fullscreen() { return } if w.framelessWithDecorations() { - err := w32.ExtendFrameIntoClientArea(w.hwnd, false) + err := w.extendFrameIntoClientArea(false) if err != nil { globalApplication.handleFatalError(err) } @@ -1017,7 +1040,7 @@ func (w *windowsWebviewWindow) unfullscreen() { return } if w.framelessWithDecorations() { - err := w32.ExtendFrameIntoClientArea(w.hwnd, true) + err := w.extendFrameIntoClientArea(true) if err != nil { globalApplication.handleFatalError(err) } @@ -1345,9 +1368,7 @@ func (w *windowsWebviewWindow) setFrameless(b bool) { func newWindowImpl(parent *WebviewWindow) *windowsWebviewWindow { result := &windowsWebviewWindow{ - parent: parent, - resizeBorderWidth: int32(w32.GetSystemMetrics(w32.SM_CXSIZEFRAME)), - resizeBorderHeight: int32(w32.GetSystemMetrics(w32.SM_CYSIZEFRAME)), + parent: parent, // Initialize visibility tracking fields showRequested: false, visibilityTimeout: nil, @@ -1569,6 +1590,16 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp return w32.HTCLIENT } + if w.parent.options.Windows.WebView2CompositionHosting && w.chromium != nil && w.chromium.CompositionControllerReady() { + if result, handled := w.routeNonClientInput(msg, wparam, lparam); handled { + return result + } + + if w.routeCompositionMouseInput(msg, wparam, lparam) { + return 0 + } + } + switch msg { case w32.WM_ACTIVATE: if int(wparam&0xffff) == w32.WA_INACTIVE { @@ -1587,7 +1618,7 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp // As a result we have hidden the titlebar but still have the default window frame styling. // See: https://docs.microsoft.com/en-us/windows/win32/api/dwmapi/nf-dwmapi-dwmextendframeintoclientarea#remarks if w.framelessWithDecorations() { - err := w32.ExtendFrameIntoClientArea(w.hwnd, true) + err := w.extendFrameIntoClientArea(true) if err != nil { globalApplication.handleFatalError(err) } @@ -1615,7 +1646,11 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp // Now do the actual close w.chromium.ShuttingDown() return w32.DefWindowProc(w.hwnd, w32.WM_CLOSE, 0, 0) - + case w32.WM_SETCURSOR: + if w.compositionCursor != 0 && w32.LOWORD(uint32(lparam)) == w32.HTCLIENT { + w32.SetCursor(w.compositionCursor) + return 1 + } case w32.WM_KILLFOCUS: if w.focusingChromium { return 0 @@ -1666,11 +1701,16 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp if w.parent.options.BackgroundType == BackgroundTypeSolid { col := w.parent.options.BackgroundColour hdc := w32.HDC(wparam) - rc := w32.GetClientRect(w.hwnd) - colorRef := w32.COLORREF(uint32(col.Red) | uint32(col.Green)<<8 | uint32(col.Blue)<<16) - hbrush := w32.CreateSolidBrush(colorRef) - w32.FillRect(hdc, rc, hbrush) - w32.DeleteObject(w32.HGDIOBJ(hbrush)) + // GetClientRect can legitimately return nil for a window in a + // transient state (minimise/restore transitions are especially + // prone to triggering it). FillRect with a nil rect crashes, so it + // must be checked before painting. + if rc := w32.GetClientRect(w.hwnd); rc != nil { + colorRef := w32.COLORREF(uint32(col.Red) | uint32(col.Green)<<8 | uint32(col.Blue)<<16) + hbrush := w32.CreateSolidBrush(colorRef) + w32.FillRect(hdc, rc, hbrush) + w32.DeleteObject(w32.HGDIOBJ(hbrush)) + } } return 1 // WM_UAHDRAWMENUITEM is handled by MenuBarWndProc at the top of this function @@ -1873,7 +1913,7 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp // For frameless windows with decorations, re-extend the frame into client area // to ensure proper window frame styling after DPI change. if w.framelessWithDecorations() { - if err := w32.ExtendFrameIntoClientArea(w.hwnd, true); err != nil { + if err := w.extendFrameIntoClientArea(true); err != nil { globalApplication.handleFatalError(err) } } @@ -1887,11 +1927,11 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp // DPI changes manually — but only while non-minimised. When detection // was re-enabled in setupChromium, the resync below is a no-op (Edge // owns the scale) and only lastKnownDPI tracking runs. - // While minimised the window sits off its restore - // monitor, so GetDpiForWindow can report a different monitor's DPI, which - // would push a wrong scale - // onto the controller (one the restore-time DPI gate then won't correct, - // since DPI == lastKnownDPI) and would make a COM call into a possibly + // While minimised the window sits off its restore monitor, so + // GetDpiForWindow can report a different monitor's DPI, which would + // push a wrong scale onto the controller (one the restore-time DPI gate + // then won't correct, since DPI == lastKnownDPI) and would make a COM + // call into a possibly // suspended controller (#5605). A genuine DPI difference is instead // caught on restore by resyncWebviewDPIAfterUnminimiseIfDPIChanged. if !w.isMinimizing { @@ -1963,7 +2003,7 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp // As a result we have hidden the titlebar but still have the default window frame styling. // See: https://docs.microsoft.com/en-us/windows/win32/api/dwmapi/nf-dwmapi-dwmextendframeintoclientarea#remarks if w.framelessWithDecorations() { - err := w32.ExtendFrameIntoClientArea(w.hwnd, true) + err := w.extendFrameIntoClientArea(true) if err != nil { globalApplication.handleFatalError(err) } @@ -2040,10 +2080,9 @@ func (w *windowsWebviewWindow) WndProc(msg uint32, wparam, lparam uintptr) uintp // resyncWebviewRasterizationScale re-asserts the window's actual DPI on the // WebView2 controller and reports whether the scale was out of sync. Wails -// runs WebView2 in raw-pixels bounds mode with ShouldDetectMonitorScaleChanges -// disabled, so keeping the rasterization scale in step with the window's DPI -// is the application's responsibility. It is a no-op when the controller is -// unavailable or already in sync. +// keeps this as a fallback for controllers where monitor-scale detection could +// not be re-enabled; when WebView2 owns monitor scale detection, the host-side +// resync stands down. func (w *windowsWebviewWindow) resyncWebviewRasterizationScale() bool { // With monitor-scale detection re-enabled (setupChromium), WebView2 owns // the rasterization scale and updates it on monitor crossings itself. A @@ -2373,33 +2412,65 @@ func (w *windowsWebviewWindow) setupChromium() { chromium.MessageWithAdditionalObjectsCallback = w.processMessageWithAdditionalObjects chromium.WebResourceRequestedCallback = w.processRequest chromium.ContainsFullScreenElementChangedCallback = w.fullscreenChanged + chromium.NavigationStartingCallback = w.navigationStarting chromium.NavigationCompletedCallback = w.navigationCompleted chromium.AcceleratorKeyCallback = w.processKeyBinding chromium.Embed(w.hwnd) - // Ensure automatic monitor-scale detection is on. Published webview2 - // module versions up to v1.0.27 disable ShouldDetectMonitorScaleChanges - // at controller creation (the in-repo module no longer does), leaving - // rasterization-scale updates entirely to the host's WM_DPICHANGED - // handling. In that - // host-managed mode, dragging the window across a mixed-DPI monitor - // boundary can make the embedded browser compute a degenerate - // scale(0,0) transform (ui/gfx/geometry/transform.cc NOTREACHED - // "is not invertible"); the resulting compositor frame is rejected by - // the viz process as a malformed Mojo message, which kills the GPU - // process, and after enough repeat kills the browser process gives up - // ("GPU process isn't usable. Goodbye.") taking the controller with - // it. Detection-on is the WebView2 default and keeps monitor-cross - // scale updates inside Edge, where that path is actually exercised; - // bounds stay raw-pixels. While detection is on, the host-side - // WM_DPICHANGED / un-minimise scale resyncs stand down (see + // Configure who owns the WebView2 rasterization scale on a monitor-DPI + // change. Two hosting modes need opposite answers: + // + // Windowed (HWND-child) hosting — the default: enable automatic + // monitor-scale detection. Published webview2 module versions up to + // v1.0.27 disabled ShouldDetectMonitorScaleChanges at controller creation + // (the in-repo module no longer does), leaving rasterization-scale updates + // entirely to the host's WM_DPICHANGED handling. In that host-managed mode, + // dragging the window across a mixed-DPI monitor boundary can make the + // embedded browser compute a degenerate scale(0,0) transform + // (ui/gfx/geometry/transform.cc NOTREACHED "is not invertible"); the + // resulting compositor frame is rejected by the viz process as a malformed + // Mojo message, which kills the GPU process, and after enough repeat kills + // the browser process gives up ("GPU process isn't usable. Goodbye.") + // taking the controller with it. Detection-on is the WebView2 default and + // keeps monitor-cross scale updates inside Edge, where that path is + // actually exercised; bounds stay raw-pixels. While detection is on, the + // host-side WM_DPICHANGED / un-minimise scale resyncs stand down (see // monitorScaleDetectionOn) so the scale has exactly one writer. + // + // Visual hosting (UseVisualHosting -> COREWEBVIEW2_HOSTING_MODE_WINDOW_TO_VISUAL): + // the content is a DirectComposition visual, decoupled from the child HWND + // that automatic detection tracks. Across a mixed-DPI boundary detection + // then reads the wrong monitor and settles the visual on a stale scale, so + // the whole UI renders shrunk. There the host must own the scale via + // resyncWebviewRasterizationScale (correct per WebView2Feedback #3665, and + // reliable now that the by-value PutRasterizationScale bug is fixed). The + // module leaves detection at its platform default (enabled), so visual + // hosting must disable it *explicitly* — merely skipping the enable would + // leave detection on AND the host resync running, i.e. two writers racing, + // which is the scale(0,0) crash above. With detection off the host owns the + // scale via resyncWebviewRasterizationScale. + // + // Whichever mode: monitorScaleDetectionOn is set from the controller's + // *actual* ShouldDetectMonitorScaleChanges after the Put, never from the + // value we asked for. A failed Put can leave detection at its platform + // default (enabled) while we intended off; keying the flag off intent would + // then run the host resync against a detecting Edge — the exact two-writer + // race this guards against. The host stands down whenever detection is on so + // the rasterization scale keeps exactly one writer. if controller := chromium.GetController(); controller != nil { if c3 := controller.GetICoreWebView2Controller3(); c3 != nil { - if err := c3.PutShouldDetectMonitorScaleChanges(true); err != nil { - globalApplication.error("webview2: enable monitor scale detection: %v", err) + wantDetection := !globalApplication.options.Windows.UseVisualHosting + if err := c3.PutShouldDetectMonitorScaleChanges(wantDetection); err != nil { + globalApplication.error("webview2: set monitor scale detection to %v: %v", wantDetection, err) + } + if on, err := c3.GetShouldDetectMonitorScaleChanges(); err == nil { + w.monitorScaleDetectionOn = on } else { + // Can't confirm the state: assume detection may be on and stand + // the host resync down. A cosmetic stale scale beats risking the + // two-writer GPU-process crash. + globalApplication.error("webview2: query monitor scale detection: %v", err) w.monitorScaleDetectionOn = true } } @@ -2561,17 +2632,24 @@ func (w *windowsWebviewWindow) flash(enabled bool) { w32.FlashWindow(w.hwnd, enabled) } +func (w *windowsWebviewWindow) navigationStarting(_ *edge.ICoreWebView2) { + w.setNonClientHitTestRegions(nil) +} + func (w *windowsWebviewWindow) navigationCompleted( sender *edge.ICoreWebView2, args *edge.ICoreWebView2NavigationCompletedEventArgs, ) { - // Install the runtime core - w.execJS(runtime.Core(globalApplication.impl.GetFlags(globalApplication.options))) - - // Set the EnableFileDrop flag for this window (Windows-specific) - // The JS runtime checks this before processing file drops - w.execJS(fmt.Sprintf("window._wails.flags.enableFileDrop = %v;", w.parent.options.EnableFileDrop)) + // Inject runtime core and window-specific flags together so side-effect + // runtime modules see a consistent _wails configuration at startup. + js := runtime.Core(globalApplication.impl.GetFlags(globalApplication.options)) + js += fmt.Sprintf( + "window._wails.flags.enableFileDrop = %v; window._wails.flags.nonClientRegionTracking = %v;", + w.parent.options.EnableFileDrop, + w.parent.options.Windows.WebView2CompositionHosting, + ) + w.execJS(js) // EmitEvent DomReady ApplicationEvent windowEvents <- &windowEvent{EventID: uint(events.Windows.WebViewNavigationCompleted), WindowID: w.parent.id} @@ -2808,15 +2886,6 @@ func (w *windowsWebviewWindow) disableRedrawWithCallback(callback func()) { } -func NewIconFromResource(instance w32.HINSTANCE, resId uint16) (w32.HICON, error) { - var err error - var result w32.HICON - if result = w32.LoadIconWithResourceID(instance, resId); result == 0 { - err = fmt.Errorf("cannot load icon from resource with id %v", resId) - } - return result, err -} - func (w *windowsWebviewWindow) setMinimiseButtonState(state ButtonState) { switch state { case ButtonDisabled, ButtonHidden: diff --git a/v3/pkg/application/webview_window_windows_devtools.go b/v3/pkg/application/webview_window_windows_devtools.go index 096bda5b556..ba8dba23d8f 100644 --- a/v3/pkg/application/webview_window_windows_devtools.go +++ b/v3/pkg/application/webview_window_windows_devtools.go @@ -1,4 +1,4 @@ -//go:build windows && (!production || devtools) +//go:build windows && !server && (!production || devtools) package application diff --git a/v3/pkg/application/webview_window_windows_nonclient.go b/v3/pkg/application/webview_window_windows_nonclient.go new file mode 100644 index 00000000000..d434e41d10d --- /dev/null +++ b/v3/pkg/application/webview_window_windows_nonclient.go @@ -0,0 +1,535 @@ +//go:build windows + +package application + +import ( + "slices" + "sync" + "unsafe" + + "github.com/wailsapp/wails/v3/pkg/w32" + "github.com/wailsapp/wails/v3/internal/webview2/pkg/edge" +) + +type nonClientHitTestState struct { + mu sync.RWMutex + regions []nonClientHitTestRegion +} + +func (s *nonClientHitTestState) set(regions []nonClientHitTestRegion) { + s.mu.Lock() + if len(regions) == 0 { + s.regions = nil + } else { + s.regions = slices.Clone(regions) + } + s.mu.Unlock() +} + +func (s *nonClientHitTestState) snapshot() []nonClientHitTestRegion { + s.mu.RLock() + defer s.mu.RUnlock() + if len(s.regions) == 0 { + return nil + } + return append([]nonClientHitTestRegion(nil), s.regions...) +} + +func (w *windowsWebviewWindow) setNonClientHitTestRegions(regions []nonClientHitTestRegion) { + w.nonClientHitTest.set(regions) +} + +func (w *windowsWebviewWindow) applyCompositionCursor(cursor edge.HCURSOR, systemCursorID uint32) { + hcursor := w32.HCURSOR(cursor) + if hcursor == 0 && systemCursorID != 0 { + hcursor = w32.LoadCursorWithResourceID(0, uint16(systemCursorID)) + } + if hcursor == 0 { + return + } + + w.compositionCursor = hcursor + w32.SetCursor(hcursor) +} + +func (w *windowsWebviewWindow) routeNonClientInput(msg uint32, wparam, lparam uintptr) (uintptr, bool) { + switch msg { + case w32.WM_NCHITTEST: + if hitTest, handled := w32.DwmDefWindowProc(w.hwnd, msg, wparam, lparam); handled { + if hitTest != w32.HTCLIENT && hitTest != w32.HTNOWHERE { + return hitTest, true + } + } + + screenX := int(w32.GET_X_LPARAM(lparam)) + screenY := int(w32.GET_Y_LPARAM(lparam)) + + if hitTest, ok := w.resizeBorderHitTest(screenX, screenY); ok { + return hitTest, true + } + + return w.nonClientHitTestFromScreen(screenX, screenY) + case w32.WM_NCMOUSEMOVE: + screenX := int(w32.GET_X_LPARAM(lparam)) + screenY := int(w32.GET_Y_LPARAM(lparam)) + + hitTest, ok := w.nonClientHitTestFromScreen(screenX, screenY) + if !ok || hitTest != wparam { + return 0, false + } + + w.trackCompositionMouseLeave(true) + + clientX, clientY, ok := w32.ScreenToClient( + w.hwnd, + int(w32.GET_X_LPARAM(lparam)), + int(w32.GET_Y_LPARAM(lparam)), + ) + if !ok { + return 0, false + } + + _ = w.chromium.SendMouseInput( + edge.COREWEBVIEW2_MOUSE_EVENT_KIND_MOVE, + edge.COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_NONE, + 0, + clientX, + clientY, + ) + + return w32.DwmDefWindowProc(w.hwnd, msg, wparam, lparam) + case w32.WM_NCMOUSELEAVE: + // Windows can emit a spurious NCMOUSELEAVE right after a forwarded + // non-client button press. Suppress it until the captured mouse move + // path below can decide whether the pointer really left the active button. + if w32.GetCapture() == w.hwnd && w.activeNonClientButton != 0 { + return 0, true + } + + _ = w.chromium.SendMouseInput( + edge.COREWEBVIEW2_MOUSE_EVENT_KIND_LEAVE, + edge.COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_NONE, + 0, + 0, + 0, + ) + case w32.WM_NCLBUTTONDOWN, w32.WM_NCLBUTTONUP, w32.WM_NCLBUTTONDBLCLK: + switch wparam { + case w32.HTMINBUTTON, w32.HTMAXBUTTON, w32.HTCLOSE: + default: + return 0, false + } + + if w.forwardFrontendNonClientButtonInput(msg, wparam, lparam) { + return 0, true + } + case w32.WM_NCRBUTTONUP: + if wparam != w32.HTCAPTION && wparam != w32.HTSYSMENU { + return 0, false + } + + screenX := int(w32.GET_X_LPARAM(lparam)) + screenY := int(w32.GET_Y_LPARAM(lparam)) + + if hitTest, ok := w.nonClientHitTestFromScreen(screenX, screenY); !ok || hitTest != w32.HTCAPTION { + return 0, false + } + + if w.showCaptionSystemMenu(screenX, screenY) { + return 0, true + } + } + + return 0, false +} + +func (w *windowsWebviewWindow) nonClientHitTestFromScreen(screenX, screenY int) (uintptr, bool) { + regions := w.nonClientHitTest.snapshot() + // Later frontend regions should win when rectangles overlap, matching the + // DOM/CSS order used to collect them (for example caption buttons over a + // caption drag area). + for i := len(regions) - 1; i >= 0; i-- { + r := regions[i] + + left, top := w32.ClientToScreen(w.hwnd, r.Left, r.Top) + right, bottom := w32.ClientToScreen(w.hwnd, r.Right, r.Bottom) + + // outside app + if screenX < left || screenX >= right || screenY < top || screenY >= bottom { + continue + } + + switch r.Kind { + case nonClientHitTestKindMaximize: + return w32.HTMAXBUTTON, true + case nonClientHitTestKindCaption: + return w32.HTCAPTION, true + case nonClientHitTestKindMinimize: + return w32.HTMINBUTTON, true + case nonClientHitTestKindClose: + return w32.HTCLOSE, true + } + } + + // fallback to default non-client region hit test (app-region) + if !w.chromium.NonClientRegionSupportEnabled { + return 0, false + } + + clientX, clientY, ok := w32.ScreenToClient(w.hwnd, screenX, screenY) + if !ok { + return 0, false + } + + region, handled, err := w.chromium.GetNonClientRegionAtPoint(int32(clientX), int32(clientY)) + if err != nil || !handled { + return 0, false + } + + switch region { + case edge.COREWEBVIEW2_NON_CLIENT_REGION_KIND_CAPTION: + return w32.HTCAPTION, true + case edge.COREWEBVIEW2_NON_CLIENT_REGION_KIND_MINIMIZE: + return w32.HTMINBUTTON, true + case edge.COREWEBVIEW2_NON_CLIENT_REGION_KIND_MAXIMIZE: + return w32.HTMAXBUTTON, true + case edge.COREWEBVIEW2_NON_CLIENT_REGION_KIND_CLOSE: + return w32.HTCLOSE, true + case edge.COREWEBVIEW2_NON_CLIENT_REGION_KIND_CLIENT, + edge.COREWEBVIEW2_NON_CLIENT_REGION_KIND_NOWHERE: + return 0, false + default: + return 0, false + } +} + +func (w *windowsWebviewWindow) resizeBorderHitTest(screenX, screenY int) (uintptr, bool) { + if w.parent.options.DisableResize || w.isMaximised() || w.isFullscreen() { + return 0, false + } + + rect := w32.GetWindowRect(w.hwnd) + width := int(rect.Right - rect.Left) + height := int(rect.Bottom - rect.Top) + if width <= 0 || height <= 0 { + return 0, false + } + + x := screenX - int(rect.Left) + y := screenY - int(rect.Top) + if x < 0 || y < 0 || x >= width || y >= height { + return 0, false + } + + dpi, _ := w.DPI() + borderX := systemMetricForDPI(w32.SM_CXSIZEFRAME, dpi) + systemMetricForDPI(w32.SM_CXPADDEDBORDER, dpi) + if borderX < 1 { + borderX = 1 + } + borderY := systemMetricForDPI(w32.SM_CYSIZEFRAME, dpi) + systemMetricForDPI(w32.SM_CXPADDEDBORDER, dpi) + if borderY < 1 { + borderY = 1 + } + + left := x < borderX + right := x >= width-borderX + top := y < borderY + bottom := y >= height-borderY + + switch { + case top && left: + return w32.HTTOPLEFT, true + case top && right: + return w32.HTTOPRIGHT, true + case bottom && left: + return w32.HTBOTTOMLEFT, true + case bottom && right: + return w32.HTBOTTOMRIGHT, true + case top: + return w32.HTTOP, true + case bottom: + return w32.HTBOTTOM, true + case left: + return w32.HTLEFT, true + case right: + return w32.HTRIGHT, true + default: + return 0, false + } +} + +func systemMetricForDPI(index int, dpi w32.UINT) int { + if dpi != 0 && w32.HasGetSystemMetricsForDpiFunc() { + return w32.GetSystemMetricsForDpi(index, dpi) + } + return w32.GetSystemMetrics(index) +} + +func (w *windowsWebviewWindow) forwardFrontendNonClientButtonInput(msg uint32, wparam, lparam uintptr) bool { + screenX := int(w32.GET_X_LPARAM(lparam)) + screenY := int(w32.GET_Y_LPARAM(lparam)) + + hitTest, ok := w.nonClientHitTestFromScreen(screenX, screenY) + if !ok || hitTest != wparam { + return false + } + + clientX, clientY, ok := w32.ScreenToClient(w.hwnd, screenX, screenY) + if !ok { + return false + } + + eventKind, virtualKeys, ok := nonClientLeftButtonMouseEvent(msg) + if !ok { + return false + } + + if err := w.chromium.SendMouseInput( + eventKind, + virtualKeys, + 0, + clientX, + clientY, + ); err != nil { + return false + } + + // Remember which caption button started the press. During capture, Windows + // sends movement as WM_MOUSEMOVE, so later moves must be compared against + // this original hit-test rather than any caption button under the cursor. + if msg == w32.WM_NCLBUTTONDOWN || msg == w32.WM_NCLBUTTONDBLCLK { + w.activeNonClientButton = wparam + w.activeNonClientButtonHovered = true + } + + w.updateCompositionMouseCapture(msg) + + return true +} + +func (w *windowsWebviewWindow) showCaptionSystemMenu(screenX, screenY int) bool { + menu := w32.GetSystemMenu(w.hwnd, false) + if menu == 0 { + return false + } + + w32.SetForegroundWindow(w.hwnd) + command := w32.TrackPopupMenuCommand( + menu, + w32.TPM_LEFTALIGN|w32.TPM_TOPALIGN|w32.TPM_RIGHTBUTTON, + int32(screenX), + int32(screenY), + w.hwnd, + nil, + ) + w32.PostMessage(w.hwnd, w32.WM_NULL, 0, 0) + if command == 0 { + return true + } + + w32.SendMessage(w.hwnd, w32.WM_SYSCOMMAND, command, 0) + return true +} + +func (w *windowsWebviewWindow) routeCompositionMouseInput(msg uint32, wparam, lparam uintptr) bool { + eventKind, ok := webviewCompositionMouseEventKind(msg) + if !ok { + return false + } + + if msg == w32.WM_MOUSEMOVE { + w.trackCompositionMouseLeave(false) + } + + clientX, clientY, ok := w.compositionMouseClientPoint(msg, lparam) + if !ok { + return false + } + + var mouseData uint32 + switch msg { + case w32.WM_MOUSEWHEEL, w32.WM_MOUSEHWHEEL: + mouseData = uint32(int16(wparam >> 16)) + case w32.WM_XBUTTONDOWN, w32.WM_XBUTTONUP, w32.WM_XBUTTONDBLCLK: + mouseData = uint32(wparam >> 16) + } + + // While a forwarded caption button owns capture, WebView still receives + // normal mouse moves. Only forward those moves while the cursor remains over + // the same button; otherwise synthesize leave so pressed styling is cleared. + if msg == w32.WM_MOUSEMOVE && w.activeNonClientButton != 0 && w32.GetCapture() == w.hwnd { + if !w.updateActiveNonClientButtonHover() { + return true + } + } + + if err := w.chromium.SendMouseInput( + eventKind, + edge.COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS(uint32(wparam)&0xffff), + mouseData, + clientX, + clientY, + ); err != nil { + return false + } + + w.updateCompositionMouseCapture(msg) + + return true +} + +func (w *windowsWebviewWindow) trackCompositionMouseLeave(nonClient bool) { + flags := uint32(w32.TME_LEAVE) + if nonClient { + flags |= w32.TME_NONCLIENT + } + + w32.TrackMouseEvent(&w32.TRACKMOUSEEVENT{ + CbSize: uint32(unsafe.Sizeof(w32.TRACKMOUSEEVENT{})), + DwFlags: flags, + HwndTrack: w.hwnd, + }) +} + +func (w *windowsWebviewWindow) compositionMouseClientPoint(msg uint32, lparam uintptr) (int, int, bool) { + switch msg { + case w32.WM_MOUSELEAVE: + return 0, 0, true + case w32.WM_MOUSEWHEEL, w32.WM_MOUSEHWHEEL: + return w32.ScreenToClient(w.hwnd, int(w32.GET_X_LPARAM(lparam)), int(w32.GET_Y_LPARAM(lparam))) + default: + return int(w32.GET_X_LPARAM(lparam)), int(w32.GET_Y_LPARAM(lparam)), true + } +} + +func (w *windowsWebviewWindow) updateCompositionMouseCapture(msg uint32) { + if isCompositionMouseButtonDown(msg) { + if w32.GetCapture() != w.hwnd { + w32.SetCapture(w.hwnd) + } + return + } + + if isCompositionMouseButtonUp(msg) && w32.GetCapture() == w.hwnd { + w32.ReleaseCapture() + + // Button release ends the synthetic caption-button interaction. + w.activeNonClientButton = 0 + w.activeNonClientButtonHovered = false + } +} + +// updateActiveNonClientButtonHover returns whether the current move should be +// forwarded to WebView. It sends a single LEAVE when capture moves off the +// originally pressed caption button, matching native caption-button behavior. +func (w *windowsWebviewWindow) updateActiveNonClientButtonHover() bool { + screenX, screenY, ok := w32.GetCursorPos() + if !ok { + return true + } + + hitTest, ok := w.nonClientHitTestFromScreen(screenX, screenY) + hovered := ok && hitTest == w.activeNonClientButton + if hovered { + w.activeNonClientButtonHovered = true + return true + } + + if w.activeNonClientButtonHovered { + _ = w.chromium.SendMouseInput( + edge.COREWEBVIEW2_MOUSE_EVENT_KIND_LEAVE, + edge.COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_NONE, + 0, + 0, + 0, + ) + w.activeNonClientButtonHovered = false + } + + return false +} + +func nonClientLeftButtonMouseEvent(msg uint32) (edge.COREWEBVIEW2_MOUSE_EVENT_KIND, edge.COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS, bool) { + switch msg { + case w32.WM_NCLBUTTONDOWN: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_DOWN, + edge.COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_LEFT_BUTTON, + true + case w32.WM_NCLBUTTONUP: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_UP, + edge.COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_NONE, + true + case w32.WM_NCLBUTTONDBLCLK: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_DOUBLE_CLICK, + edge.COREWEBVIEW2_MOUSE_EVENT_VIRTUAL_KEYS_LEFT_BUTTON, + true + default: + return 0, 0, false + } +} + +func isCompositionMouseButtonDown(msg uint32) bool { + switch msg { + case w32.WM_LBUTTONDOWN, + w32.WM_NCLBUTTONDOWN, + w32.WM_NCLBUTTONDBLCLK, + w32.WM_RBUTTONDOWN, + w32.WM_MBUTTONDOWN, + w32.WM_XBUTTONDOWN: + return true + default: + return false + } +} + +func isCompositionMouseButtonUp(msg uint32) bool { + switch msg { + case w32.WM_LBUTTONUP, + w32.WM_NCLBUTTONUP, + w32.WM_RBUTTONUP, + w32.WM_MBUTTONUP, + w32.WM_XBUTTONUP: + return true + default: + return false + } +} + +func webviewCompositionMouseEventKind(msg uint32) (edge.COREWEBVIEW2_MOUSE_EVENT_KIND, bool) { + switch msg { + case w32.WM_MOUSELEAVE: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_LEAVE, true + case w32.WM_MOUSEMOVE: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_MOVE, true + case w32.WM_LBUTTONDOWN: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_DOWN, true + case w32.WM_LBUTTONUP: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_UP, true + case w32.WM_LBUTTONDBLCLK: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_LEFT_BUTTON_DOUBLE_CLICK, true + case w32.WM_RBUTTONDOWN: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_RIGHT_BUTTON_DOWN, true + case w32.WM_RBUTTONUP: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_RIGHT_BUTTON_UP, true + case w32.WM_RBUTTONDBLCLK: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_RIGHT_BUTTON_DOUBLE_CLICK, true + case w32.WM_MBUTTONDOWN: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_MIDDLE_BUTTON_DOWN, true + case w32.WM_MBUTTONUP: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_MIDDLE_BUTTON_UP, true + case w32.WM_MBUTTONDBLCLK: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_MIDDLE_BUTTON_DOUBLE_CLICK, true + case w32.WM_XBUTTONDOWN: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_X_BUTTON_DOWN, true + case w32.WM_XBUTTONUP: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_X_BUTTON_UP, true + case w32.WM_XBUTTONDBLCLK: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_X_BUTTON_DOUBLE_CLICK, true + case w32.WM_MOUSEWHEEL: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_WHEEL, true + case w32.WM_MOUSEHWHEEL: + return edge.COREWEBVIEW2_MOUSE_EVENT_KIND_HORIZONTAL_WHEEL, true + default: + return 0, false + } +} diff --git a/v3/pkg/application/webview_window_windows_production.go b/v3/pkg/application/webview_window_windows_production.go index 4ca89c1ea5d..289a339ded3 100644 --- a/v3/pkg/application/webview_window_windows_production.go +++ b/v3/pkg/application/webview_window_windows_production.go @@ -1,4 +1,4 @@ -//go:build windows && production && !devtools +//go:build windows && !server && production && !devtools package application diff --git a/v3/pkg/events/events.go b/v3/pkg/events/events.go index f24a85fb5cb..d09ae67ecee 100644 --- a/v3/pkg/events/events.go +++ b/v3/pkg/events/events.go @@ -1,601 +1,601 @@ package events type ApplicationEventType uint -type WindowEventType uint +type WindowEventType uint var Common = newCommonEvents() type commonEvents struct { - ApplicationOpenedWithFile ApplicationEventType - ApplicationStarted ApplicationEventType + ApplicationOpenedWithFile ApplicationEventType + ApplicationStarted ApplicationEventType ApplicationLaunchedWithUrl ApplicationEventType - ThemeChanged ApplicationEventType - SystemDidWake ApplicationEventType - SystemWillSleep ApplicationEventType - WindowClosing WindowEventType - WindowDidMove WindowEventType - WindowDidResize WindowEventType - WindowDPIChanged WindowEventType - WindowFilesDropped WindowEventType - WindowFocus WindowEventType - WindowFullscreen WindowEventType - WindowHide WindowEventType - WindowLostFocus WindowEventType - WindowMaximise WindowEventType - WindowMinimise WindowEventType - WindowToggleFrameless WindowEventType - WindowRestore WindowEventType - WindowRuntimeReady WindowEventType - WindowShow WindowEventType - WindowUnFullscreen WindowEventType - WindowUnMaximise WindowEventType - WindowUnMinimise WindowEventType - WindowZoom WindowEventType - WindowZoomIn WindowEventType - WindowZoomOut WindowEventType - WindowZoomReset WindowEventType - BatteryChanged ApplicationEventType - NetworkChanged ApplicationEventType - ScreenLocked ApplicationEventType - ScreenUnlocked ApplicationEventType - LowMemory ApplicationEventType + ThemeChanged ApplicationEventType + SystemDidWake ApplicationEventType + SystemWillSleep ApplicationEventType + WindowClosing WindowEventType + WindowDidMove WindowEventType + WindowDidResize WindowEventType + WindowDPIChanged WindowEventType + WindowFilesDropped WindowEventType + WindowFocus WindowEventType + WindowFullscreen WindowEventType + WindowHide WindowEventType + WindowLostFocus WindowEventType + WindowMaximise WindowEventType + WindowMinimise WindowEventType + WindowToggleFrameless WindowEventType + WindowRestore WindowEventType + WindowRuntimeReady WindowEventType + WindowShow WindowEventType + WindowUnFullscreen WindowEventType + WindowUnMaximise WindowEventType + WindowUnMinimise WindowEventType + WindowZoom WindowEventType + WindowZoomIn WindowEventType + WindowZoomOut WindowEventType + WindowZoomReset WindowEventType + BatteryChanged ApplicationEventType + NetworkChanged ApplicationEventType + ScreenLocked ApplicationEventType + ScreenUnlocked ApplicationEventType + LowMemory ApplicationEventType } func newCommonEvents() commonEvents { return commonEvents{ - ApplicationOpenedWithFile: 1024, - ApplicationStarted: 1025, + ApplicationOpenedWithFile: 1024, + ApplicationStarted: 1025, ApplicationLaunchedWithUrl: 1026, - ThemeChanged: 1027, - SystemDidWake: 1028, - SystemWillSleep: 1029, - WindowClosing: 1030, - WindowDidMove: 1031, - WindowDidResize: 1032, - WindowDPIChanged: 1033, - WindowFilesDropped: 1034, - WindowFocus: 1035, - WindowFullscreen: 1036, - WindowHide: 1037, - WindowLostFocus: 1038, - WindowMaximise: 1039, - WindowMinimise: 1040, - WindowToggleFrameless: 1041, - WindowRestore: 1042, - WindowRuntimeReady: 1043, - WindowShow: 1044, - WindowUnFullscreen: 1045, - WindowUnMaximise: 1046, - WindowUnMinimise: 1047, - WindowZoom: 1048, - WindowZoomIn: 1049, - WindowZoomOut: 1050, - WindowZoomReset: 1051, - BatteryChanged: 1287, - NetworkChanged: 1288, - ScreenLocked: 1289, - ScreenUnlocked: 1290, - LowMemory: 1291, + ThemeChanged: 1027, + SystemDidWake: 1028, + SystemWillSleep: 1029, + WindowClosing: 1030, + WindowDidMove: 1031, + WindowDidResize: 1032, + WindowDPIChanged: 1033, + WindowFilesDropped: 1034, + WindowFocus: 1035, + WindowFullscreen: 1036, + WindowHide: 1037, + WindowLostFocus: 1038, + WindowMaximise: 1039, + WindowMinimise: 1040, + WindowToggleFrameless: 1041, + WindowRestore: 1042, + WindowRuntimeReady: 1043, + WindowShow: 1044, + WindowUnFullscreen: 1045, + WindowUnMaximise: 1046, + WindowUnMinimise: 1047, + WindowZoom: 1048, + WindowZoomIn: 1049, + WindowZoomOut: 1050, + WindowZoomReset: 1051, + BatteryChanged: 1287, + NetworkChanged: 1288, + ScreenLocked: 1289, + ScreenUnlocked: 1290, + LowMemory: 1291, } } var Linux = newLinuxEvents() type linuxEvents struct { - ApplicationStartup ApplicationEventType - SystemDidWake ApplicationEventType - SystemThemeChanged ApplicationEventType - SystemWillSleep ApplicationEventType - WindowDeleteEvent WindowEventType - WindowDidMove WindowEventType - WindowDidResize WindowEventType - WindowFocusIn WindowEventType - WindowFocusOut WindowEventType - WindowLoadStarted WindowEventType + ApplicationStartup ApplicationEventType + SystemDidWake ApplicationEventType + SystemThemeChanged ApplicationEventType + SystemWillSleep ApplicationEventType + WindowDeleteEvent WindowEventType + WindowDidMove WindowEventType + WindowDidResize WindowEventType + WindowFocusIn WindowEventType + WindowFocusOut WindowEventType + WindowLoadStarted WindowEventType WindowLoadRedirected WindowEventType - WindowLoadCommitted WindowEventType - WindowLoadFinished WindowEventType + WindowLoadCommitted WindowEventType + WindowLoadFinished WindowEventType } func newLinuxEvents() linuxEvents { return linuxEvents{ - ApplicationStartup: 1052, - SystemDidWake: 1053, - SystemThemeChanged: 1054, - SystemWillSleep: 1055, - WindowDeleteEvent: 1056, - WindowDidMove: 1057, - WindowDidResize: 1058, - WindowFocusIn: 1059, - WindowFocusOut: 1060, - WindowLoadStarted: 1061, + ApplicationStartup: 1052, + SystemDidWake: 1053, + SystemThemeChanged: 1054, + SystemWillSleep: 1055, + WindowDeleteEvent: 1056, + WindowDidMove: 1057, + WindowDidResize: 1058, + WindowFocusIn: 1059, + WindowFocusOut: 1060, + WindowLoadStarted: 1061, WindowLoadRedirected: 1062, - WindowLoadCommitted: 1063, - WindowLoadFinished: 1064, + WindowLoadCommitted: 1063, + WindowLoadFinished: 1064, } } var Mac = newMacEvents() type macEvents struct { - ApplicationDidBecomeActive ApplicationEventType - ApplicationDidChangeBackingProperties ApplicationEventType - ApplicationDidChangeEffectiveAppearance ApplicationEventType - ApplicationDidChangeIcon ApplicationEventType - ApplicationDidChangeOcclusionState ApplicationEventType - ApplicationDidChangeScreenParameters ApplicationEventType - ApplicationDidChangeStatusBarFrame ApplicationEventType - ApplicationDidChangeStatusBarOrientation ApplicationEventType - ApplicationDidChangeTheme ApplicationEventType - ApplicationDidFinishLaunching ApplicationEventType - ApplicationDidHide ApplicationEventType - ApplicationDidResignActive ApplicationEventType - ApplicationDidUnhide ApplicationEventType - ApplicationDidUpdate ApplicationEventType - ApplicationDidWake ApplicationEventType - ApplicationScreensDidSleep ApplicationEventType - ApplicationScreensDidWake ApplicationEventType - ApplicationShouldHandleReopen ApplicationEventType - ApplicationWillBecomeActive ApplicationEventType - ApplicationWillFinishLaunching ApplicationEventType - ApplicationWillHide ApplicationEventType - ApplicationWillResignActive ApplicationEventType - ApplicationWillSleep ApplicationEventType - ApplicationWillTerminate ApplicationEventType - ApplicationWillUnhide ApplicationEventType - ApplicationWillUpdate ApplicationEventType - MenuDidAddItem ApplicationEventType - MenuDidBeginTracking ApplicationEventType - MenuDidClose ApplicationEventType - MenuDidDisplayItem ApplicationEventType - MenuDidEndTracking ApplicationEventType - MenuDidHighlightItem ApplicationEventType - MenuDidOpen ApplicationEventType - MenuDidPopUp ApplicationEventType - MenuDidRemoveItem ApplicationEventType - MenuDidSendAction ApplicationEventType - MenuDidSendActionToItem ApplicationEventType - MenuDidUpdate ApplicationEventType - MenuWillAddItem ApplicationEventType - MenuWillBeginTracking ApplicationEventType - MenuWillDisplayItem ApplicationEventType - MenuWillEndTracking ApplicationEventType - MenuWillHighlightItem ApplicationEventType - MenuWillOpen ApplicationEventType - MenuWillPopUp ApplicationEventType - MenuWillRemoveItem ApplicationEventType - MenuWillSendAction ApplicationEventType - MenuWillSendActionToItem ApplicationEventType - MenuWillUpdate ApplicationEventType - WebViewDidCommitNavigation WindowEventType - WebViewDidFinishNavigation WindowEventType + ApplicationDidBecomeActive ApplicationEventType + ApplicationDidChangeBackingProperties ApplicationEventType + ApplicationDidChangeEffectiveAppearance ApplicationEventType + ApplicationDidChangeIcon ApplicationEventType + ApplicationDidChangeOcclusionState ApplicationEventType + ApplicationDidChangeScreenParameters ApplicationEventType + ApplicationDidChangeStatusBarFrame ApplicationEventType + ApplicationDidChangeStatusBarOrientation ApplicationEventType + ApplicationDidChangeTheme ApplicationEventType + ApplicationDidFinishLaunching ApplicationEventType + ApplicationDidHide ApplicationEventType + ApplicationDidResignActive ApplicationEventType + ApplicationDidUnhide ApplicationEventType + ApplicationDidUpdate ApplicationEventType + ApplicationDidWake ApplicationEventType + ApplicationScreensDidSleep ApplicationEventType + ApplicationScreensDidWake ApplicationEventType + ApplicationShouldHandleReopen ApplicationEventType + ApplicationWillBecomeActive ApplicationEventType + ApplicationWillFinishLaunching ApplicationEventType + ApplicationWillHide ApplicationEventType + ApplicationWillResignActive ApplicationEventType + ApplicationWillSleep ApplicationEventType + ApplicationWillTerminate ApplicationEventType + ApplicationWillUnhide ApplicationEventType + ApplicationWillUpdate ApplicationEventType + MenuDidAddItem ApplicationEventType + MenuDidBeginTracking ApplicationEventType + MenuDidClose ApplicationEventType + MenuDidDisplayItem ApplicationEventType + MenuDidEndTracking ApplicationEventType + MenuDidHighlightItem ApplicationEventType + MenuDidOpen ApplicationEventType + MenuDidPopUp ApplicationEventType + MenuDidRemoveItem ApplicationEventType + MenuDidSendAction ApplicationEventType + MenuDidSendActionToItem ApplicationEventType + MenuDidUpdate ApplicationEventType + MenuWillAddItem ApplicationEventType + MenuWillBeginTracking ApplicationEventType + MenuWillDisplayItem ApplicationEventType + MenuWillEndTracking ApplicationEventType + MenuWillHighlightItem ApplicationEventType + MenuWillOpen ApplicationEventType + MenuWillPopUp ApplicationEventType + MenuWillRemoveItem ApplicationEventType + MenuWillSendAction ApplicationEventType + MenuWillSendActionToItem ApplicationEventType + MenuWillUpdate ApplicationEventType + WebViewDidCommitNavigation WindowEventType + WebViewDidFinishNavigation WindowEventType WebViewDidReceiveServerRedirectForProvisionalNavigation WindowEventType - WebViewDidStartProvisionalNavigation WindowEventType - WindowDidBecomeKey WindowEventType - WindowDidBecomeMain WindowEventType - WindowDidBeginSheet WindowEventType - WindowDidChangeAlpha WindowEventType - WindowDidChangeBackingLocation WindowEventType - WindowDidChangeBackingProperties WindowEventType - WindowDidChangeCollectionBehavior WindowEventType - WindowDidChangeEffectiveAppearance WindowEventType - WindowDidChangeOcclusionState WindowEventType - WindowDidChangeOrderingMode WindowEventType - WindowDidChangeScreen WindowEventType - WindowDidChangeScreenParameters WindowEventType - WindowDidChangeScreenProfile WindowEventType - WindowDidChangeScreenSpace WindowEventType - WindowDidChangeScreenSpaceProperties WindowEventType - WindowDidChangeSharingType WindowEventType - WindowDidChangeSpace WindowEventType - WindowDidChangeSpaceOrderingMode WindowEventType - WindowDidChangeTitle WindowEventType - WindowDidChangeToolbar WindowEventType - WindowDidDeminiaturize WindowEventType - WindowDidEndSheet WindowEventType - WindowDidEnterFullScreen WindowEventType - WindowDidEnterVersionBrowser WindowEventType - WindowDidExitFullScreen WindowEventType - WindowDidExitVersionBrowser WindowEventType - WindowDidExpose WindowEventType - WindowDidFocus WindowEventType - WindowDidMiniaturize WindowEventType - WindowDidMove WindowEventType - WindowDidOrderOffScreen WindowEventType - WindowDidOrderOnScreen WindowEventType - WindowDidResignKey WindowEventType - WindowDidResignMain WindowEventType - WindowDidResize WindowEventType - WindowDidUpdate WindowEventType - WindowDidUpdateAlpha WindowEventType - WindowDidUpdateCollectionBehavior WindowEventType - WindowDidUpdateCollectionProperties WindowEventType - WindowDidUpdateShadow WindowEventType - WindowDidUpdateTitle WindowEventType - WindowDidUpdateToolbar WindowEventType - WindowDidZoom WindowEventType - WindowFileDraggingEntered WindowEventType - WindowFileDraggingExited WindowEventType - WindowFileDraggingPerformed WindowEventType - WindowHide WindowEventType - WindowMaximise WindowEventType - WindowUnMaximise WindowEventType - WindowMinimise WindowEventType - WindowUnMinimise WindowEventType - WindowShouldClose WindowEventType - WindowShow WindowEventType - WindowWillBecomeKey WindowEventType - WindowWillBecomeMain WindowEventType - WindowWillBeginSheet WindowEventType - WindowWillChangeOrderingMode WindowEventType - WindowWillClose WindowEventType - WindowWillDeminiaturize WindowEventType - WindowWillEnterFullScreen WindowEventType - WindowWillEnterVersionBrowser WindowEventType - WindowWillExitFullScreen WindowEventType - WindowWillExitVersionBrowser WindowEventType - WindowWillFocus WindowEventType - WindowWillMiniaturize WindowEventType - WindowWillMove WindowEventType - WindowWillOrderOffScreen WindowEventType - WindowWillOrderOnScreen WindowEventType - WindowWillResignMain WindowEventType - WindowWillResize WindowEventType - WindowWillUnfocus WindowEventType - WindowWillUpdate WindowEventType - WindowWillUpdateAlpha WindowEventType - WindowWillUpdateCollectionBehavior WindowEventType - WindowWillUpdateCollectionProperties WindowEventType - WindowWillUpdateShadow WindowEventType - WindowWillUpdateTitle WindowEventType - WindowWillUpdateToolbar WindowEventType - WindowWillUpdateVisibility WindowEventType - WindowWillUseStandardFrame WindowEventType - WindowZoomIn WindowEventType - WindowZoomOut WindowEventType - WindowZoomReset WindowEventType - WebViewWebContentProcessDidTerminate WindowEventType + WebViewDidStartProvisionalNavigation WindowEventType + WindowDidBecomeKey WindowEventType + WindowDidBecomeMain WindowEventType + WindowDidBeginSheet WindowEventType + WindowDidChangeAlpha WindowEventType + WindowDidChangeBackingLocation WindowEventType + WindowDidChangeBackingProperties WindowEventType + WindowDidChangeCollectionBehavior WindowEventType + WindowDidChangeEffectiveAppearance WindowEventType + WindowDidChangeOcclusionState WindowEventType + WindowDidChangeOrderingMode WindowEventType + WindowDidChangeScreen WindowEventType + WindowDidChangeScreenParameters WindowEventType + WindowDidChangeScreenProfile WindowEventType + WindowDidChangeScreenSpace WindowEventType + WindowDidChangeScreenSpaceProperties WindowEventType + WindowDidChangeSharingType WindowEventType + WindowDidChangeSpace WindowEventType + WindowDidChangeSpaceOrderingMode WindowEventType + WindowDidChangeTitle WindowEventType + WindowDidChangeToolbar WindowEventType + WindowDidDeminiaturize WindowEventType + WindowDidEndSheet WindowEventType + WindowDidEnterFullScreen WindowEventType + WindowDidEnterVersionBrowser WindowEventType + WindowDidExitFullScreen WindowEventType + WindowDidExitVersionBrowser WindowEventType + WindowDidExpose WindowEventType + WindowDidFocus WindowEventType + WindowDidMiniaturize WindowEventType + WindowDidMove WindowEventType + WindowDidOrderOffScreen WindowEventType + WindowDidOrderOnScreen WindowEventType + WindowDidResignKey WindowEventType + WindowDidResignMain WindowEventType + WindowDidResize WindowEventType + WindowDidUpdate WindowEventType + WindowDidUpdateAlpha WindowEventType + WindowDidUpdateCollectionBehavior WindowEventType + WindowDidUpdateCollectionProperties WindowEventType + WindowDidUpdateShadow WindowEventType + WindowDidUpdateTitle WindowEventType + WindowDidUpdateToolbar WindowEventType + WindowDidZoom WindowEventType + WindowFileDraggingEntered WindowEventType + WindowFileDraggingExited WindowEventType + WindowFileDraggingPerformed WindowEventType + WindowHide WindowEventType + WindowMaximise WindowEventType + WindowUnMaximise WindowEventType + WindowMinimise WindowEventType + WindowUnMinimise WindowEventType + WindowShouldClose WindowEventType + WindowShow WindowEventType + WindowWillBecomeKey WindowEventType + WindowWillBecomeMain WindowEventType + WindowWillBeginSheet WindowEventType + WindowWillChangeOrderingMode WindowEventType + WindowWillClose WindowEventType + WindowWillDeminiaturize WindowEventType + WindowWillEnterFullScreen WindowEventType + WindowWillEnterVersionBrowser WindowEventType + WindowWillExitFullScreen WindowEventType + WindowWillExitVersionBrowser WindowEventType + WindowWillFocus WindowEventType + WindowWillMiniaturize WindowEventType + WindowWillMove WindowEventType + WindowWillOrderOffScreen WindowEventType + WindowWillOrderOnScreen WindowEventType + WindowWillResignMain WindowEventType + WindowWillResize WindowEventType + WindowWillUnfocus WindowEventType + WindowWillUpdate WindowEventType + WindowWillUpdateAlpha WindowEventType + WindowWillUpdateCollectionBehavior WindowEventType + WindowWillUpdateCollectionProperties WindowEventType + WindowWillUpdateShadow WindowEventType + WindowWillUpdateTitle WindowEventType + WindowWillUpdateToolbar WindowEventType + WindowWillUpdateVisibility WindowEventType + WindowWillUseStandardFrame WindowEventType + WindowZoomIn WindowEventType + WindowZoomOut WindowEventType + WindowZoomReset WindowEventType + WebViewWebContentProcessDidTerminate WindowEventType } func newMacEvents() macEvents { return macEvents{ - ApplicationDidBecomeActive: 1065, - ApplicationDidChangeBackingProperties: 1066, - ApplicationDidChangeEffectiveAppearance: 1067, - ApplicationDidChangeIcon: 1068, - ApplicationDidChangeOcclusionState: 1069, - ApplicationDidChangeScreenParameters: 1070, - ApplicationDidChangeStatusBarFrame: 1071, + ApplicationDidBecomeActive: 1065, + ApplicationDidChangeBackingProperties: 1066, + ApplicationDidChangeEffectiveAppearance: 1067, + ApplicationDidChangeIcon: 1068, + ApplicationDidChangeOcclusionState: 1069, + ApplicationDidChangeScreenParameters: 1070, + ApplicationDidChangeStatusBarFrame: 1071, ApplicationDidChangeStatusBarOrientation: 1072, - ApplicationDidChangeTheme: 1073, - ApplicationDidFinishLaunching: 1074, - ApplicationDidHide: 1075, - ApplicationDidResignActive: 1076, - ApplicationDidUnhide: 1077, - ApplicationDidUpdate: 1078, - ApplicationDidWake: 1079, - ApplicationScreensDidSleep: 1080, - ApplicationScreensDidWake: 1081, - ApplicationShouldHandleReopen: 1082, - ApplicationWillBecomeActive: 1083, - ApplicationWillFinishLaunching: 1084, - ApplicationWillHide: 1085, - ApplicationWillResignActive: 1086, - ApplicationWillSleep: 1087, - ApplicationWillTerminate: 1088, - ApplicationWillUnhide: 1089, - ApplicationWillUpdate: 1090, - MenuDidAddItem: 1091, - MenuDidBeginTracking: 1092, - MenuDidClose: 1093, - MenuDidDisplayItem: 1094, - MenuDidEndTracking: 1095, - MenuDidHighlightItem: 1096, - MenuDidOpen: 1097, - MenuDidPopUp: 1098, - MenuDidRemoveItem: 1099, - MenuDidSendAction: 1100, - MenuDidSendActionToItem: 1101, - MenuDidUpdate: 1102, - MenuWillAddItem: 1103, - MenuWillBeginTracking: 1104, - MenuWillDisplayItem: 1105, - MenuWillEndTracking: 1106, - MenuWillHighlightItem: 1107, - MenuWillOpen: 1108, - MenuWillPopUp: 1109, - MenuWillRemoveItem: 1110, - MenuWillSendAction: 1111, - MenuWillSendActionToItem: 1112, - MenuWillUpdate: 1113, - WebViewDidCommitNavigation: 1114, - WebViewDidFinishNavigation: 1115, + ApplicationDidChangeTheme: 1073, + ApplicationDidFinishLaunching: 1074, + ApplicationDidHide: 1075, + ApplicationDidResignActive: 1076, + ApplicationDidUnhide: 1077, + ApplicationDidUpdate: 1078, + ApplicationDidWake: 1079, + ApplicationScreensDidSleep: 1080, + ApplicationScreensDidWake: 1081, + ApplicationShouldHandleReopen: 1082, + ApplicationWillBecomeActive: 1083, + ApplicationWillFinishLaunching: 1084, + ApplicationWillHide: 1085, + ApplicationWillResignActive: 1086, + ApplicationWillSleep: 1087, + ApplicationWillTerminate: 1088, + ApplicationWillUnhide: 1089, + ApplicationWillUpdate: 1090, + MenuDidAddItem: 1091, + MenuDidBeginTracking: 1092, + MenuDidClose: 1093, + MenuDidDisplayItem: 1094, + MenuDidEndTracking: 1095, + MenuDidHighlightItem: 1096, + MenuDidOpen: 1097, + MenuDidPopUp: 1098, + MenuDidRemoveItem: 1099, + MenuDidSendAction: 1100, + MenuDidSendActionToItem: 1101, + MenuDidUpdate: 1102, + MenuWillAddItem: 1103, + MenuWillBeginTracking: 1104, + MenuWillDisplayItem: 1105, + MenuWillEndTracking: 1106, + MenuWillHighlightItem: 1107, + MenuWillOpen: 1108, + MenuWillPopUp: 1109, + MenuWillRemoveItem: 1110, + MenuWillSendAction: 1111, + MenuWillSendActionToItem: 1112, + MenuWillUpdate: 1113, + WebViewDidCommitNavigation: 1114, + WebViewDidFinishNavigation: 1115, WebViewDidReceiveServerRedirectForProvisionalNavigation: 1116, - WebViewDidStartProvisionalNavigation: 1117, - WindowDidBecomeKey: 1118, - WindowDidBecomeMain: 1119, - WindowDidBeginSheet: 1120, - WindowDidChangeAlpha: 1121, - WindowDidChangeBackingLocation: 1122, - WindowDidChangeBackingProperties: 1123, - WindowDidChangeCollectionBehavior: 1124, - WindowDidChangeEffectiveAppearance: 1125, - WindowDidChangeOcclusionState: 1126, - WindowDidChangeOrderingMode: 1127, - WindowDidChangeScreen: 1128, - WindowDidChangeScreenParameters: 1129, - WindowDidChangeScreenProfile: 1130, - WindowDidChangeScreenSpace: 1131, - WindowDidChangeScreenSpaceProperties: 1132, - WindowDidChangeSharingType: 1133, - WindowDidChangeSpace: 1134, - WindowDidChangeSpaceOrderingMode: 1135, - WindowDidChangeTitle: 1136, - WindowDidChangeToolbar: 1137, - WindowDidDeminiaturize: 1138, - WindowDidEndSheet: 1139, - WindowDidEnterFullScreen: 1140, - WindowDidEnterVersionBrowser: 1141, - WindowDidExitFullScreen: 1142, - WindowDidExitVersionBrowser: 1143, - WindowDidExpose: 1144, - WindowDidFocus: 1145, - WindowDidMiniaturize: 1146, - WindowDidMove: 1147, - WindowDidOrderOffScreen: 1148, - WindowDidOrderOnScreen: 1149, - WindowDidResignKey: 1150, - WindowDidResignMain: 1151, - WindowDidResize: 1152, - WindowDidUpdate: 1153, - WindowDidUpdateAlpha: 1154, - WindowDidUpdateCollectionBehavior: 1155, - WindowDidUpdateCollectionProperties: 1156, - WindowDidUpdateShadow: 1157, - WindowDidUpdateTitle: 1158, - WindowDidUpdateToolbar: 1159, - WindowDidZoom: 1160, - WindowFileDraggingEntered: 1161, - WindowFileDraggingExited: 1162, - WindowFileDraggingPerformed: 1163, - WindowHide: 1164, - WindowMaximise: 1165, - WindowUnMaximise: 1166, - WindowMinimise: 1167, - WindowUnMinimise: 1168, - WindowShouldClose: 1169, - WindowShow: 1170, - WindowWillBecomeKey: 1171, - WindowWillBecomeMain: 1172, - WindowWillBeginSheet: 1173, - WindowWillChangeOrderingMode: 1174, - WindowWillClose: 1175, - WindowWillDeminiaturize: 1176, - WindowWillEnterFullScreen: 1177, - WindowWillEnterVersionBrowser: 1178, - WindowWillExitFullScreen: 1179, - WindowWillExitVersionBrowser: 1180, - WindowWillFocus: 1181, - WindowWillMiniaturize: 1182, - WindowWillMove: 1183, - WindowWillOrderOffScreen: 1184, - WindowWillOrderOnScreen: 1185, - WindowWillResignMain: 1186, - WindowWillResize: 1187, - WindowWillUnfocus: 1188, - WindowWillUpdate: 1189, - WindowWillUpdateAlpha: 1190, - WindowWillUpdateCollectionBehavior: 1191, - WindowWillUpdateCollectionProperties: 1192, - WindowWillUpdateShadow: 1193, - WindowWillUpdateTitle: 1194, - WindowWillUpdateToolbar: 1195, - WindowWillUpdateVisibility: 1196, - WindowWillUseStandardFrame: 1197, - WindowZoomIn: 1198, - WindowZoomOut: 1199, - WindowZoomReset: 1200, - WebViewWebContentProcessDidTerminate: 1267, + WebViewDidStartProvisionalNavigation: 1117, + WindowDidBecomeKey: 1118, + WindowDidBecomeMain: 1119, + WindowDidBeginSheet: 1120, + WindowDidChangeAlpha: 1121, + WindowDidChangeBackingLocation: 1122, + WindowDidChangeBackingProperties: 1123, + WindowDidChangeCollectionBehavior: 1124, + WindowDidChangeEffectiveAppearance: 1125, + WindowDidChangeOcclusionState: 1126, + WindowDidChangeOrderingMode: 1127, + WindowDidChangeScreen: 1128, + WindowDidChangeScreenParameters: 1129, + WindowDidChangeScreenProfile: 1130, + WindowDidChangeScreenSpace: 1131, + WindowDidChangeScreenSpaceProperties: 1132, + WindowDidChangeSharingType: 1133, + WindowDidChangeSpace: 1134, + WindowDidChangeSpaceOrderingMode: 1135, + WindowDidChangeTitle: 1136, + WindowDidChangeToolbar: 1137, + WindowDidDeminiaturize: 1138, + WindowDidEndSheet: 1139, + WindowDidEnterFullScreen: 1140, + WindowDidEnterVersionBrowser: 1141, + WindowDidExitFullScreen: 1142, + WindowDidExitVersionBrowser: 1143, + WindowDidExpose: 1144, + WindowDidFocus: 1145, + WindowDidMiniaturize: 1146, + WindowDidMove: 1147, + WindowDidOrderOffScreen: 1148, + WindowDidOrderOnScreen: 1149, + WindowDidResignKey: 1150, + WindowDidResignMain: 1151, + WindowDidResize: 1152, + WindowDidUpdate: 1153, + WindowDidUpdateAlpha: 1154, + WindowDidUpdateCollectionBehavior: 1155, + WindowDidUpdateCollectionProperties: 1156, + WindowDidUpdateShadow: 1157, + WindowDidUpdateTitle: 1158, + WindowDidUpdateToolbar: 1159, + WindowDidZoom: 1160, + WindowFileDraggingEntered: 1161, + WindowFileDraggingExited: 1162, + WindowFileDraggingPerformed: 1163, + WindowHide: 1164, + WindowMaximise: 1165, + WindowUnMaximise: 1166, + WindowMinimise: 1167, + WindowUnMinimise: 1168, + WindowShouldClose: 1169, + WindowShow: 1170, + WindowWillBecomeKey: 1171, + WindowWillBecomeMain: 1172, + WindowWillBeginSheet: 1173, + WindowWillChangeOrderingMode: 1174, + WindowWillClose: 1175, + WindowWillDeminiaturize: 1176, + WindowWillEnterFullScreen: 1177, + WindowWillEnterVersionBrowser: 1178, + WindowWillExitFullScreen: 1179, + WindowWillExitVersionBrowser: 1180, + WindowWillFocus: 1181, + WindowWillMiniaturize: 1182, + WindowWillMove: 1183, + WindowWillOrderOffScreen: 1184, + WindowWillOrderOnScreen: 1185, + WindowWillResignMain: 1186, + WindowWillResize: 1187, + WindowWillUnfocus: 1188, + WindowWillUpdate: 1189, + WindowWillUpdateAlpha: 1190, + WindowWillUpdateCollectionBehavior: 1191, + WindowWillUpdateCollectionProperties: 1192, + WindowWillUpdateShadow: 1193, + WindowWillUpdateTitle: 1194, + WindowWillUpdateToolbar: 1195, + WindowWillUpdateVisibility: 1196, + WindowWillUseStandardFrame: 1197, + WindowZoomIn: 1198, + WindowZoomOut: 1199, + WindowZoomReset: 1200, + WebViewWebContentProcessDidTerminate: 1267, } } var Windows = newWindowsEvents() type windowsEvents struct { - APMPowerSettingChange ApplicationEventType - APMPowerStatusChange ApplicationEventType - APMResumeAutomatic ApplicationEventType - APMResumeSuspend ApplicationEventType - APMSuspend ApplicationEventType - ApplicationStarted ApplicationEventType - SystemThemeChanged ApplicationEventType + APMPowerSettingChange ApplicationEventType + APMPowerStatusChange ApplicationEventType + APMResumeAutomatic ApplicationEventType + APMResumeSuspend ApplicationEventType + APMSuspend ApplicationEventType + ApplicationStarted ApplicationEventType + SystemThemeChanged ApplicationEventType WebViewNavigationCompleted WindowEventType - WindowActive WindowEventType - WindowBackgroundErase WindowEventType - WindowClickActive WindowEventType - WindowClosing WindowEventType - WindowDidMove WindowEventType - WindowDidResize WindowEventType - WindowDPIChanged WindowEventType - WindowDragDrop WindowEventType - WindowDragEnter WindowEventType - WindowDragLeave WindowEventType - WindowDragOver WindowEventType - WindowEndMove WindowEventType - WindowEndResize WindowEventType - WindowFullscreen WindowEventType - WindowHide WindowEventType - WindowInactive WindowEventType - WindowKeyDown WindowEventType - WindowKeyUp WindowEventType - WindowKillFocus WindowEventType - WindowNonClientHit WindowEventType - WindowNonClientMouseDown WindowEventType - WindowNonClientMouseLeave WindowEventType - WindowNonClientMouseMove WindowEventType - WindowNonClientMouseUp WindowEventType - WindowPaint WindowEventType - WindowRestore WindowEventType - WindowSetFocus WindowEventType - WindowShow WindowEventType - WindowStartMove WindowEventType - WindowStartResize WindowEventType - WindowUnFullscreen WindowEventType - WindowZOrderChanged WindowEventType - WindowMinimise WindowEventType - WindowUnMinimise WindowEventType - WindowMaximise WindowEventType - WindowUnMaximise WindowEventType + WindowActive WindowEventType + WindowBackgroundErase WindowEventType + WindowClickActive WindowEventType + WindowClosing WindowEventType + WindowDidMove WindowEventType + WindowDidResize WindowEventType + WindowDPIChanged WindowEventType + WindowDragDrop WindowEventType + WindowDragEnter WindowEventType + WindowDragLeave WindowEventType + WindowDragOver WindowEventType + WindowEndMove WindowEventType + WindowEndResize WindowEventType + WindowFullscreen WindowEventType + WindowHide WindowEventType + WindowInactive WindowEventType + WindowKeyDown WindowEventType + WindowKeyUp WindowEventType + WindowKillFocus WindowEventType + WindowNonClientHit WindowEventType + WindowNonClientMouseDown WindowEventType + WindowNonClientMouseLeave WindowEventType + WindowNonClientMouseMove WindowEventType + WindowNonClientMouseUp WindowEventType + WindowPaint WindowEventType + WindowRestore WindowEventType + WindowSetFocus WindowEventType + WindowShow WindowEventType + WindowStartMove WindowEventType + WindowStartResize WindowEventType + WindowUnFullscreen WindowEventType + WindowZOrderChanged WindowEventType + WindowMinimise WindowEventType + WindowUnMinimise WindowEventType + WindowMaximise WindowEventType + WindowUnMaximise WindowEventType } func newWindowsEvents() windowsEvents { return windowsEvents{ - APMPowerSettingChange: 1201, - APMPowerStatusChange: 1202, - APMResumeAutomatic: 1203, - APMResumeSuspend: 1204, - APMSuspend: 1205, - ApplicationStarted: 1206, - SystemThemeChanged: 1207, + APMPowerSettingChange: 1201, + APMPowerStatusChange: 1202, + APMResumeAutomatic: 1203, + APMResumeSuspend: 1204, + APMSuspend: 1205, + ApplicationStarted: 1206, + SystemThemeChanged: 1207, WebViewNavigationCompleted: 1208, - WindowActive: 1209, - WindowBackgroundErase: 1210, - WindowClickActive: 1211, - WindowClosing: 1212, - WindowDidMove: 1213, - WindowDidResize: 1214, - WindowDPIChanged: 1215, - WindowDragDrop: 1216, - WindowDragEnter: 1217, - WindowDragLeave: 1218, - WindowDragOver: 1219, - WindowEndMove: 1220, - WindowEndResize: 1221, - WindowFullscreen: 1222, - WindowHide: 1223, - WindowInactive: 1224, - WindowKeyDown: 1225, - WindowKeyUp: 1226, - WindowKillFocus: 1227, - WindowNonClientHit: 1228, - WindowNonClientMouseDown: 1229, - WindowNonClientMouseLeave: 1230, - WindowNonClientMouseMove: 1231, - WindowNonClientMouseUp: 1232, - WindowPaint: 1233, - WindowRestore: 1234, - WindowSetFocus: 1235, - WindowShow: 1236, - WindowStartMove: 1237, - WindowStartResize: 1238, - WindowUnFullscreen: 1239, - WindowZOrderChanged: 1240, - WindowMinimise: 1241, - WindowUnMinimise: 1242, - WindowMaximise: 1243, - WindowUnMaximise: 1244, + WindowActive: 1209, + WindowBackgroundErase: 1210, + WindowClickActive: 1211, + WindowClosing: 1212, + WindowDidMove: 1213, + WindowDidResize: 1214, + WindowDPIChanged: 1215, + WindowDragDrop: 1216, + WindowDragEnter: 1217, + WindowDragLeave: 1218, + WindowDragOver: 1219, + WindowEndMove: 1220, + WindowEndResize: 1221, + WindowFullscreen: 1222, + WindowHide: 1223, + WindowInactive: 1224, + WindowKeyDown: 1225, + WindowKeyUp: 1226, + WindowKillFocus: 1227, + WindowNonClientHit: 1228, + WindowNonClientMouseDown: 1229, + WindowNonClientMouseLeave: 1230, + WindowNonClientMouseMove: 1231, + WindowNonClientMouseUp: 1232, + WindowPaint: 1233, + WindowRestore: 1234, + WindowSetFocus: 1235, + WindowShow: 1236, + WindowStartMove: 1237, + WindowStartResize: 1238, + WindowUnFullscreen: 1239, + WindowZOrderChanged: 1240, + WindowMinimise: 1241, + WindowUnMinimise: 1242, + WindowMaximise: 1243, + WindowUnMaximise: 1244, } } var IOS = newIOSEvents() type iosEvents struct { - ApplicationDidBecomeActive ApplicationEventType - ApplicationDidEnterBackground ApplicationEventType - ApplicationDidFinishLaunching ApplicationEventType - ApplicationDidReceiveMemoryWarning ApplicationEventType - ApplicationWillEnterForeground ApplicationEventType - ApplicationWillResignActive ApplicationEventType - ApplicationWillTerminate ApplicationEventType - WindowDidLoad WindowEventType - WindowWillAppear WindowEventType - WindowDidAppear WindowEventType - WindowWillDisappear WindowEventType - WindowDidDisappear WindowEventType - WindowSafeAreaInsetsChanged WindowEventType - WindowOrientationChanged WindowEventType - WindowTouchBegan WindowEventType - WindowTouchMoved WindowEventType - WindowTouchEnded WindowEventType - WindowTouchCancelled WindowEventType - WebViewDidStartNavigation WindowEventType - WebViewDidFinishNavigation WindowEventType - WebViewDidFailNavigation WindowEventType + ApplicationDidBecomeActive ApplicationEventType + ApplicationDidEnterBackground ApplicationEventType + ApplicationDidFinishLaunching ApplicationEventType + ApplicationDidReceiveMemoryWarning ApplicationEventType + ApplicationWillEnterForeground ApplicationEventType + ApplicationWillResignActive ApplicationEventType + ApplicationWillTerminate ApplicationEventType + WindowDidLoad WindowEventType + WindowWillAppear WindowEventType + WindowDidAppear WindowEventType + WindowWillDisappear WindowEventType + WindowDidDisappear WindowEventType + WindowSafeAreaInsetsChanged WindowEventType + WindowOrientationChanged WindowEventType + WindowTouchBegan WindowEventType + WindowTouchMoved WindowEventType + WindowTouchEnded WindowEventType + WindowTouchCancelled WindowEventType + WebViewDidStartNavigation WindowEventType + WebViewDidFinishNavigation WindowEventType + WebViewDidFailNavigation WindowEventType WebViewDecidePolicyForNavigationAction WindowEventType - BatteryChanged ApplicationEventType - NetworkChanged ApplicationEventType - ThemeChanged ApplicationEventType - ScreenLocked ApplicationEventType - ScreenUnlocked ApplicationEventType + BatteryChanged ApplicationEventType + NetworkChanged ApplicationEventType + ThemeChanged ApplicationEventType + ScreenLocked ApplicationEventType + ScreenUnlocked ApplicationEventType } func newIOSEvents() iosEvents { return iosEvents{ - ApplicationDidBecomeActive: 1245, - ApplicationDidEnterBackground: 1246, - ApplicationDidFinishLaunching: 1247, - ApplicationDidReceiveMemoryWarning: 1248, - ApplicationWillEnterForeground: 1249, - ApplicationWillResignActive: 1250, - ApplicationWillTerminate: 1251, - WindowDidLoad: 1252, - WindowWillAppear: 1253, - WindowDidAppear: 1254, - WindowWillDisappear: 1255, - WindowDidDisappear: 1256, - WindowSafeAreaInsetsChanged: 1257, - WindowOrientationChanged: 1258, - WindowTouchBegan: 1259, - WindowTouchMoved: 1260, - WindowTouchEnded: 1261, - WindowTouchCancelled: 1262, - WebViewDidStartNavigation: 1263, - WebViewDidFinishNavigation: 1264, - WebViewDidFailNavigation: 1265, + ApplicationDidBecomeActive: 1245, + ApplicationDidEnterBackground: 1246, + ApplicationDidFinishLaunching: 1247, + ApplicationDidReceiveMemoryWarning: 1248, + ApplicationWillEnterForeground: 1249, + ApplicationWillResignActive: 1250, + ApplicationWillTerminate: 1251, + WindowDidLoad: 1252, + WindowWillAppear: 1253, + WindowDidAppear: 1254, + WindowWillDisappear: 1255, + WindowDidDisappear: 1256, + WindowSafeAreaInsetsChanged: 1257, + WindowOrientationChanged: 1258, + WindowTouchBegan: 1259, + WindowTouchMoved: 1260, + WindowTouchEnded: 1261, + WindowTouchCancelled: 1262, + WebViewDidStartNavigation: 1263, + WebViewDidFinishNavigation: 1264, + WebViewDidFailNavigation: 1265, WebViewDecidePolicyForNavigationAction: 1266, - BatteryChanged: 1277, - NetworkChanged: 1278, - ThemeChanged: 1279, - ScreenLocked: 1280, - ScreenUnlocked: 1281, + BatteryChanged: 1277, + NetworkChanged: 1278, + ThemeChanged: 1279, + ScreenLocked: 1280, + ScreenUnlocked: 1281, } } var Android = newAndroidEvents() type androidEvents struct { - ActivityCreated ApplicationEventType - ActivityStarted ApplicationEventType - ActivityResumed ApplicationEventType - ActivityPaused ApplicationEventType - ActivityStopped ApplicationEventType - ActivityDestroyed ApplicationEventType + ActivityCreated ApplicationEventType + ActivityStarted ApplicationEventType + ActivityResumed ApplicationEventType + ActivityPaused ApplicationEventType + ActivityStopped ApplicationEventType + ActivityDestroyed ApplicationEventType ApplicationLowMemory ApplicationEventType - WebViewPageStarted WindowEventType - WebViewPageFinished WindowEventType - BatteryChanged ApplicationEventType - NetworkChanged ApplicationEventType - ThemeChanged ApplicationEventType - ScreenLocked ApplicationEventType - ScreenUnlocked ApplicationEventType + WebViewPageStarted WindowEventType + WebViewPageFinished WindowEventType + BatteryChanged ApplicationEventType + NetworkChanged ApplicationEventType + ThemeChanged ApplicationEventType + ScreenLocked ApplicationEventType + ScreenUnlocked ApplicationEventType } func newAndroidEvents() androidEvents { return androidEvents{ - ActivityCreated: 1268, - ActivityStarted: 1269, - ActivityResumed: 1270, - ActivityPaused: 1271, - ActivityStopped: 1272, - ActivityDestroyed: 1273, + ActivityCreated: 1268, + ActivityStarted: 1269, + ActivityResumed: 1270, + ActivityPaused: 1271, + ActivityStopped: 1272, + ActivityDestroyed: 1273, ApplicationLowMemory: 1274, - WebViewPageStarted: 1275, - WebViewPageFinished: 1276, - BatteryChanged: 1282, - NetworkChanged: 1283, - ThemeChanged: 1284, - ScreenLocked: 1285, - ScreenUnlocked: 1286, + WebViewPageStarted: 1275, + WebViewPageFinished: 1276, + BatteryChanged: 1282, + NetworkChanged: 1283, + ThemeChanged: 1284, + ScreenLocked: 1285, + ScreenUnlocked: 1286, } } @@ -873,4 +873,3 @@ var eventToJS = map[uint]string{ 1290: "common:ScreenUnlocked", 1291: "common:LowMemory", } - diff --git a/v3/pkg/w32/dwmapi.go b/v3/pkg/w32/dwmapi.go index 1b911efc316..d66d17c7013 100644 --- a/v3/pkg/w32/dwmapi.go +++ b/v3/pkg/w32/dwmapi.go @@ -13,6 +13,7 @@ var ( procDwmSetWindowAttribute = moddwmapi.NewProc("DwmSetWindowAttribute") procDwmGetWindowAttribute = moddwmapi.NewProc("DwmGetWindowAttribute") procDwmExtendFrameIntoClientArea = moddwmapi.NewProc("DwmExtendFrameIntoClientArea") + procDwmDefWindowProc = moddwmapi.NewProc("DwmDefWindowProc") ) func DwmSetWindowAttribute(hwnd HWND, dwAttribute DWMWINDOWATTRIBUTE, pvAttribute unsafe.Pointer, cbAttribute uintptr) HRESULT { @@ -33,6 +34,18 @@ func DwmGetWindowAttribute(hwnd HWND, dwAttribute DWMWINDOWATTRIBUTE, pvAttribut return HRESULT(ret) } +func DwmDefWindowProc(hwnd HWND, msg uint32, wparam, lparam uintptr) (uintptr, bool) { + var result uintptr + ret, _, _ := procDwmDefWindowProc.Call( + hwnd, + uintptr(msg), + wparam, + lparam, + uintptr(unsafe.Pointer(&result)), + ) + return result, ret != 0 +} + func dwmExtendFrameIntoClientArea(hwnd uintptr, margins *MARGINS) error { ret, _, _ := procDwmExtendFrameIntoClientArea.Call( hwnd, diff --git a/v3/pkg/w32/user32.go b/v3/pkg/w32/user32.go index 33696f67b99..203d5154688 100644 --- a/v3/pkg/w32/user32.go +++ b/v3/pkg/w32/user32.go @@ -52,9 +52,13 @@ var ( procScreenToClient = moduser32.NewProc("ScreenToClient") procCallWindowProc = moduser32.NewProc("CallWindowProcW") procSetWindowLong = moduser32.NewProc("SetWindowLongW") - procSetWindowLongPtr = moduser32.NewProc("SetWindowLongW") + // Wails v3 does not support 32-bit Windows. On 32-bit Windows these Ptr + // APIs are C macros over SetWindowLongW/GetWindowLongW and are not exported + // from user32.dll, so keep the real 64-bit exports here instead of adding a + // 386 fallback. + procSetWindowLongPtr = moduser32.NewProc("SetWindowLongPtrW") procGetWindowLong = moduser32.NewProc("GetWindowLongW") - procGetWindowLongPtr = moduser32.NewProc("GetWindowLongW") + procGetWindowLongPtr = moduser32.NewProc("GetWindowLongPtrW") procEnableWindow = moduser32.NewProc("EnableWindow") procIsWindowEnabled = moduser32.NewProc("IsWindowEnabled") procIsWindowVisible = moduser32.NewProc("IsWindowVisible") @@ -67,12 +71,14 @@ var ( procGetClientRect = moduser32.NewProc("GetClientRect") procGetDC = moduser32.NewProc("GetDC") procReleaseDC = moduser32.NewProc("ReleaseDC") + procGetCapture = moduser32.NewProc("GetCapture") procSetCapture = moduser32.NewProc("SetCapture") procReleaseCapture = moduser32.NewProc("ReleaseCapture") procGetWindowThreadProcessId = moduser32.NewProc("GetWindowThreadProcessId") procMessageBox = moduser32.NewProc("MessageBoxW") procMessageBoxIndirect = moduser32.NewProc("MessageBoxIndirectW") procGetSystemMetrics = moduser32.NewProc("GetSystemMetrics") + procGetSystemMetricsForDpi = moduser32.NewProc("GetSystemMetricsForDpi") procPostThreadMessageW = moduser32.NewProc("PostThreadMessageW") procRegisterHotKey = moduser32.NewProc("RegisterHotKey") procUnregisterHotKey = moduser32.NewProc("UnregisterHotKey") @@ -785,6 +791,11 @@ func SetCapture(hwnd HWND) HWND { return HWND(ret) } +func GetCapture() HWND { + ret, _, _ := procGetCapture.Call() + return HWND(ret) +} + func ReleaseCapture() bool { ret, _, _ := procReleaseCapture.Call() @@ -825,6 +836,18 @@ func GetSystemMetrics(index int) int { return int(ret) } +func HasGetSystemMetricsForDpiFunc() bool { + return procGetSystemMetricsForDpi.Find() == nil +} + +func GetSystemMetricsForDpi(index int, dpi UINT) int { + ret, _, _ := procGetSystemMetricsForDpi.Call( + uintptr(index), + uintptr(dpi)) + + return int(ret) +} + func GetSysColorBrush(nIndex int) HBRUSH { ret, _, _ := procGetSysColorBrush.Call(1, uintptr(nIndex), @@ -1550,6 +1573,18 @@ func TrackPopupMenu(hmenu HMENU, flags uint32, x, y int32, reserved int32, hwnd return ret != 0 } +func TrackPopupMenuCommand(hmenu HMENU, flags uint32, x, y int32, hwnd HWND, prcRect *RECT) uintptr { + ret, _, _ := procTrackPopupMenu.Call( + uintptr(hmenu), + uintptr(flags|TPM_RETURNCMD), + uintptr(x), + uintptr(y), + 0, + uintptr(hwnd), + uintptr(unsafe.Pointer(prcRect))) + return ret +} + // KeybdEvent synthesizes a keystroke. The system can use such a synthesized keystroke to generate a WM_KEYUP or WM_KEYDOWN message. // bVk: Virtual-key code // bScan: Hardware scan code diff --git a/v3/pkg/w32/window.go b/v3/pkg/w32/window.go index c26ec414d1e..fff2d93f2b6 100644 --- a/v3/pkg/w32/window.go +++ b/v3/pkg/w32/window.go @@ -43,6 +43,7 @@ var Fatal func(error) const ( GCLP_HBRBACKGROUND int32 = -10 + GCLP_HCURSOR int32 = -12 GCLP_HICON int32 = -14 ) @@ -63,8 +64,12 @@ func ExtendFrameIntoClientArea(hwnd uintptr, extend bool) error { // are shown if transparent ant translucent. var margins MARGINS if extend { - margins = MARGINS{1, 1, 1, 1} // Only extend 1 pixel to have the default frame styling but no caption buttons + margins = MARGINS{1, 1, 1, 1} } + return ExtendFrameIntoClientAreaWithMargins(hwnd, margins) +} + +func ExtendFrameIntoClientAreaWithMargins(hwnd uintptr, margins MARGINS) error { if err := dwmExtendFrameIntoClientArea(hwnd, &margins); err != nil { return fmt.Errorf("DwmExtendFrameIntoClientArea failed: %s", err) } @@ -114,6 +119,10 @@ func SetApplicationIcon(hwnd uintptr, icon HICON) { setClassLongPtr(hwnd, GCLP_HICON, icon) } +func SetClassCursor(hwnd uintptr, cursor HCURSOR) { + setClassLongPtr(hwnd, GCLP_HCURSOR, cursor) +} + func SetBackgroundColour(hwnd uintptr, r, g, b uint8) { col := uint32(r) | uint32(g)<<8 | uint32(b)<<16 hbrush, _, _ := procCreateSolidBrush.Call(uintptr(col)) @@ -192,7 +201,7 @@ func MustStringToUTF16uintptr(input string) uintptr { } // MustStringToUTF16 converts s to UTF-16 encoding, stripping any embedded NULs and panicking on error. -// +// // The returned slice is suitable for Windows API calls that expect a UTF-16 encoded string. func MustStringToUTF16(input string) []uint16 { input = stripNulls(input) @@ -339,6 +348,11 @@ func EnableCloseButton(hwnd HWND) error { return nil } +func GetSystemMenu(hwnd HWND, revert bool) HMENU { + ret, _, _ := getSystemMenu.Call(hwnd, uintptr(BoolToBOOL(revert))) + return HMENU(ret) +} + func FindWindowW(className, windowName *uint16) HWND { ret, _, _ := findWindow.Call( uintptr(unsafe.Pointer(className)), @@ -374,4 +388,4 @@ func SendMessageToWindow(hwnd HWND, msg string) { func GetMenu(hwnd HWND) HMENU { ret, _, _ := getMenuProc.Call(hwnd) return ret -} \ No newline at end of file +} diff --git a/v3/wep/README.md b/v3/wep/README.md index 63ea57c980a..55be7bfad90 100644 --- a/v3/wep/README.md +++ b/v3/wep/README.md @@ -11,10 +11,20 @@ Following this structured approach ensures transparency, community involvement, **NOTE**: This process is for proposing new functionality. For bug fixes, documentation improvements, and other minor changes, please follow the standard PR process. +## Do I Need a WEP? + +Not every change needs a proposal. As a rule of thumb: + +- **WEP required**: new public API, changes to existing API behaviour, breaking changes, new cross-platform functionality, or anything involving significant platform-specific work. +- **No WEP needed**: bug fixes, documentation, small additive options, internal refactoring. Use the standard PR process. + +If you are unsure, ask in the [Ideas](https://github.com/wailsapp/wails/discussions/categories/ideas) category on GitHub Discussions or on [Discord](https://discord.gg/JDdSxwjhGf). + ## Submission of Proposal ### 1. Idea Initiation +- **Gauge Interest (optional)**: Before writing a proposal, consider floating the idea in the [Ideas](https://github.com/wailsapp/wails/discussions/categories/ideas) category on GitHub Discussions or on [Discord](https://discord.gg/JDdSxwjhGf). It can catch overlap with existing plans before you invest time in a write-up. - **Document Your Idea**: - Create a new directory: `v3/wep/proposals/` with the name of your proposal. - Copy the WEP template located in `v3/wep/WEP_TEMPLATE.md` into `v3/wep/proposals//proposal.md`. @@ -30,9 +40,9 @@ Following this structured approach ensures transparency, community involvement, ### 3. Community Discussion -- **Share Your Proposal**: Present your proposal to the Wails community. Try to get support for the proposal to increase the chances of acceptance. If you are on the discord server, create a post in the [`#enhancement-proposals`](https://discord.gg/TA8kbQds95) channel. -- **Gather Feedback**: Refine your proposal based on community input. All feedback should be added as comments in the PR. -- **Show Support**: Agreement with the proposal should be indicated by adding a thumbs-up emoji to the PR. The more thumbs-up emojis, the more likely the proposal will be accepted. +- **Share Your Proposal**: The PR is the official place to discuss the proposal. Present it to the Wails community and try to get support for it to increase the chances of acceptance. If you are on the discord server, share it in the [`#enhancement-proposals`](https://discord.gg/TA8kbQds95) channel. +- **Gather Feedback**: Refine your proposal based on community input. All feedback should be added as comments on the PR so the discussion stays with the document. +- **Show Support**: Agreement with the proposal should be indicated by adding a thumbs-up reaction to the PR. The more support a proposal has, the more likely it is to be accepted. - **Iterate**: Make changes to the proposal based on feedback. - **Agree on an Implementor**: To avoid stagnant proposals, we require someone agree to implement it. This could be the proposer. - **Ready for Review**: Once the proposal is ready for review, change the PR status to `Ready for Review`. @@ -41,11 +51,20 @@ A minimum of 2 weeks should be given for community feedback and discussion. ### 4. Final Decision -- **Decision**: The Wails maintainers will make a final decision on the proposal based on community feedback and the proposal's merits. - - If accepted, the proposal will be assigned a WEP number and the PR merged. - - If rejected, the reasons will be provided in the PR comments. +- **Decision**: The Wails maintainers will make a final decision on the proposal based on community feedback and the proposal's merits. The decision is recorded as a comment on the PR in this format: + + ``` + **Decision**: Accepted / Rejected + **Decided by**: @maintainer(s) + **Rationale**: A short explanation of the decision. + ``` + +- **If accepted**: + - The proposal is assigned the next WEP number and its directory renamed to `NNNN-`. + - The proposal's status is updated to `Accepted`, it is added to the [WEP Index](#wep-index), and the PR is merged. +- **If rejected**: The PR is closed and the proposal recorded in the [WEP Index](#wep-index) with a link to the decision, so the outcome is easy to find if the idea comes up again. -*NOTE*: If a proposal has not met the required support or has been inactive for more than a month, it may be closed. +*NOTE*: If a proposal has not met the required support or has been inactive for more than a month, it may be closed as `Withdrawn`. ## Implementation of Proposal @@ -66,4 +85,16 @@ Once a proposal has been accepted and an implementation plan has been decided, t - **Review of PR**: Address any review comments. - **Merge**: The PR will be merged after satisfactory review. +- **Update the Status**: When the implementation PR merges, update the proposal's status to `Implemented` and add the implementation PR to the [WEP Index](#wep-index). + +*NOTE*: Acceptance requires a committed implementor. If implementation has not started within 3 months of acceptance, the proposal is marked as up for grabs in the WEP Index and anyone may take it on. + +## WEP Index + +| WEP | Title | Status | Proposal | Implementation | +|-----|-------|--------|----------|----------------| +| [0001](proposals/0001-titlebar-buttons/proposal.md) | Customising Window Controls | Implemented | [#3508](https://github.com/wailsapp/wails/pull/3508) | [#3508](https://github.com/wailsapp/wails/pull/3508) | + +**Statuses**: `Draft` (under discussion), `Accepted` (approved, awaiting implementation), `Implemented` (shipped), `Rejected` (declined), `Withdrawn` (closed by the author or for inactivity). + The WEP process ensures structured and collaborative enhancement of Wails. Adhere to this guide to contribute effectively to the project's growth. \ No newline at end of file diff --git a/v3/wep/WEP_TEMPLATE.md b/v3/wep/WEP_TEMPLATE.md index c822c236177..dc2140ede72 100644 --- a/v3/wep/WEP_TEMPLATE.md +++ b/v3/wep/WEP_TEMPLATE.md @@ -2,8 +2,12 @@ ## Title +**WEP Number**: (leave blank, assigned on acceptance) +**Status**: Draft **Author**: [Your Name] -**Created**: [YYYY-MM-DD] +**Created**: [YYYY-MM-DD] +**Discussion**: [optional link to any prior discussion of the idea] +**Implementor**: [who has agreed to implement this, may be the author] ## Summary @@ -21,6 +25,13 @@ Provide a detailed description of the proposed feature, including: - Implementation steps - Potential impact on existing functionality +## Platform Considerations + +Describe how the feature behaves on each platform (Windows, macOS, Linux, and mobile where relevant). Include: + +- Platform-specific behaviour, limitations or API differences +- Any platform where the feature is unsupported, and why + ## Pros/Cons List the pros and cons of the proposed solution. diff --git a/v3/wep/proposals/titlebar-buttons/proposal.md b/v3/wep/proposals/0001-titlebar-buttons/proposal.md similarity index 94% rename from v3/wep/proposals/titlebar-buttons/proposal.md rename to v3/wep/proposals/0001-titlebar-buttons/proposal.md index 8bd6b8c4fdc..c699f8d1c2d 100644 --- a/v3/wep/proposals/titlebar-buttons/proposal.md +++ b/v3/wep/proposals/0001-titlebar-buttons/proposal.md @@ -2,8 +2,12 @@ ## Customising Window Controls in Wails -**Author**: Lea Anthony -**Created**: 2024-05-20 +**WEP Number**: 0001 +**Status**: Implemented +**Author**: Lea Anthony +**Created**: 2024-05-20 +**Proposal**: [#3508](https://github.com/wailsapp/wails/pull/3508) +**Implementor**: Lea Anthony ## Summary diff --git a/website/i18n/en/docusaurus-plugin-content-docs/version-v2.13.0.json b/website/i18n/en/docusaurus-plugin-content-docs/version-v2.13.0.json new file mode 100644 index 00000000000..a665611f119 --- /dev/null +++ b/website/i18n/en/docusaurus-plugin-content-docs/version-v2.13.0.json @@ -0,0 +1,38 @@ +{ + "version.label": { + "message": "v2.13.0", + "description": "The label for version v2.13.0" + }, + "sidebar.docs.category.Getting Started": { + "message": "Getting Started", + "description": "The label for category 'Getting Started' in sidebar 'docs'" + }, + "sidebar.docs.category.Reference": { + "message": "Reference", + "description": "The label for category 'Reference' in sidebar 'docs'" + }, + "sidebar.docs.category.Runtime": { + "message": "Runtime", + "description": "The label for category 'Runtime' in sidebar 'docs'" + }, + "sidebar.docs.category.Community": { + "message": "Community", + "description": "The label for category 'Community' in sidebar 'docs'" + }, + "sidebar.docs.category.Showcase": { + "message": "Showcase", + "description": "The label for category 'Showcase' in sidebar 'docs'" + }, + "sidebar.docs.category.Guides": { + "message": "Guides", + "description": "The label for category 'Guides' in sidebar 'docs'" + }, + "sidebar.docs.category.Tutorials": { + "message": "Tutorials", + "description": "The label for category 'Tutorials' in sidebar 'docs'" + }, + "sidebar.docs.link.Contributing": { + "message": "Contributing", + "description": "The label for link 'Contributing' in sidebar 'docs', linking to '/community-guide#ways-of-contributing'" + } +} diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0.json b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0.json new file mode 100644 index 00000000000..f9fa85bae9c --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0.json @@ -0,0 +1,38 @@ +{ + "version.label": { + "message": "Prochaine version 🚧", + "description": "The label for version current" + }, + "sidebar.docs.category.Getting Started": { + "message": "Pour démarrer", + "description": "The label for category Getting Started in sidebar docs" + }, + "sidebar.docs.category.Reference": { + "message": "Références", + "description": "The label for category Reference in sidebar docs" + }, + "sidebar.docs.category.Runtime": { + "message": "Exécution", + "description": "The label for category Runtime in sidebar docs" + }, + "sidebar.docs.category.Community": { + "message": "Communauté", + "description": "The label for category Community in sidebar docs" + }, + "sidebar.docs.category.Showcase": { + "message": "Galerie", + "description": "The label for category Showcase in sidebar docs" + }, + "sidebar.docs.category.Guides": { + "message": "Guides", + "description": "The label for category Guides in sidebar docs" + }, + "sidebar.docs.category.Tutorials": { + "message": "Tutoriels", + "description": "The label for category Tutorials in sidebar docs" + }, + "sidebar.docs.link.Contributing": { + "message": "Contribuer", + "description": "The label for link Contributing in sidebar docs, linking to /community-guide#ways-of-contributing" + } +} diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/links.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/links.mdx new file mode 100644 index 00000000000..d6b742435e4 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/links.mdx @@ -0,0 +1,26 @@ +--- +sidebar_position: 2 +--- + +# Liens + +Cette page sert de liste pour les liens liés à la communauté. Veuillez soumettre une PR (cliquez sur `Modifier cette page` en bas) pour soumettre des liens. + +## Awesome Wails + +La [liste définitive](https://github.com/wailsapp/awesome-wails) de liens relatifs à Wails. + +## Canaux de support + +- [Serveur Discord Wails](https://discord.gg/JDdSxwjhGf) +- [Github Issues](https://github.com/wailsapp/wails/issues) +- [canal de discussion sur la bêta v2](https://github.com/wailsapp/wails/discussions/828) + +## Réseaux sociaux + +- [Twitter](https://twitter.com/wailsapp) +- [Groupe QQ pour la communauté chinoise de Wails](https://qm.qq.com/cgi-bin/qm/qr?k=PmIURne5hFGNd7QWzW5qd6FV-INEjNJv&jump_from=webapi) - Numéro de groupe : 1067173054 + +## Autres tutoriels et articles + +- [Construction d'un Panneau d'Affichage](https://blog.customct.com/building-bulletin-board) diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/bulletinboard.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/bulletinboard.mdx new file mode 100644 index 00000000000..2c56a2e836c --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/bulletinboard.mdx @@ -0,0 +1,10 @@ +# BulletinBoard + +```mdx-code-block +

                        + +
                        +

                        +``` + +L'application [BulletinBoard](https://github.com/raguay/BulletinBoard) est un panneau de messages versitaux pour les messages statiques ou les boîtes de dialogue pour obtenir des informations de l'utilisateur pour un script. Il a une TUI pour créer de nouvelles boîtes de dialogue qui peuvent être utilisées pour obtenir des informations de l'utilisateur. Son design est de rester en fonctionnement sur votre système et de montrer les informations au besoin, puis de se cacher. J'ai un processus pour surveiller un fichier sur mon système et pour envoyer le contenu à BulletinBoard une fois modifié. Cela fonctionne très bien avec mes workflows. Il y a auss un [workflow Alfred](https://github.com/raguay/MyAlfred/blob/master/Alfred%205/EmailIt.alfredworkflow) pour envoyer les informations au programme. Le workflow fonctionne aussi avec [EmailIt](https://github.com/raguay/EmailIt). diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/cfntracker.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/cfntracker.mdx new file mode 100644 index 00000000000..7b9dd1164e5 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/cfntracker.mdx @@ -0,0 +1,37 @@ +# CFN Tracker + +```mdx-code-block +

                        + +
                        +

                        +``` + +[CFN Tracker](https://github.com/williamsjokvist/cfn-tracker) - Suivez les matchs en direct de n'importe quel profil CFN Street +Fighter 6 ou V. Allez sur +[le site web](https://cfn.williamsjokvist.se/) pour commencer. + +## Fonctionnalités + +- Suivi des matchs en temps réel +- Affichage des logs et des statistiques des matchs +- Prise en charge de l'affichage des statistiques en direct à OBS via la source Browser +- Support de SF6 et SFV +- Possibilité pour les utilisateurs de créer leurs propres thèmes OBS avec du CSS + +### Technologies principales utilisées aux côtés de Wails + +- [Task](https://github.com/go-task/task) - encapsuler le CLI Wails pour rendre + des commandes communes faciles à utiliser +- [React](https://github.com/facebook/react) - choisi pour son écosystème riche + (radix, framer-motion) +- [Bun](https://github.com/oven-sh/bun) - utilisé pour sa résolution de dépendance + rapide et temps de compilation +- [Rod](https://github.com/go-rod/rod) - Outil d'automatisation du navigateur sans fenêtre pour les modifications d'authentification et de sondage +- [SQLite](https://github.com/mattn/go-sqlite3) - utilisé pour stocker des matches, + sessions et profils +- [Server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events) - Stream HTTP pour suivant les mises à jour et envoyant les modifications aux sources OBS +- [i18next](https://github.com/i18next/) - avec le connecteur backend pour servir les objets de localisation + depuis Go +- [xstate](https://github.com/statelyai/xstate) - des machines à états pour le processus d'authentification + et le suivi diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/emailit.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/emailit.mdx new file mode 100644 index 00000000000..ac64e25acce --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/emailit.mdx @@ -0,0 +1,10 @@ +# EmailIt + +```mdx-code-block +

                        + +
                        +

                        +``` + +[EmailIt](https://github.com/raguay/EmailIt/) est un programme Wails 2 qui est un expéditeur de courrier électronique basé sur le markdown uniquement avec neuf blocs-notes, pour manipuler le texte et les modèles. Il a également un terminal pour exécuter des scripts dans EmailIt sur les fichiers de votre système. Les scripts et modèles peuvent être utilisés depuis la ligne de commande elle-même ou avec les extensions Alfred, Keyboard Maestro, Dropzone ou PopClip. Il supporte également les scripts et thèmes téléchargés sous GitHub. La documentation n'est pas complète, mais le programme fonctionne. Il est construit en utilisant Wails2 et Svelte, et le téléchargement est une application macOS universelle. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/encrypteasy.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/encrypteasy.mdx new file mode 100644 index 00000000000..7f4bd7a634a --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/encrypteasy.mdx @@ -0,0 +1,12 @@ +# EncryptEasy + +```mdx-code-block +

                        + +
                        +

                        +``` + +**[EncryptEasy](https://www.encrypteasy.app) est un outil de chiffrement PGP simple et facile à utiliser, qui gère toutes vos clés et celles de vos contacts. Le chiffrement devrait être simple. Développé avec Wails.** + +Chiffrer les messages à l'aide de PGP est la norme de l'industrie. Tout le monde a une clé privée et publique. Votre clé privée, eh bien, doit être privée afin que vous seul puissiez lire les messages. Votre clé publique est distribuée à toute personne qui veut vous envoyer des messages secrets, chiffrés. Gérer les clés, chiffrer les messages et déchiffrer les messages devrait être une expérience agréable. EncryptEasy a pour but de vous simplifier la tâche. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/espstudio.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/espstudio.mdx new file mode 100644 index 00000000000..3f9f1ab344d --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/espstudio.mdx @@ -0,0 +1,12 @@ +# ESP Studio + +```mdx-code-block +

                        + +
                        +

                        +``` + +[ESP Studio](https://github.com/torabian/esp-studio) - Cross platform, Desktop, Cloud, et logiciel embarqué pour contrôler les appareils ESP/Arduino, et construire des workflows et contrôles de systèmes IOT diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/filehound.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/filehound.mdx new file mode 100644 index 00000000000..7522afa6ecf --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/filehound.mdx @@ -0,0 +1,16 @@ +# Utilitaire d'exportation FileHound + +```mdx-code-block +

                        + +
                        +

                        +``` + +[L'utilitaire d'exportation FileHound](https://www.filehound.co.uk/) est une plate-forme de gestion de documents cloud conçue pour la conservation sécurisée de fichiers, l'automatisation des processus métier et les capacités de SmartCapture. + +L'utilitaire d'exportation FileHound permet aux administrateurs FileHound d'exécuter des tâches sécurisées d'extraction de documents et de données à des fins alternatives de sauvegarde et de récupération. Cette application téléchargera tous les documents et/ou métadonnées enregistrés dans FileHound en fonction des filtres que vous avez choisis. Les métadonnées seront exportées dans les formats JSON et XML. + +Backend construit avec: Go 1.15 Wails 1.11.0 go-sqlite3 1.14.6 go-linq 3.2 + +Frontend avec: Vue 2.6.11 Vuex 3.4.0 TypeScript Tailwind 1.9.6 diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/grpcmd-gui.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/grpcmd-gui.mdx new file mode 100644 index 00000000000..213124a89a3 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/grpcmd-gui.mdx @@ -0,0 +1,10 @@ +# grpcmd-gui + +```mdx-code-block +

                        + +
                        +

                        +``` + +[grpcmd-gui](https://grpc.md/gui) est une application et un client API Desktop cross-plateform moderne pour le développement et le test d'appels gRPC. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/hiposter.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/hiposter.mdx new file mode 100644 index 00000000000..21fd4b11743 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/hiposter.mdx @@ -0,0 +1,10 @@ +# hiposter + +```mdx-code-block +

                        + +
                        +

                        +``` + +[hiposter](https://github.com/obity/hiposter) est un outil client de test d'API http simple et efficace. Basé sur les Wails, Go et sveltejs. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/kafka-king.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/kafka-king.mdx new file mode 100644 index 00000000000..8d40f82371c --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/kafka-king.mdx @@ -0,0 +1,23 @@ +# Kafka-King + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Kafka-King](https://github.com/Bronya0/Kafka-King) est un client GUI kafka qui supporte différents systèmes et est compact et facile à utiliser. +Ceci est fait avec Wails+vue3 + +# Liste des fonctionalités de Kafka-King + +- [x] Voir la liste des nœuds du cluster, prendre en charge la configuration dynamique des éléments de broker et de la configuration des éléments +- [x] Supporte les clients consommateurs, consomme le sujet, la taille et le délai spécifiés selon le groupe spécifié, et affiche les informations du message dans différentes dimensions dans un tableau +- [x] Supporte PLAIN, SSL, SASL, kerberos, sasl_plaintext, etc. +- [x] Créer des topics (support les batches), supprimer des topics, spécifier des replicas, des partitions +- [x] Statistiques de support du nombre total de messages, du nombre total de soumissions et du retard de consommation pour chaque topic basée sur les groupes de consommateurs +- [x] Prise en charge de la visualisation des rubriques Informations détaillées (offset) de la partition, et support l'ajout de partitions supplémentaires +- [x] Supporte la simulation de producteurs, d'envoi de messages par batch, la définition de headers, partitions +- [x] Health check +- [x] Support de la visualisation des groupes de consommateurs, Consommateur- …… diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/mchat.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/mchat.mdx new file mode 100644 index 00000000000..15a908bf401 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/mchat.mdx @@ -0,0 +1,10 @@ +# Mchat + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Page officielle](https://marcio199226.github.io/mchat-site/public/) Chat chiffré de end2end entièrement anonyme. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/minecraftupdater.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/minecraftupdater.mdx new file mode 100644 index 00000000000..5966e75fa63 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/minecraftupdater.mdx @@ -0,0 +1,14 @@ +# Minecraft Updater + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Minecraft Updater](https://github.com/Gurkengewuerz/MinecraftModUpdater) est un outil utilitaire pour mettre à jour et synchroniser les mods Minecraft pour votre base d'utilisateurs. Il a été conçu en utilisant Wails2 et React avec [antd](https://ant.design/) comme framework frontend. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/minesweeper-xp.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/minesweeper-xp.mdx new file mode 100644 index 00000000000..425505b1a83 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/minesweeper-xp.mdx @@ -0,0 +1,10 @@ +# Minesweeper XP + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Minesweeper-XP](https://git.new/Minesweeper-XP) vous permet de vivre l'expérience du Démineur XP (+ 98 et 3.1) sur macOS, Windows et Linux ! diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/modalfilemanager.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/modalfilemanager.mdx new file mode 100644 index 00000000000..fe644bd7bb5 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/modalfilemanager.mdx @@ -0,0 +1,14 @@ +# Modal File Manager + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Modal File Manager](https://github.com/raguay/ModalFileManager) est un gestionnaire de fichiers à double volet utilisant des technologies web. Mon design original était basé sur NW.js et peut être trouvé [ici](https://github.com/raguay/ModalFileManager-NWjs). Cette version utilise le même code frontend basé sur Svelte (mais il a été grandement modifié depuis le départ de NW.js), mais le backend est une implémentation de [Wails 2](https://wails.io/). En utilisant cette implémentation, je n'utilise plus la ligne de commande `rm`, `cp`, etc. , mais une installation de git doit être présente sur le système pour télécharger des thèmes et des extensions. Il est entièrement codé en utilisant Go et fonctionne beaucoup plus rapidement que les versions précédentes. + +Ce gestionnaire de fichiers est conçu autour du même principe que Vim: l'état est contrôlé par des actions via le clavier. Le nombre d'états n'est pas fixe, mais très programmable. Par conséquent, un nombre infini de configurations de clavier qui peuvent être créées et utilisées. C'est la principale différence par rapport aux autres gestionnaires de fichiers. Il y a des thèmes et des extensions disponibles à télécharger à partir de GitHub. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/mollywallet.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/mollywallet.mdx new file mode 100644 index 00000000000..70a6cd1f44d --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/mollywallet.mdx @@ -0,0 +1,10 @@ +# Molley Wallet + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Molly Wallet](https://github.com/grvlle/constellation_wallet/) le portefeuille officiel $DAG du Constellation Network. Cela permettra aux utilisateurs d'interagir avec le réseau Hypergraph de différentes manières, sans se limiter à la production de transactions en $DAG. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/october.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/october.mdx new file mode 100644 index 00000000000..5a9789d8711 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/october.mdx @@ -0,0 +1,14 @@ +# October + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Octobre](https://october.utf9k.net) est une petite application Wails qui rend vraiment facile d'extraire les surlignements de [Kobo eReaders](https://en.wikipedia.org/wiki/Kobo_eReader) puis de les transférer vers [Readwise](https://readwise.io). + +Il a une taille relativement petite avec toutes les versions de la plate-forme pesant en moins de 10 Mo, et c'est sans activer la [compression UPX](https://upx.github.io/)! + +En revanche, les précédentes tentatives de l'auteur avec Electron ont rapidement gonflé à plusieurs centaines de mégaoctets. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/optimus.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/optimus.mdx new file mode 100644 index 00000000000..41744234d37 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/optimus.mdx @@ -0,0 +1,10 @@ +# Optimus + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Optimus](https://github.com/splode/optimus) est une application d'optimisation d'image de bureau. Il supporte la conversion et la compression entre les formats d’images WebP, JPEG et PNG. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/portfall.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/portfall.mdx new file mode 100644 index 00000000000..acdc682becf --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/portfall.mdx @@ -0,0 +1,10 @@ +# Portfall + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Portfall](https://github.com/rekon-oss/portfall) - Un portail de redirection de port k8 pour un accès facile à toutes les interfaces de votre instance diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/resizem.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/resizem.mdx new file mode 100644 index 00000000000..a3b560683f3 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/resizem.mdx @@ -0,0 +1,10 @@ +# Resizem + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Resizem](https://github.com/barats/resizem) - est une application conçue pour le traitement d'images en bloc. Il est particulièrement utile pour les utilisateurs qui ont besoin de redimensionner, de convertir et de gérer un grand nombre de fichiers image à la fois. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/restic-browser.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/restic-browser.mdx new file mode 100644 index 00000000000..b6597166852 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/restic-browser.mdx @@ -0,0 +1,12 @@ +# Restic Browser + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Restic-Browser](https://github.com/emuell/restic-browser) - Une interface de sauvegarde simple et multiplateforme [restic](https://github.com/restic/restic) pour la navigation et la restauration de dépôts restic. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/riftshare.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/riftshare.mdx new file mode 100644 index 00000000000..e47b2397e63 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/riftshare.mdx @@ -0,0 +1,21 @@ +# RiftShare + +```mdx-code-block +

                        + +
                        +

                        +``` + +Partage de fichiers facile, sécurisé et gratuit pour tout le monde. Apprenez-en plus sur [Riftshare.app](https://riftshare.app) + +## Fonctionnalités + +- Partage facile et sécurisé de fichiers entre ordinateurs à la fois sur le réseau local et via Internet +- Supporte l'envoi de fichiers ou de répertoires de manière sécurisée par le protocole [magic wormhole](https://magic-wormhole.readthedocs.io/en/latest/) +- Compatible avec toutes les autres applications utilisant magic wormhole (magic-wormhole or wormhole-william CLI, wormhole-gui, etc.) +- Compression automatique de plusieurs fichiers sélectionnés à envoyer en même temps +- Animations complètes, barre de progression et support d'annulation pour l'envoi et la réception +- Sélection de fichier natif au système d'exploitation +- Ouvrir les fichiers en un seul clic une fois reçus +- Mise à jour automatique - ne vous inquiétez pas d'avoir la dernière version! diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/scriptbar.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/scriptbar.mdx new file mode 100644 index 00000000000..d7215d66126 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/scriptbar.mdx @@ -0,0 +1,10 @@ +# ScriptBar + +```mdx-code-block +

                        + +
                        +

                        +``` + +[ScriptBar](https://GitHub.com/raguay/ScriptBarApp) est un programme pour afficher la sortie de scripts ou d'un serveur [Node-Red](https://nodered.org). Il exécute des scripts définis dans le programme EmailIt et affiche la sortie. Des scripts de xBar ou TextBar peuvent être utilisés. Actuellement sur les scripts TextBar fonctionnent bien. Il affiche également la sortie des scripts sur votre système. ScriptBar ne les met pas dans la barre de menus, mais les a tous dans une fenêtre convenable pour une visualisation facile. Vous pouvez avoir plusieurs onglets pour voir plusieurs choses différentes. Vous pouvez également conserver les liens vers vos sites Web les plus visités. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/snippetexpander.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/snippetexpander.mdx new file mode 100644 index 00000000000..a0445182638 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/snippetexpander.mdx @@ -0,0 +1,27 @@ +# Snippet Expander + +```mdx-code-block +

                        + +
                        + Screenshot of Snippet Expander's Select Snippet window +

                        +

                        + +
                        + Screenshot of Snippet Expander's Add Snippet screen +

                        +

                        + +
                        + Screenshot of Snippet Expander's Search & Paste window +

                        +``` + +[Snippet Expander](https://snippetexpander.org) est "Votre petit assistant de snippets extensibles", pour Linux. + +Snippet Expander comprend une application GUI construite avec Wails pour gérer les modules de texte et les paramètres, avec le mode Recherche & Coller pour sélectionner et coller rapidement un snippet. + +L'interface Wails, le CLI go-lang et le daemon vala-lang d'auto expansion de Wails communiquent tous avec un daemon go-lang via D-Bus. Le daemon fait la majorité du travail, gère la base de données des snippets et des paramètres communs, et fournit des services pour l'expansion et le collage des snippets, etc. + +Consultez le [code source](https://git.sr.ht/~ianmjones/snippetexpander/tree/trunk/item/cmd/snippetexpandergui/app.go#L38) pour voir comment l'application Wails envoie des messages de l'interface utilisateur vers le backend qui sont ensuite envoyés au daemon, et s'abonne à un événement D-Bus pour surveiller les changements de snippets via une autre instance de l'application ou CLI et les afficher instantanément dans l'interface utilisateur via un événement Wails. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/surge.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/surge.mdx new file mode 100644 index 00000000000..b5917484303 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/surge.mdx @@ -0,0 +1,10 @@ +# Surge + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Surge](https://getsurge.io/) est une application de partage de fichiers p2p conçue pour utiliser les technologies blockchain afin d'activer les transferts de fichiers 100 % anonymes. Surge est chiffré de bout en bout, décentralisé et open source. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/tinyrdm.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/tinyrdm.mdx new file mode 100644 index 00000000000..5390d57fbde --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/tinyrdm.mdx @@ -0,0 +1,11 @@ +# Tiny RDM + +```mdx-code-block +

                        + + +
                        +

                        +``` + +L'application [Tiny RDM](https://redis.tinycraft.cc/) est une interface Redis moderne et open-source. Il possède une interface utilisateur magnifique, une gestion de base de données Redis intuitive et compatible avec Windows, Mac et Linux. Il fournit des opérations visuelles de données de clé-valeur, supporte diverses options de décodage et de visualisation des données, possède une console intégrée pour exécuter des commandes, des requêtes de log lentes et plus encore. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/wailsterm.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/wailsterm.mdx new file mode 100644 index 00000000000..e7ae7d3ec19 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/wailsterm.mdx @@ -0,0 +1,10 @@ +# WailsTerm + +```mdx-code-block +

                        + +
                        +

                        +``` + +[WailsTerm](https://github.com/rlshukhov/wailsterm) est une simple application de terminal translucide propulsée par Wails et Xterm.js. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/wally.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/wally.mdx new file mode 100644 index 00000000000..ba2a7fccc45 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/wally.mdx @@ -0,0 +1,10 @@ +# Wally + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Wally](https://ergodox-ez.com/pages/wally) est le flasheur officiel du firmware pour les claviers [Ergodox](https://ergodox-ez.com/). C'est un excellent exemple de ce que vous pouvez réaliser avec Wails : la capacité de combiner la puissance de Go et les riches outils graphiques du monde du développement web. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/warmine.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/warmine.mdx new file mode 100644 index 00000000000..2e427433069 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/warmine.mdx @@ -0,0 +1,19 @@ +# Lanceur Minecraft pour WarMine + +```mdx-code-block +

                        + + +
                        +

                        +``` + +[Lanceur Minecraft pour WarMine](https://warmine.ru/) est une application Wails qui vous permet facilement de rejoindre le serveur de jeu contenant les mods, ainsi que la gestion de vos comptes de jeu. + +Le Launcher télécharge les fichiers du jeu, vérifie leur intégrité et lance le jeu avec une large gamme d'options de personnalisation. + +Le frontend est écrit en Svelte, le lanceur entier tient dans 9Mo et prend en charge Windows 7-11. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/wombat.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/wombat.mdx new file mode 100644 index 00000000000..c431f691952 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/wombat.mdx @@ -0,0 +1,10 @@ +# Wombat + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Wombat](https://github.com/rogchap/wombat) est un client gRPC multi-plateforme. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/ytd.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/ytd.mdx new file mode 100644 index 00000000000..4f5bd993cb1 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/showcase/ytd.mdx @@ -0,0 +1,10 @@ +# Ytd + +```mdx-code-block +

                        + +
                        +

                        +``` + +[Ytd](https://github.com/marcio199226/ytd/tree/v2-wails) est une application pour télécharger des pistes depuis youtube, créer des listes de lecture hors ligne et les partager avec vos amis, vos amis seront en mesure de lire vos playlists ou de les télécharger pour l'écoute hors ligne, a un lecteur intégré. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/templates.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/templates.mdx new file mode 100644 index 00000000000..49a3c7684e4 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/community/templates.mdx @@ -0,0 +1,76 @@ +--- +sidebar_position: 1 +--- + +# Modèles + +Cette page sert de liste pour les modèles supportés par la communauté. Veuillez soumettre une PR (cliquez sur `Modifier cette page` en bas) pour inclure vos modèles. Pour construire votre propre modèle, veuillez consulter le guide [Modèles](../guides/templates.mdx). + +Pour utiliser ces modèles, exécutez `wails init -n "Votre nom de projet" -t [le lien ci-dessous[@version]]` + +S'il n'y a pas de suffixe de version, la branche principale du modèle de code sera alors utilisé par défaut. S'il y a un suffixe de version, le modèle de code correspondant au tag de cette version sera utilisé. + +Exemple : `wails init -n "Votre nom de projet" -t https://github.com/misitebao/wails-template-vue` + +:::warning Attention + +**Le projet Wails n'entretient pas, et n'est pas responsable des modèles de tierces parties!** + +Si vous n'êtes pas sûr d'un modèle, inspectez `package.json` et `wails.json` pour savoir quels scripts sont exécutés et quels paquets sont installés. + +::: + +## Vue + +- [wails-template-vue](https://github.com/misitebao/wails-template-vue) - Modèle de Wails basé sur Vue (TypeScript intégré, thème sombre, internationalisation, routage de page unique, TailwindCSS) +- [wails-template-quasar-js](https://github.com/sgosiaco/wails-template-quasar-js) - Un modèle utilisant JavaScript + Quasar V2 (Vue 3, Vite, Sass, Pinia, ESLint, Prettier) +- [wails-template-quasar-ts](https://github.com/sgosiaco/wails-template-quasar-ts) - Un modèle utilisant TypeScript + Quasar V2 (Vue 3, Vite, Sass, Pinia, ESLint, Prettier, Composition API avec <script setup>) +- [wails-template-naive](https://github.com/tk103331/wails-template-naive) - Modèle Wails basé sur Naive UI (Librairie de composants Vue 3) +- [wails-template-tdesign-js](https://github.com/tongque0/wails-template-tdesign-js) - Modèle Wails basé sur TDesign UI (une librairie Vue 3 UI de Tencent), utilisant Vite, Pinia, Vue Router, ESLint, et Prettier. + +## Angular + +- [wails-template-angular](https://github.com/mateothegreat/wails-template-angular) - Modèle Angular 15+ prêt à être utilisé en production. +- [wails-angular-template](https://github.com/TAINCER/wails-angular-template) - Angular avec TypeScript, Sass, rechargement à chaud, découpage dynamique de code et i18n + +## React + +- [wails-react-template](https://github.com/AlienRecall/wails-react-template) - Un modèle utilisant reactjs +- [wails-react-template](https://github.com/flin7/wails-react-template) - Un modèle minimal pour React qui supporte le développement en direct +- [wails-template-nextjs](https://github.com/LGiki/wails-template-nextjs) - Un modèle utilisant Next.js et TypeScript +- [wails-template-nextjs-app-router](https://github.com/thisisvk-in/wails-template-nextjs-app-router) - Un modèle utilisant Next.js et TypeScript avec un routeur +- [wails-vite-react-ts-tailwind-template](https://github.com/hotafrika/wails-vite-react-ts-tailwind-template) - Un modèle pour React + TypeScript + Vite + TailwindCSS +- [wails-vite-react-ts-tailwind-shadcnui-template](https://github.com/Mahcks/wails-vite-react-tailwind-shadcnui-ts) - Un modèle avec Vite, React, TypeScript, TailwindCSS, et shadcn/ui +- [wails-nextjs-tailwind-template](https://github.com/kairo913/wails-nextjs-tailwind-template) - Un modèle utilisant Next.js et Typescript avec TailwindCSS + +## Svelte + +- [wails-svelte-template](https://github.com/raitonoberu/wails-svelte-template) - Un modèle utilisant Svelte +- [wails-vite-svelte-template](https://github.com/BillBuilt/wails-vite-svelte-template) - Un modèle utilisant Svelte et Vite +- [wails-vite-svelte-ts-tailwind-template](https://github.com/xvertile/wails-vite-svelte-tailwind-template) - Un modèle utilisant Wails, Svelte, Vite, TypeScript et TailwindCSS v3 +- [wails-vite-svelte-tailwind-template](https://github.com/BillBuilt/wails-vite-svelte-tailwind-template) - Un modèle utilisant Svelte et Vite avec TailwindCSS v3 +- [wails-svelte-tailwind-vite-template](https://github.com/PylotLight/wails-vite-svelte-tailwind-template/tree/master) - Un modèle mis à jour en utilisant Svelte v4.2.0 et Vite avec TailwindCSS v3.3.3 +- [wails-sveltekit-template](https://github.com/h8gi/wails-sveltekit-template) - Un modèle utilisant SvelteKit + +## Solid + +- [wails-template-vite-solid-ts](https://github.com/xijaja/wails-template-solid-ts) - Un modèle utilisant Solid + Ts + Vite +- [wails-template-vite-solid-ts](https://github.com/xijaja/wails-template-solid-js) - Un modèle utilisant Solid + Js + Vite + +## Elm + +- [wails-elm-template](https://github.com/benjamin-thomas/wails-elm-template) - Développez votre application GUI avec de la programmation fonctionnelle et une configuration de développement en direct :tada: :rocket: +- [wails-template-elm-tailwind](https://github.com/rnice01/wails-template-elm-tailwind) - Combine les puissances :muscle: d'Elm + Tailwind CSS + Wails ! Rechargement automatique pris en charge. + +## HTMX + +- [wails-htmx-templ-chi-tailwind](https://github.com/PylotLight/wails-hmtx-templ-template) - Utilisez une combinaison unique de htmx pour interactivité, et de templ pour créer des composants et des formes + +## Pure JavaScript (Vanilla) + +- [wails-pure-js-template](https://github.com/KiddoV/wails-pure-js-template) - Un modèle avec rien que du JavaScript, du HTML et du CSS de base + + +## Lit (Composants web) + +- [wails-lit-shoelace-esbuild-template](https://github.com/Braincompiler/wails-lit-shoelace-esbuild-template) - Modèle Wails fournissant une interface avec lit, une bibliothèque de composants Shoelace, ainsi que prettier et typescript préconfigurés. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/building.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/building.mdx new file mode 100644 index 00000000000..4de31450bc2 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/building.mdx @@ -0,0 +1,26 @@ +--- +sidebar_position: 6 +--- + +# Compiler votre projet + +À partir du répertoire du projet, exécutez `wails build`. Cela compilera votre projet et sauvegardera le binaire prêt à la production dans le répertoire `build/bin`. + +:::info Linux +Si vous utilisez une distribution Linux qui n'a pas webkit2gtk-4. (comme Ubuntu 24.04), vous devrez ajouter `-tags webkit2_41`. +::: + +Si vous exécutez le binaire, vous devriez voir l'application par défaut : + +```mdx-code-block +
                        + +
                        +
                        +``` + +Pour plus de détails sur les options de compilation, veuillez vous référer à la [documentation du CLI](../reference/cli.mdx#build). diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/development.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/development.mdx new file mode 100644 index 00000000000..307029141d4 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/development.mdx @@ -0,0 +1,16 @@ +--- +sidebar_position: 5 +--- + +# Développez votre application + +Vous pouvez exécuter votre application en mode développement en exécutant `wails dev` à partir du répertoire de votre projet. Cela fera les choses suivantes : + +- Construire votre application et l'exécuter +- Lier votre code Go au frontend pour qu'il puisse être appelé à partir de JavaScript +- En utilisant la puissance de [Vite](https://vitejs.dev/), surveillera les modifications dans vos fichiers Go et reconstruira / ré-exécutera en cas de changement +- Mettra en place un [serveur web](http://localhost:34115) qui servira votre application via un navigateur. Cela vous permet d'utiliser les extensions de votre navigateur préféré. Vous pouvez même appeler votre code Go depuis la console + +Pour commencer, exécutez `wails dev` dans le répertoire du projet. Plus d'informations à ce sujet peuvent être trouvées [ici](../reference/cli.mdx#dev). + +Prochainement : Tutoriel diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/firstproject.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/firstproject.mdx new file mode 100644 index 00000000000..02e9f955b98 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/firstproject.mdx @@ -0,0 +1,128 @@ +--- +sidebar_position: 2 +--- + +# Créer un projet + +## Génération de projet + +Maintenant que le CLI est installé, vous pouvez générer un nouveau projet en utilisant la commande `wails init`. + +Choisissez votre framework favori : + +```mdx-code-block +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + + + + Générer un projet Svelte utilisant JavaScript avec:

                        + + wails init -n myproject -t svelte + +Si vous préférez utiliser TypeScript:
                        + + wails init -n myproject -t svelte-ts + +
                        + + Générer un projet React utilisant JavaScript avec :

                        + + wails init -n myproject -t react + +Si vous préférez utiliser TypeScript:
                        + + wails init -n myproject -t react-ts + +
                        + + Générer un projet Vue utilisant JavaScript avec:

                        + + wails init -n myproject -t vue + +Si vous préférez TypeScript:
                        + + wails init -n myproject -t vue-ts + +
                        + + Générer un projet Preact utilisant JavaScript avec:

                        + + wails init -n myproject -t preact + +Si vous préférez TypeScript:
                        + + wails init -n myproject -t preact-ts + +
                        + + Générer un projet Lit utilisant JavaScript avec:

                        + + wails init -n myproject -t lit + +Si vous préférez TypeScript:
                        + + wails init -n myproject -t lit-ts + +
                        + + Générer un projet Vanilla utilisant JavaScript avec :

                        + + wails init -n myproject -t vanilla + +Si vous préférez TypeScript:
                        + + wails init -n myproject -t vanilla-ts + +
                        +
                        +``` + +
                        + +Il y a aussi [des modèles créés par la communauté](../community/templates.mdx) qui sont disponibles et qui offrent différentes possibilités. + +Pour voir les autres options disponibles, vous pouvez exécuter `wails init -help`. Plus de détails peuvent être trouvés dans la [documentation du CLI](../reference/cli.mdx#init). + +## Structure du projet + +Les projets Wails ont la structure suivante: + +``` +. +├── build/ +│ ├── appicon.png +│ ├── darwin/ +│ └── windows/ +├── frontend/ +├── go.mod +├── go.sum +├── main.go +└── wails.json +``` + +### Récapitulatif de la structure du projet + +- `/main.go` - L'application principale +- `/frontend/` - Fichiers de la partie frontend +- `/build/` - Répertoire de construction du projet +- `/build/appicon.png` - L'icône de l'application +- `/build/darwin/` - Fichiers spécifiques pour Mac +- `/build/windows/` - Fichiers spécifiques pour Windows +- `/wails.json` - La configuration du projet +- `/go.mod` - Le fichier du module Go +- `/go.sum` - Le checksum du fichier du module Go + +Le répertoire `frontend` n'a rien de spécifique à Wails et n'importe quel outil de frontend peut être utilisé. + +Le répertoire `build` est utilisé pendant le processus de compilation. Ces fichiers peuvent être mis à jour pour personnaliser vos builds. Si fichiers sont supprimés du répertoire de compilation, les versions par défaut seront régénérées. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/installation.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/installation.mdx new file mode 100644 index 00000000000..1420ffcbe40 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/gettingstarted/installation.mdx @@ -0,0 +1,92 @@ +--- +sidebar_position: 1 +--- + +# Installation + +## Plates-formes Prises en charge + +- Windows 10/11 AMD64/ARM64 +- MacOS 10.15+ AMD64 pour le développement, MacOS 10.13+ pour la publication +- MacOS 11.0+ ARM64 +- Linux AMD64/ARM64 + +## Dépendances + +Wails a un certain nombre de dépendances communes qui sont nécessaires avant l'installation : + +- Go 1.21+ (macOS 15+ requiert Go 1.23.3+) +- NPM (Node 15+) + +### Go + +Télécharger Go à partir de la [Page de téléchargement](https://go.dev/dl/). + +Assurez-vous que vous suivez les instructions officielles de [l'installation de Go](https://go.dev/doc/install). Vous devrez également vous assurer que votre variable d'environnement `PATH` inclut également le chemin vers votre répertoire `~/go/bin`. Redémarrez votre terminal et effectuez les vérifications suivantes : + +- Vérifiez que Go est installé correctement : `go version` +- Vérifiez que "~/go/bin" est dans votre variable PATH : `echo $PATH | grep go/bin` + +### NPM + +Téléchargez le NPM à partir de la [page de téléchargement de Node](https://nodejs.org/en/download/). Il est préférable d'utiliser la dernière version car c'est avec celle-là que nous effectuons nos tests. + +Exécutez `npm --version` pour vérifier. + +## Dépendances spécifiques aux plateformes + +Vous devrez également installer des dépendances spécifiques liés à la plateforme que vous utilisez : + +```mdx-code-block +import Tabs from "@theme/Tabs"; +import TabItem from "@theme/TabItem"; + + + + Wails a besoin que les outils de command line xocde soient installés. Cela peut être fait + en exécutant xcode-select --install. + + + Wails a besoin que WebView2 runtime soit installé. Certaines installations de Windows auront déjà installé cette fonctionnalité. Vous pouvez vérifier en utilisant la commande wails doctor. + + + Linux a besoin de gcc comme outil de compilation en plus de libgtk3 et libwebkit. Plutôt que de lister une tonne de commandes pour différentes distributions, Wails peut essayer de déterminer ce que sont les commandes d'installation pour votre distribution. Exécutez wails doctor après l'installation pour voir de quelles dépendances vous avez besoin. Si votre gestionnaire de distribution/paquet n'est pas pris en charge, veuillez consulter le guide Ajouter une distribution Linux. +
                        Note :
                        + Si vous utilisez la dernière version de Linux (exemple : Ubuntu 24. 4) et qu'il ne supporte pas libwebkit2gtk-4. -dev, alors vous pourriez rencontrer un problème dans le wails doctor: libwebkit introuvable. Pour résoudre ce problème, vous pouvez installer libwebkit2gtk-4.1-dev et pendant votre compilation, utilisez le tag -tags webkit2_41. +
                        +
                        +``` + +## Dépendances optionnelles + +- [UPX](https://upx.github.io/) pour compresser vos applications. +- [NSIS](https://wails.io/docs/guides/windows-installer/) pour générer des installateurs Windows. + +## Installer Wails + +Exécutez `go go install github.com/wailsapp/wails/v2/cmd/wails@latest` pour installer le CLI. + +Note: Si vous obtenez une erreur similaire à ceci: + +```shell +....\Go\pkg\mod\github.com\wailsapp\wails\v2@v2.1.0\pkg\templates\templates.go:28:12: pattern all:ides/*: no matching files found +``` +vérifiez que vous avez installé Go 1.18+ : +```shell +go version +``` + +## Vérification du système + +Exécuter `wails doctor` qui vérifiera si vous avez les bonnes dépendances installées. Si ce n'est pas le cas, il vous conseillera sur ce qui manque et vous aidera à corriger tout problème. + +## La commande `wails` semble manquer ? + +Si votre système signale que la commande `wails` est manquante, assurez-vous que vous avez suivi le guide d'installation correctement. Normalement, cela signifie que le répertoire `go/bin` du répertoire racine de votre utilisateur n'est pas dans la variable d'environnement `PATH` . Vous devrez également normalement fermer et réouvrir toutes les commandes ouvertes afin que les modifications apportées à l'environnement par l'installateur soient reflétées dans l'invite de commande. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/angular.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/angular.mdx new file mode 100644 index 00000000000..1fe2f199ffe --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/angular.mdx @@ -0,0 +1,14 @@ +# Angular + +Bien que Wails n'ait pas de modèle Angular, il est possible d'utiliser Angular avec Wails. + +## Dev Mode + +Pour que le mode développeur fonctionne avec Angular, vous devez ajouter ce qui suit à votre fichier `wails.json`: + +```json + "frontend:build": "npx ng build", + "frontend:install": "npm install", + "frontend:dev:watcher": "npx ng serve", + "frontend:dev:serverUrl": "http://localhost:4200", +``` \ No newline at end of file diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/application-development.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/application-development.mdx new file mode 100644 index 00000000000..a3418349426 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/application-development.mdx @@ -0,0 +1,273 @@ +# Développement d'applications + +Il n'y a pas de règles gravées dans le marbre pour le développement d'applications avec Wails, mais il y a quelques lignes directrices de base. + +## Configuration de l'application + +Le modèle utilisé par défaut défini que `main.go` est utilisé pour configurer et démarrer l'application, tandis que `app.go` est utilisé pour définir la logique de l'application. + +Le fichier `app.go` va définir une structure qui a 2 méthodes qui agissent comme crochets dans l'application principale: + +```go title="app.go" +type App struct { + ctx context.Context +} + +func NewApp() *App { + return &App{} +} + +func (a *App) startup(ctx context.Context) { + a.ctx = ctx +} + +func (a *App) shutdown(ctx context.Context) { +} +``` + +- La méthode startup est appelée d-s que Wails a donné les ressources nécessaires et qu'il est dans un bon état pour créer les ressources, mettre en place les event listeners et tout ce dont l'application peut avoir besoin pour démarrer. Il est donné un `context.Context` qui est généralement sauvegardé dans un champ struct. Ce contexte est nécessaire pour appeler le [runtime](../reference/runtime/intro.mdx). Si cette méthode renvoie une erreur, l'application se fermera. En mode développement, l'erreur sera affichée dans la console. + +- La méthode d'arrêt sera appelée par Wails à la fin du processus d'arrêt. C'est un bon endroit pour vider la mémoire et effectuer toutes les tâches d'arrêt. + +Le fichier `main.go` consiste généralement en un seul appel à `wails.Run()`, qui accepte la configuration de l'application. Le modèle utilisé par les templates fait qu'avant l'appel à `wails.Run()`, une instance du struct que l'on a définie dans `app.go` est créée et instanciée dans une variable appelée `app`. Cette configuration est l'endroit où nous ajoutons nos callbacks : + +```go {3,9,10} title="main.go" +func main() { + + app := NewApp() + + err := wails.Run(&options.App{ + Title: "My App", + Width: 800, + Height: 600, + OnStartup: app.startup, + OnShutdown: app.shutdown, + }) + if err != nil { + log.Fatal(err) + } +} + +``` + +Plus d'informations sur les crochets du cycle de vie des applications peuvent être trouvées [ici](../howdoesitwork.mdx#application-lifecycle-callbacks). + +## Méthodes de liaison + +Il est probable que vous vouliez appeler les méthodes Go depuis le frontend. Cela se fait normalement en ajoutant des méthodes publiques à le struct déjà défini dans `app.go`: + +```go {16-18} title="app.go" +type App struct { + ctx context.Context +} + +func NewApp() *App { + return &App{} +} + +func (a *App) startup(ctx context.Context) { + a.ctx = ctx +} + +func (a *App) shutdown(ctx context.Context) { +} + +func (a *App) Greet(name string) string { + return fmt.Sprintf("Hello %s!", name) +} +``` + +Dans la configuration principale de l'application, le paramètre `Bind` est l'endroit où nous pouvons dire à Wails ce que nous voulons lier : + +```go {11-13} title="main.go" +func main() { + + app := NewApp() + + err := wails.Run(&options.App{ + Title: "My App", + Width: 800, + Height: 600, + OnStartup: app.startup, + OnShutdown: app.shutdown, + Bind: []interface{}{ + app, + }, + }) + if err != nil { + log.Fatal(err) + } +} + +``` + +Cela liera toutes les méthodes publiques de notre structure `App` (cela ne liera jamais les méthodes de démarrage et d'arrêt du système). + +### Traiter avec le contexte lors de la liaison de plusieurs structures + +Si vous voulez lier des méthodes pour des structures multiples, mais que vous voulez que chaque struct conserve une référence au contexte pour que vous puissiez utiliser les fonctions d'exécution... Un bon choix est de passer le contexte de la méthode `OnStartup` à vos instances struct : + +```go +func main() { + + app := NewApp() + otherStruct := NewOtherStruct() + + err := wails.Run(&options.App{ + Title: "My App", + Width: 800, + Height: 600, + OnStartup: func(ctx context.Context){ + app.SetContext(ctx) + otherStruct.SetContext(ctx) + }, + OnShutdown: app.shutdown, + Bind: []interface{}{ + app, + otherStruct + }, + }) + if err != nil { + log.Fatal(err) + } +} +``` + +Vous pouvez également utiliser des énums dans vos structures et avoir des modèles pour elles dans le frontend. Dans ce cas, vous devriez créer un tableau qui contiendra toutes les valeurs possibles de l'énumération, définir le type de l'énumération et lier le tout à l'application: + +```go {16-18} title="app.go" +type Weekday string + +const ( + Sunday Weekday = "Sunday" + Monday Weekday = "Monday" + Tuesday Weekday = "Tuesday" + Wednesday Weekday = "Wednesday" + Thursday Weekday = "Thursday" + Friday Weekday = "Friday" + Saturday Weekday = "Saturday" +) + +var AllWeekdays = []struct { + Value Weekday + TSName string +}{ + {Sunday, "SUNDAY"}, + {Monday, "MONDAY"}, + {Tuesday, "TUESDAY"}, + {Wednesday, "WEDNESDAY"}, + {Thursday, "THURSDAY"}, + {Friday, "FRIDAY"}, + {Saturday, "SATURDAY"}, +} +``` + +Dans la configuration principale de l'application, le paramètre `EnumBind` est l'endroit où nous pouvons dire à Wails ce que nous voulons lier : + +```go {11-13} title="main.go" +func main() { + + app := NewApp() + + err := wails.Run(&options.App{ + Title: "My App", + Width: 800, + Height: 600, + OnStartup: app.startup, + OnShutdown: app.shutdown, + Bind: []interface{}{ + app, + }, + EnumBind: []interface{}{ + AllWeekdays, + }, + }) + if err != nil { + log.Fatal(err) + } +} + +``` + +Ceci ajoutera des enums manquants à votre fichier `model.ts`. + +Plus d'informations à sur Binding peuvent être trouvées [ici](../howdoesitwork.mdx#method-binding). + +## Menu de l’application + +Wails prend en charge l'ajout d'un menu à votre application. Ceci est fait en passant un [Menu](../reference/menus.mdx#menu) structuré à la configuration de l'application. Il est courant d'utiliser une méthode qui renvoie un Menu, et encore plus courant pour que cela soit une méthode sur la struct de l'`app` qui soit utilisée pour les hooks du cycle de vie. + +```go {11} title="main.go" +func main() { + + app := NewApp() + + err := wails.Run(&options.App{ + Title: "My App", + Width: 800, + Height: 600, + OnStartup: app.startup, + OnShutdown: app.shutdown, + Menu: app.menu(), + Bind: []interface{}{ + app, + }, + }) + if err != nil { + log.Fatal(err) + } +} + +``` + +## Ressources + +La grande chose à propos de la façon dont Wails v2 gère les ressources pour le frontend, est que ce n'est pas le cas! La seule chose que vous devez donner à Wails est un `embed.FS`. C'est à vous de décider comment vous y arrivez. Vous pouvez utiliser les fichiers html/css/js vanilla comme dans le modèle vanilla. Vous pourriez avoir un système de compilation compliqué, peu importe. + +Quand la commande `wails dev` est exécutée, elle vérifiera le fichier de projet `wails.json` à la racine du projet. Il y a 2 clés dans le fichier du projet qui sont lues : + +- "frontend:install" +- "frontend:build" + +Le premier, si fourni, sera exécuté dans le répertoire `frontend` pour installer les modules. Le second, si fourni, sera exécuté dans le répertoire `frontend` pour construire le projet frontend. + +Si ces 2 clés ne sont pas fournies, alors Wails ne fait absolument rien avec le frontend. Il n'attend que `embed.FS`. + +### AssetsHandler + +Une application Wails v2 peut éventuellement définir un `http.Handler` dans `options.app`, qui permet de se connecter à l'AssetServer pour créer des fichiers à la volée ou traiter les requêtes POST/PUT. Les requêtes GET sont toujours traitées d'abord par le `assets` FS. Si le FS ne trouve pas le fichier demandé, la requête sera transmise au `http.Handler`. Toute requête autre que GET sera traitée directement par le `AssetsHandler` si spécifié. Il est également possible d'utiliser l'`AssetsHandler` uniquement en spécifiant `nil` dans l'option `Assets`. + +## Serveur de développement embarqué + +Exécuter `wails dev` démarrera le serveur de développement intégré qui démarrera un observateur de fichiers dans votre répertoire de projet. Par par défaut, si un fichier change, wails vérifie s'il s'agit d'un fichier d'application (par défaut: `.go`, configurable avec l'option `-e`). Si c'est le cas, il reconstruira votre application et la relancera. Si le fichier modifié se trouvait dans les actifs, il lancera un rechargement après un court laps de temps. + +Le serveur de développement utilise une technique appelée "debouncing", ce qui signifie qu'il ne se recharge pas tout de suite, comme il peut y avoir plusieurs fichiers modifiés en un court laps de temps. Lorsqu'un déclencheur se produit, il attend un temps défini avant d'émettre un rechargement. Si un autre déclencheur se produit, le temps d'attente se réinitialise avant un prochain rechargement. Par défaut, cette période est définie à `100ms`. Si cette valeur ne fonctionne pas pour votre projet, elle peut être configurée en utilisant l'option `-debounce`. Si elle est utilisée, cette valeur sera enregistrée dans la configuration de votre projet et deviendra la valeur par défaut. + +## Serveur de développement externe + +Certains frameworks sont fournis avec leur propre serveur de rechargement en direct, cependant ils ne seront pas en mesure de tirer parti des liaisons Wails Go. Dans ce scénario, il est préférable d'exécuter un script qui va surveiller le projet dans dossier build, dossier que Wails surveille aussi. Pour un exemple, voir le modèle svelte par défaut qui utilise [rollup](https://rollupjs.org/guide/en/). + +### Créer une application React + +Le processus pour créer un projet Reactest un peu plus compliqué. Afin de prendre en charge le rechargement du frontend en direct, la configuration suivante doit être ajoutée à votre `wails.json`: + +```json + "frontend:dev:watcher": "yarn start", + "frontend:dev:serverUrl": "http://localhost:3000", +``` + +La commande `frontend:dev:watcher` démarrera le serveur de développement React (hébergé sur le port `3000` typiquement). La commande `frontend:dev:serverUrl` demande ensuite à Wails d'exposer les ressources depuis le serveur de développement lors du chargement du frontend, plutôt que depuis le dossier de construction. En plus de ce qui précède, le fichier `index.html` doit être mis à jour avec les éléments suivants : + +```html + + + + + +``` + +Ceci est nécessaire, car la commande watcher qui reconstruit le frontend empêche Wails de les injecter. Ça contourne le problème en assurant les scripts sont toujours injectés. Avec cette configuration, `wails dev` peut être exécuté, ce qui construira le frontend et le backend de manière appropriée avec le rechargement à chaud activé. De plus, lorsque vous accédez à l'application à partir d'un navigateur, les outils de développement de React peuvent maintenant être utilisés sur une version non minifiée de l'application pour le débogage. Enfin, pour des compilations plus rapides, `wails dev -s` peut être exécuté pour passer la construction par défaut du frontend par Wails car c'est une étape inutile. + +## Module Go + +Les modèles Wails par défaut génèrent un fichier `go.mod` qui contient le nom de module "changeme". Vous devriez changer ceci pour quelque chose de plus approprié après la génération du projet. diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/crossplatform-build.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/crossplatform-build.mdx new file mode 100644 index 00000000000..d933270205c --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/crossplatform-build.mdx @@ -0,0 +1,66 @@ +# Construction cross-plateforme avec Github Actions + +Pour construire un projet Wails pour toutes les plateformes disponibles, vous devez créer un build de l'application pour chaque système d'exploitation. Une méthode efficace pour y parvenir est d'utiliser GitHub Actions. + +Une action qui facilite la création d'une application Wails est disponible sur : +https://github.com/dAppServer/wails-build-action + +Dans le cas où l'action existante ne répond pas à vos exigences, vous ne pouvez sélectionner que les étapes nécessaires à partir de la source : +https://github.com/dAppServer/wails-build-action/blob/main/action.yml + +Voici un exemple complet qui démontre la construction d'une application lors de la création d'une nouvelle balise Git et qui la téléversera ensuite sur les artefacts Actions : + +```yaml +name: Wails build + +on: + push: + tags: + # Matche n'importe quel nouveau tag + - '*' + +env: + # Nécessaire pour la plupart des environnement, car des soucis de build peuvent arriver à cause de soucis de mémoire + NODE_OPTIONS: "--max-old-space-size=4096" + +jobs: + build: + strategy: + # Afin d'éviter que l'échec du build d'une plateforme n'impacte les autres + fail-fast: false + matrix: + build: + - name: 'App' + platform: 'linux/amd64' + os: 'ubuntu-latest' + - name: 'App' + platform: 'windows/amd64' + os: 'windows-latest' + - name: 'App' + platform: 'darwin/universal' + os: 'macos-latest' + + runs-on: ${{ matrix.build.os }} + steps: + - name: Checkout + uses: actions/checkout@v2 + with: + submodules: recursive + + - name: Build wails + uses: dAppServer/wails-build-action@v2.2 + id: build + with: + build-name: ${{ matrix.build.name }} + build-platform: ${{ matrix.build.platform }} + package: false + go-version: '1.20' +``` + +Cet exemple offre des opportunités pour diverses améliorations, comprenant : + +- Mise en cache des dépendances +- Signature de code +- Envoi vers des plateformes comme S3, Supabase, etc. +- Injection de secrets en tant que variables d'environnement +- Utiliser des variables d'environnement comme variables de compilation (telles que la variable de version extraite de la balise Git actuelle) diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/custom-protocol-schemes.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/custom-protocol-schemes.mdx new file mode 100644 index 00000000000..bc44dcc4d02 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/custom-protocol-schemes.mdx @@ -0,0 +1,203 @@ +# Association de schéma de protocole personnalisé + +La fonction d'association de fichiers vous permet d'associer des types de fichiers spécifiques à votre application afin que lorsque les utilisateurs ouvrent ces fichiers, +votre application est lancée pour les gérer. Cela peut être particulièrement utile pour connecter votre application de bureau à votre application web. +Dans ce guide, nous allons parcourir les étapes pour implémenter l'association de fichiers dans l'application Wails. + +## Configurer une association de schémas de protocoles personnalisés : + +Pour configurer l'association de fichiers, vous devez modifier le fichier wails.json de votre application. +Dans la section "info", ajoutez une section "fileAssociations" spécifiant les types de fichiers auxquels votre application doit être associée. + +Par exemple : + +```json +{ + "info": { + "protocols": [ + { + "scheme": "myapp", + "description": "My App Protocol", + "role": "Editor" + } + ] + } +} +``` + +| Propriété | Description | +| :----------- | :------------------------------------------------------------------------------------------------ | +| scheme | Le schéma de protocole personnalisé. ex: myapp | +| description | Windows seulement. La description. | +| role | macOS uniquement. Rôle de l'application par rapport au type. Correspond au rôle CFBundleTypeRole. | + +## Spécificités par platefome : + +### MacOS + +Lorsque vous ouvrez un fichier (ou des fichiers) avec votre application, le système lancera votre application et appellera la fonction `OnFileOpen` dans votre application Wails. Exemple: + +```go title="main.go" +func main() { + // Create application with options + err := wails.Run(&options.App{ + Title: "wails-open-file", + Width: 1024, + Height: 768, + AssetServer: &assetserver.Options{ + Assets: assets, + }, + BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1}, + Mac: &mac.Options{ + OnUrlOpen: func(url string) { println(url) }, + }, + Bind: []interface{}{ + app, + }, + }) + + if err != nil { + println("Error:", err.Error()) + } +} +``` + +### Windows + +L'association de fichiers dans Windows n'est prise en charge qu'avec l'installateur NSIS. Pendant l'installation, l'installateur créera une entrée de registre +pour vos associations de fichiers. Lorsque vous ouvrez un fichier avec votre application, une nouvelle instance d'application est lancée et le chemin d'accès est passé à +comme argument à votre application. Pour gérer cela, vous devez analyser les arguments de la ligne de commande dans votre application. Exemple: + +```go title="main.go" +func main() { + argsWithoutProg := os.Args[1:] + + if len(argsWithoutProg) != 0 { + println("launchArgs", argsWithoutProg) + } +} +``` + +Vous pouvez également activer le verrouillage par instance unique pour votre application. Dans ce cas, lorsque vous ouvrez un fichier avec votre application, la nouvelle instance d'application n'est pas lancée +et les arguments sont passés à l'instance déjà en cours d'exécution. Consultez le guide de verrouillage de l'instance unique pour plus de détails. Exemple: + +```go title="main.go" +func main() { + // Create application with options + err := wails.Run(&options.App{ + Title: "wails-open-file", + Width: 1024, + Height: 768, + AssetServer: &assetserver.Options{ + Assets: assets, + }, + BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1}, + SingleInstanceLock: &options.SingleInstanceLock{ + UniqueId: "e3984e08-28dc-4e3d-b70a-45e961589cdc", + OnSecondInstanceLaunch: app.onSecondInstanceLaunch, + }, + Bind: []interface{}{ + app, + }, + }) +} +``` + +### Linux + +Actuellement, Wails ne prend pas en charge l'association de fichiers pour Linux. Vous devez donc créer des associations de fichiers manuellement. +Par exemple, si vous distribuez votre application en tant que package .deb, vous pouvez créer des associations de fichiers en ajoutant les fichiers requis dans votre bundle. +Vous pouvez utiliser [nfpm](https://nfpm.goreleaser.com/) pour créer un package .deb pour votre application. + +1. Créez un fichier .desktop pour votre application et spécifiez des associations de fichiers là-bas (notez que `%u` est important dans Executive). Exemple: + +```ini +[Desktop Entry] +Categories=Office +Exec=/usr/bin/wails-open-file %u +Icon=wails-open-file.png +Name=wails-open-file +Terminal=false +Type=Application +MimeType=x-scheme-handler/myapp; +``` + +2. Préparez les scripts postInstall/postRemove pour votre paquet. Exemple: + +```sh +# recharger la base de données du bureau pour charger l'application dans la liste des applications disponibles +update-desktop-database /usr/share/applications +``` + +3. Configurez nfpm pour utiliser vos scripts et fichiers. Exemple: + +```yaml +name: "wails-open-file" +arch: "arm64" +platform: "linux" +version: "1.0.0" +section: "default" +priority: "extra" +maintainer: "FooBarCorp " +description: "Sample Package" +vendor: "FooBarCorp" +homepage: "http://example.com" +license: "MIT" +contents: +- src: ../bin/wails-open-file + dst: /usr/bin/wails-open-file +- src: ./main.desktop + dst: /usr/share/applications/wails-open-file.desktop +- src: ../appicon.svg + dst: /usr/share/icons/hicolor/scalable/apps/wails-open-file.svg +# copy icons to Yaru theme as well. For some reason Ubuntu didn't pick up fileicons from hicolor theme +- src: ../appicon.svg + dst: /usr/share/icons/Yaru/scalable/apps/wails-open-file.svg +scripts: + postinstall: ./postInstall.sh + postremove: ./postRemove.sh +``` + +6. Construisez votre paquet .deb en utilisant nfpm: + +```sh +nfpm pkg --packager deb --target . +``` + +7. Maintenant que votre paquet est installé, votre application sera associée aux types de fichiers qui ont été spécifiés. Lorsque vous ouvrez un fichier avec votre application, une nouvelle instance est lancée et le chemin du fichier est passé en argument à votre application. + Pour gérer cela, vous devez analyser les arguments de la ligne de commande dans votre application. Exemple: + +```go title="main.go" +func main() { + argsWithoutProg := os.Args[1:] + + if len(argsWithoutProg) != 0 { + println("launchArgs", argsWithoutProg) + } +} +``` + +Vous pouvez également activer le verrouillage par instance unique pour votre application. Dans ce cas, lorsque vous ouvrez un fichier avec votre application, la nouvelle instance d'application n'est pas lancée +et les arguments sont passés à l'instance déjà en cours d'exécution. Consultez le guide de verrouillage de l'instance unique pour plus de détails. Exemple: + +```go title="main.go" +func main() { + // Create application with options + err := wails.Run(&options.App{ + Title: "wails-open-file", + Width: 1024, + Height: 768, + AssetServer: &assetserver.Options{ + Assets: assets, + }, + BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1}, + SingleInstanceLock: &options.SingleInstanceLock{ + UniqueId: "e3984e08-28dc-4e3d-b70a-45e961589cdc", + OnSecondInstanceLaunch: app.onSecondInstanceLaunch, + }, + Bind: []interface{}{ + app, + }, + }) +} +``` diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/dynamic-assets.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/dynamic-assets.mdx new file mode 100644 index 00000000000..f1098b09cb0 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/dynamic-assets.mdx @@ -0,0 +1,142 @@ +# Ressources dynamiques + +:::info + +Cela ne fonctionne pas avec la v5.0.0+ vite et wails v2 en raison des changements dans vite. Des changements sont prévus dans la v3 pour prendre en charge des fonctionnalités similaires sous la v5.0.0+. Si vous avez besoin de cette fonctionnalité, restez avec la v4.0.0+. Regardez l'[issue 3240](https://github.com/wailsapp/wails/issues/3240) pour les détails + +::: + +Si vous voulez charger ou générer des ressources pour votre frontend de manière dynamique, vous pouvez y parvenir en utilisant l'option [AssetsHandler](../reference/options#assetshandler). Le AssetsHandler est un générique`http.Handler` qui sera appelé pour toute requête non GET sur le serveur d'assets et pour les requêtes GET qui ne peuvent pas être servies car l'asset n'est pas trouvé. + +En installant un AssetsHandler personnalisé, vous pouvez servir vos propres ressources en utilisant un serveur de ressources personnalisé. + +## Exemple + +Dans notre exemple de projet, nous allons créer un gestionnaire de ressources simple qui chargera les fichiers à partir du disque: + +```go title=main.go {17-36,49} +package main + +import ( + "embed" + "fmt" + "github.com/wailsapp/wails/v2" + "github.com/wailsapp/wails/v2/pkg/options" + "github.com/wailsapp/wails/v2/pkg/options/assetserver" + "net/http" + "os" + "strings" +) + +//go:embed all:frontend/dist +var assets embed.FS + +type FileLoader struct { + http.Handler +} + +func NewFileLoader() *FileLoader { + return &FileLoader{} +} + +func (h *FileLoader) ServeHTTP(res http.ResponseWriter, req *http.Request) { + var err error + requestedFilename := strings.TrimPrefix(req.URL.Path, "/") + println("Requesting file:", requestedFilename) + fileData, err := os.ReadFile(requestedFilename) + if err != nil { + res.WriteHeader(http.StatusBadRequest) + res.Write([]byte(fmt.Sprintf("Could not load file %s", requestedFilename))) + } + + res.Write(fileData) +} + +func main() { + // Create an instance of the app structure + app := NewApp() + + // Create application with options + err := wails.Run(&options.App{ + Title: "helloworld", + Width: 1024, + Height: 768, + AssetServer: &assetserver.Options{ + Assets: assets, + Handler: NewFileLoader(), + }, + BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 255}, + OnStartup: app.startup, + Bind: []interface{}{ + app, + }, + }) + + if err != nil { + println("Error:", err) + } +} +``` + +Lorsque nous exécutons l'application en mode dev en utilisant `wails dev`, nous verrons la sortie suivante : + +``` +DEB | [ExternalAssetHandler] Loading 'http://localhost:3001/favicon.ico' +DEB | [ExternalAssetHandler] Loading 'http://localhost:3001/favicon.ico' failed, using AssetHandler +Requesting file: favicon.ico +``` + +Comme vous pouvez le voir, le gestionnaire d'actifs est appelé lorsque le serveur d'assets par défaut est incapable de servir le fichier `favicon.ico`. + +Si vous faites un clic droit sur l'application principale et sélectionnez "inspecter" pour afficher les devtools, vous pouvez tester cette fonctionnalité en tapant ce qui suit dans la console : + +``` +let response = await fetch('does-not-exist.txt'); +``` + +Cela générera une erreur dans les devtools. Nous pouvons voir que l'erreur est ce que nous attendons est retourné par notre gestionnaire de ressources personnalisées : + +```mdx-code-block +

                        + +

                        +``` + +Cependant, si nous demandons `go.mod`, nous verrons la sortie suivante : + +```mdx-code-block +

                        + +

                        +``` + +Cette technique peut être utilisée pour charger des images directement dans la page. Si nous avons mis à jour notre modèle vanilla par défaut et a remplacé l'image du logo : + +```html + +``` + +avec : + +```html + +``` + +Nous verrions ensuite ce qui suit: + +```mdx-code-block +

                        + +

                        +``` + +:::warning + +Exposer votre système de fichiers de cette manière est un risque de sécurité. Il est recommandé de gérer correctement l'accès à votre système de fichiers. + +::: diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/file-association.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/file-association.mdx new file mode 100644 index 00000000000..973a4d21758 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/file-association.mdx @@ -0,0 +1,243 @@ +# Associations de fichiers + +La fonction d'association de fichiers vous permet d'associer des types de fichiers spécifiques à votre application afin que lorsque les utilisateurs ouvrent ces fichiers, +votre application est lancée pour les gérer. Cela peut être particulièrement utile pour les éditeurs de texte, les visualisateurs d'images ou n'importe quelle application +qui fonctionne avec des formats de fichiers spécifiques. Dans ce guide, nous allons parcourir les étapes pour implémenter l'association de fichiers dans l'application Wails. + +## Configurer l'association de fichiers : + +Pour configurer l'association de fichiers, vous devez modifier le fichier wails.json de votre application. +Dans la section "info", ajoutez une section "fileAssociations" spécifiant les types de fichiers auxquels votre application doit être associée. + +Par exemple : + +```json +{ + "info": { + "fileAssociations": [ + { + "ext": "wails", + "name": "Wails", + "description": "Wails Application File", + "iconName": "wailsFileIcon", + "role": "Editor" + }, + { + "ext": "jpg", + "name": "JPEG", + "description": "Image File", + "iconName": "jpegFileIcon", + "role": "Editor" + } + ] + } +} +``` + +| Propriété | Description | +| :----------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| ext | L'extension. ex: png | +| name | Le nom de l'extension. ex: PNG File | +| iconName | Le nom de l'icône sans extension. Les icônes doivent être situées dans le dossier de build. Des icônes appropriées seront générées à partir du fichier .png pour macOS et Windows | +| description | Windows seulement. La description. Il est affiché dans la colonne `Type` dans l'explorateur Windows. | +| role | macOS uniquement. Rôle de l'application par rapport au type. Correspond au rôle CFBundleTypeRole. | + +## Spécificités par platefome : + +### MacOS + +Lorsque vous ouvrez un fichier (ou des fichiers) avec votre application, le système lancera votre application et appellera la fonction `OnFileOpen` dans votre application Wails. Exemple: + +```go title="main.go" +func main() { + // Création d'une application avec des options + err := wails.Run(&options.App{ + Title: "wails-open-file", + Width: 1024, + Height: 768, + AssetServer: &assetserver.Options{ + Assets: assets, + }, + BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1}, + Mac: &mac.Options{ + OnFileOpen: func(filePaths []string) { println(filestring) }, + }, + Bind: []interface{}{ + app, + }, + }) + + if err != nil { + println("Error:", err.Error()) + } +} +``` + +### Windows + +L'association de fichiers dans Windows n'est prise en charge qu'avec l'installateur NSS. Pendant l'installation, l'installateur créera une entrée de registre +pour vos associations de fichiers. Lorsque vous ouvrez un fichier avec votre application, une nouvelle instance d'application est lancée et le chemin d'accès est passé à +comme argument à votre application. Pour gérer cela, vous devez analyser les arguments de la ligne de commande dans votre application. Exemple: + +```go title="main.go" +func main() { + argsWithoutProg := os.Args[1:] + + if len(argsWithoutProg) != 0 { + println("launchArgs", argsWithoutProg) + } +} +``` + +Vous pouvez également activer le verrouillage par instance unique pour votre application. Dans ce cas, lorsque vous ouvrez un fichier avec votre application, la nouvelle instance d'application n'est pas lancée +et les arguments sont passés à l'instance déjà en cours d'exécution. Consultez le guide de verrouillage de l'instance unique pour plus de détails. Exemple: + +```go title="main.go" +func main() { + // Création d'une application avec des options + err := wails.Run(&options.App{ + Title: "wails-open-file", + Width: 1024, + Height: 768, + AssetServer: &assetserver.Options{ + Assets: assets, + }, + BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1}, + SingleInstanceLock: &options.SingleInstanceLock{ + UniqueId: "e3984e08-28dc-4e3d-b70a-45e961589cdc", + OnSecondInstanceLaunch: app.onSecondInstanceLaunch, + }, + Bind: []interface{}{ + app, + }, + }) +} +``` + +### Linux + +Actuellement, Wails ne prend pas en charge l'association de fichiers pour Linux. Vous devez donc créer des associations de fichiers manuellement. +Par exemple, si vous distribuez votre application en tant que package .deb, vous pouvez créer des associations de fichiers en ajoutant les fichiers requis dans votre bundle. +Vous pouvez utiliser [nfpm](https://nfpm.goreleaser.com/) pour créer un package .deb pour votre application. + +1. Créez un fichier .desktop pour votre application et spécifiez des associations de fichiers là-bas. Exemple: + +```ini +[Desktop Entry] +Categories=Office +Exec=/usr/bin/wails-open-file %u +Icon=wails-open-file.png +Name=wails-open-file +Terminal=false +Type=Application +MimeType=application/x-wails;application/x-test +``` + +2. Créer un fichier de type MIME. Exemple: + +```xml + + + + Wails Application File + + + +``` + +3. Créez des icônes pour vos types de fichiers. Les icônes SVG sont recommandées. +4. Préparez les scripts postInstall/postRemove pour votre paquet. Exemple: + +```sh +# Recharge les types MIME pour enregistrer votre association de fichiers +update-mime-database /usr/share/mime +# Recharge la base de données du bureau afin de rendre disponible votre application dans les choix possibles +update-desktop-database /usr/share/applications +# Mise à jour des icônes +update-icon-caches /usr/share/icons/* +``` + +5. Configurez nfpm pour utiliser vos scripts et fichiers. Exemple: + +```yaml +name: "wails-open-file" +arch: "arm64" +platform: "linux" +version: "1.0.0" +section: "default" +priority: "extra" +maintainer: "FooBarCorp " +description: "Sample Package" +vendor: "FooBarCorp" +homepage: "http://example.com" +license: "MIT" +contents: +- src: ../bin/wails-open-file + dst: /usr/bin/wails-open-file +- src: ./main.desktop + dst: /usr/share/applications/wails-open-file.desktop +- src: ./application-wails-mime.xml + dst: /usr/share/mime/packages/application-x-wails.xml +- src: ./application-test-mime.xml + dst: /usr/share/mime/packages/application-x-test.xml +- src: ../appicon.svg + dst: /usr/share/icons/hicolor/scalable/apps/wails-open-file.svg +- src: ../wailsFileIcon.svg + dst: /usr/share/icons/hicolor/scalable/mimetypes/application-x-wails.svg +- src: ../testFileIcon.svg + dst: /usr/share/icons/hicolor/scalable/mimetypes/application-x-test.svg +# copy icons to Yaru theme as well. For some reason Ubuntu didn't pick up fileicons from hicolor theme +- src: ../appicon.svg + dst: /usr/share/icons/Yaru/scalable/apps/wails-open-file.svg +- src: ../wailsFileIcon.svg + dst: /usr/share/icons/Yaru/scalable/mimetypes/application-x-wails.svg +- src: ../testFileIcon.svg + dst: /usr/share/icons/Yaru/scalable/mimetypes/application-x-test.svg +scripts: + postinstall: ./postInstall.sh + postremove: ./postRemove.sh +``` + +6. Construisez votre paquet .deb en utilisant nfpm: + +```sh +nfpm pkg --packager deb --target . +``` + +7. Maintenant que votre paquet est installé, votre application sera associée aux types de fichiers qui ont été spécifiés. Lorsque vous ouvrez un fichier avec votre application, une nouvelle instance est lancée et le chemin du fichier est passé en argument à votre application. + Pour gérer cela, vous devez analyser les arguments de la ligne de commande dans votre application. Exemple: + +```go title="main.go" +func main() { + argsWithoutProg := os.Args[1:] + + if len(argsWithoutProg) != 0 { + println("launchArgs", argsWithoutProg) + } +} +``` + +Vous pouvez également activer le verrouillage par instance unique pour votre application. Dans ce cas, lorsque vous ouvrez un fichier avec votre application, la nouvelle instance d'application n'est pas lancée +et les arguments sont passés à l'instance déjà en cours d'exécution. Consultez le guide de verrouillage de l'instance unique pour plus de détails. Exemple: + +```go title="main.go" +func main() { + // Création d'une application avec des options + err := wails.Run(&options.App{ + Title: "wails-open-file", + Width: 1024, + Height: 768, + AssetServer: &assetserver.Options{ + Assets: assets, + }, + BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1}, + SingleInstanceLock: &options.SingleInstanceLock{ + UniqueId: "e3984e08-28dc-4e3d-b70a-45e961589cdc", + OnSecondInstanceLaunch: app.onSecondInstanceLaunch, + }, + Bind: []interface{}{ + app, + }, + }) +} +``` diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/frameless.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/frameless.mdx new file mode 100644 index 00000000000..bbeb338f1b6 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/frameless.mdx @@ -0,0 +1,87 @@ +# Applications sans cadre + +Wails prend en charge la création d'applications qui n'ont pas de cadres. Ceci peut être réalisé en utilisant le champ [frameless](../reference/options.mdx#frameless) dans [Application Options](../reference/options.mdx#application-options). + +Wails offre une solution simple pour faire glisser la fenêtre: N'importe quel élément HTML qui a le style CSS `--wails-draggable:drag` agira comme une "poignée de glisser". Cette propriété s'applique à tous les éléments enfants. Si vous devez indiquer qu'un élément imbriqué ne doit pas glisser, alors utilisez l'attribut '--wails-draggable:no-drag' sur cet élément. + +```html + + + + + + + +
                        + + +
                        +
                        + + + + +``` + +Pour certains projets, l'utilisation d'une variable CSS peut ne pas être possible en raison du style dynamique. Dans ce cas, vous pouvez utiliser les options `CSSDragProperty` et `CSSDragValue` pour définir une propriété et une valeur qui seront utilisées pour indiquer régions glissables : + +```go title=main.go +package main + +import ( + "embed" + + "github.com/wailsapp/wails/v2" + "github.com/wailsapp/wails/v2/pkg/options" + "github.com/wailsapp/wails/v2/pkg/options/assetserver" +) + +//go:embed all:frontend/dist +var assets embed.FS + +func main() { + // Create an instance of the app structure + app := NewApp() + + // Create application with options + err := wails.Run(&options.App{ + Title: "alwaysontop", + Width: 1024, + Height: 768, + AssetServer: &assetserver.Options{ + Assets: assets, + }, + Frameless: true, + CSSDragProperty: "widows", + CSSDragValue: "1", + Bind: []interface{}{ + app, + }, + }) + + if err != nil { + println("Error:", err) + } +} +``` + +```html title=index.html + + + + + + alwaysontop + + +
                        + + + +``` + +:::info Plein écran + +Si vous autorisez votre application à être en plein écran, cette fonctionnalité de glissement sera désactivée. + +::: diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/frontend.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/frontend.mdx new file mode 100644 index 00000000000..ea101019ad8 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/frontend.mdx @@ -0,0 +1,72 @@ +# Frontend + +## Injection de script + +Quand Wails sert votre fichier `index.html`, par défaut, il injectera 2 entrées de script dans la balise `` pour charger `/wails/ipc.js` et `/wails/runtime.js`. Ces fichiers installent respectivement les bindings et les runtime. + +Le code ci-dessous montre où ils sont injectés par défaut : + +```html + + + injection example + + + + + + + +
                        Please enter your name below 👇
                        +
                        + + +
                        + + + + +``` + +### Remplacer l'injection de script par défaut + +Pour fournir plus de flexibilité aux développeurs, il y a une balise meta qui peut être utilisée pour personnaliser ce comportement: + +```html + +``` + +Les options sont les suivantes : + +| Valeur | Description | +| ------------------- | -------------------------------------------------------------- | +| noautoinjectruntime | Pour désactiver l'injection automatique de `/wails/runtime.js` | +| noautoinjectipc | Pour désactiver l'injection automatique de `/wails/ipc.js` | +| noautoinject | Pour désactiver l'injection automatique de tous les scripts | + +Plusieurs options peuvent être utilisées à condition qu'elles soient séparées par des virgules. + +Ce code est parfaitement valide et fonctionne de la même manière que la version avec l'auto-injection : + +```html + + + injection example + + + + + + +
                        Please enter your name below 👇
                        +
                        + + +
                        + + + + + + +``` diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/ides.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/ides.mdx new file mode 100644 index 00000000000..887937954a2 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/ides.mdx @@ -0,0 +1,127 @@ +# IDEs + +Wails vise à fournir une grande expérience de développement. À cet effet, nous supportons maintenant la génération d'une configuration spécifique IDE pour fournir une configuration plus souple du projet. + +Actuellement, nous prenons en charge [Visual Studio Code](https://code.visualstudio.com/) et [Goland](https://www.jetbrains.com/go/). + +## Visual Studio Code + +```mdx-code-block +

                        + +

                        +``` + +Lors de la génération d'un projet en utilisant l'option `-ide vscode` , les fichiers IDE seront créés à côté des autres fichiers du projet. Ces fichiers sont placés dans le répertoire `.vscode` et fournissent la configuration correcte pour déboguer votre application. + +Les 2 fichiers générés sont `tasks.json` et `launch.json`. Ci-dessous se trouvent les fichiers générés par défaut : + +```json title="tasks.json" +{ + "version": "2.0.0", + "tasks": [ + { + "label": "build", + "type": "shell", + "options": { + "cwd": "${workspaceFolder}" + }, + "command": "go", + "args": [ + "build", + "-tags", + "dev", + "-gcflags", + "all=-N -l", + "-o", + "build/bin/myproject.exe" + ] + } + ] +} +``` + +```json title="launch.json" +{ + "version": "0.2.0", + "configurations": [ + { + "name": "Wails: Debug myproject", + "type": "go", + "request": "launch", + "mode": "exec", + "program": "${workspaceFolder}/build/bin/myproject.exe", + "preLaunchTask": "build", + "cwd": "${workspaceFolder}", + "env": {} + } + ] +} +``` + +### Configuration des étapes d'installation et de construction + +Le fichier `tasks.json` est simple pour le projet par défaut car il n'y a pas d'étapes `npm install` ou `npm build` nécessaire. Pour les projets qui ont une étape de construction en frontend comme avec Svelte, nous devrions modifier `tasks.json` pour ajouter les étapes d'installation et de construction suivantes : + +```json title="tasks.json" +{ + "version": "2.0.0", + "tasks": [ + { + "label": "npm install", + "type": "npm", + "script": "install", + "options": { + "cwd": "${workspaceFolder}/frontend" + }, + "presentation": { + "clear": true, + "panel": "shared", + "showReuseMessage": false + }, + "problemMatcher": [] + }, + { + "label": "npm run build", + "type": "npm", + "script": "build", + "options": { + "cwd": "${workspaceFolder}/frontend" + }, + "presentation": { + "clear": true, + "panel": "shared", + "showReuseMessage": false + }, + "problemMatcher": [] + }, + { + "label": "build", + "type": "shell", + "options": { + "cwd": "${workspaceFolder}" + }, + "command": "go", + "args": [ + "build", + "-tags", + "dev", + "-gcflags", + "all=-N -l", + "-o", + "build/bin/vscode.exe" + ], + "dependsOn": ["npm install", "npm run build"] + } + ] +} +``` + +:::info Améliorations futures + +Dans le futur, nous espérons générer un `tasks.json` qui inclut les étapes d'installation et de construction automatiquement. + +::: diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/linux-distro-support.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/linux-distro-support.mdx new file mode 100644 index 00000000000..6bd2002fce7 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/linux-distro-support.mdx @@ -0,0 +1,103 @@ +# Prise en charge des distributions Linux + +## Vue d'ensemble + +Wails offre le support de Linux, mais fournir des instructions d'installation pour toutes les distributions disponibles est une tâche impossible. À la place, Wails essaie de déterminer si les paquets dont vous avez besoin pour développer des applications sont disponibles via le gestionnaire de paquets de votre système. Actuellement, nous supportons les gestionnaires de paquets suivants : + +- apt +- dnf +- emerge +- eopkg +- nixpkgs +- pacman +- zypper + +## Ajout des noms de paquets + +Il peut y avoir des cas où votre distribution de linux utilise un des gestionnaires de paquets pris en charge mais le nom du paquet est différent. Par exemple, vous pouvez utiliser un dérivé Ubuntu, mais le nom du paquet pour gtk peut être différent. Wails tente de trouver le paquet correct en itérant une liste de noms de paquets. La liste des paquets est stockée dans un fichier spécifique dans le dossier `v2/internal/system/packagemanager` . Dans notre exemple, ce serait `v2/internal/system/packagemanager/apt.go`. + +Dans ce fichier, la liste des paquets est définie par la méthode `Packages()`: + +```go +func (a *Apt) Packages() packagemap { + return packagemap{ + "libgtk-3": []*Package{ + {Name: "libgtk-3-dev", SystemPackage: true, Library: true}, + }, + "libwebkit": []*Package{ + {Name: "libwebkit2gtk-4.0-dev", SystemPackage: true, Library: true}, + }, + "gcc": []*Package{ + {Name: "build-essential", SystemPackage: true}, + }, + "pkg-config": []*Package{ + {Name: "pkg-config", SystemPackage: true}, + }, + "npm": []*Package{ + {Name: "npm", SystemPackage: true}, + }, + "docker": []*Package{ + {Name: "docker.io", SystemPackage: true, Optional: true}, + }, + } +} +``` + +Supposons que dans notre distribution linux, `libgtk-3` est empaqueté sous le nom `lib-gtk3-dev`. Nous pourrions ajouter le support de ce paquet en ajoutant la ligne suivante : + +```go {5} +func (a *Apt) Packages() packagemap { + return packagemap{ + "libgtk-3": []*Package{ + {Name: "libgtk-3-dev", SystemPackage: true, Library: true}, + {Name: "lib-gtk3-dev", SystemPackage: true, Library: true}, + }, + "libwebkit": []*Package{ + {Name: "libwebkit2gtk-4.0-dev", SystemPackage: true, Library: true}, + }, + "gcc": []*Package{ + {Name: "build-essential", SystemPackage: true}, + }, + "pkg-config": []*Package{ + {Name: "pkg-config", SystemPackage: true}, + }, + "npm": []*Package{ + {Name: "npm", SystemPackage: true}, + }, + "docker": []*Package{ + {Name: "docker.io", SystemPackage: true, Optional: true}, + }, + } +} +``` + +## Ajout de nouveaux gestionnaires de paquets + +Pour ajouter un nouveau gestionnaire de paquets, effectuez les étapes suivantes : + +- Créez un nouveau fichier dans `v2/internal/system/packagemanager` appelé `.go`, où `` est le nom du gestionnaire de paquets. +- Définit une structure conforme à l'interface du gestionnaire de paquets définie dans `pm.go`: + +```go +type PackageManager interface { + Name() string + Packages() packagemap + PackageInstalled(*Package) (bool, error) + PackageAvailable(*Package) (bool, error) + InstallCommand(*Package) string +} +``` + +- `Name()` doit retourner le nom du gestionnaire de paquets +- `Packages()` doit retourner une `packagemap`, qui fournit des noms de fichiers candidats pour les dépendances +- `PackageInstalled()` devrait retourner `true` si le paquet donné est installé +- `PackageAvailable()` devrait retourner `true` si le paquet donné n'est pas installé mais disponible pour l'installation +- `InstallCommand()` doit retourner la commande exacte pour installer le nom du paquet donné + +Jetez un coup d'œil au code des autres gestionnaires de paquets pour avoir une idée de comment cela fonctionne. + +:::info Rappel + +Si vous ajoutez le support d'un nouveau gestionnaire de paquets, n'oubliez pas de mettre également à jour cette page ! + +::: diff --git a/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/linux.mdx b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/linux.mdx new file mode 100644 index 00000000000..6df9f0fe0d2 --- /dev/null +++ b/website/i18n/fr/docusaurus-plugin-content-docs/version-v2.13.0/guides/linux.mdx @@ -0,0 +1,70 @@ +# Linux + +Cette page a divers guides liés au développement d'applications Wails pour Linux. + +## Le tag vidéo ne déclenche pas l'événement "ended" + +Lorsque vous utilisez un tag vidéo, l'événement "terminé" n'est pas déclenché lorsque la vidéo est finie. Ceci est un bogue dans WebkitGTK, cependant vous pouvez utiliser le contournement suivant pour le corriger : + +```js +videoTag.addEventListener("timeupdate", (event) => { + if (event.target.duration - event.target.currentTime < 0.2) { + let ended = new Event("ended"); + event.target.dispatchEvent(ended); + } +}); +``` + +Source : [Lyimmi](https://github.com/Lyimmi) sur le [forum de discussion](https://github.com/wailsapp/wails/issues/1729#issuecomment-1212291275) + +## Erreur GStreamer lors de l'utilisation d'éléments audio ou vidéo + +Si vous voyez l'erreur suivante lorsque vous incluez les éléments `