chore(release): 19.2.0-dev.1 [skip ci]

# [19.2.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v19.1.1-dev.1...v19.2.0-dev.1) (2023-12-22) ### Features * Add `PatchExtensions#registerNewPatchOption` function to simplify instantiation and registration of patch options ([4a91845](4a9184597b))
feat: Add PatchExtensions#registerNewPatchOption function to simplify instantiation and registration of patch options
2026-01-12 06:16:18 +00:00 · 2023-12-22 02:23:04 +00:00 · 2023-12-22 03:20:50 +01:00 · 2023-12-22 03:09:42 +01:00 · 2023-12-10 21:57:10 +01:00 · 2023-12-01 22:15:43 +00:00
81 changed files with 8976 additions and 3567 deletions
--- a/.github/ISSUE_TEMPLATE/bug-issue.yml
+++ b/.github/ISSUE_TEMPLATE/bug-issue.yml
@@ -1,72 +0,0 @@
-name: 🐞 Bug report
-description: Report a very clearly broken issue.
-title: 'bug: <title>'
-labels: [bug]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        # ReVanced bug report
-
-        Important to note that your issue may have already been reported before. Please check for existing issues [here](https://github.com/revanced/revanced-patcher/labels/bug).
-
-  - type: dropdown
-    attributes:
-      label: Type
-      options:
-        - Crash
-        - Cosmetic
-        - Other
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Bug description
-      description: How did you find the bug? Any additional details that might help?
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Steps to reproduce
-      description: Add the steps to reproduce this bug including your environment.
-      placeholder: Step 1. Download some files. Step 2. ...
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Relevant log output
-      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
-      render: shell
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Screenshots or videos
-      description: Add screenshots or videos that show the bug here.
-      placeholder: Drag and drop the screenshots/videos into this box.
-    validations:
-      required: false
-  - type: textarea
-    attributes:
-      label: Solution
-      description: If applicable, add a possible solution.
-    validations:
-      required: false
-  - type: textarea
-    attributes:
-      label: Additional context
-      description: Add additional context here.
-    validations:
-      required: false
-  - type: checkboxes
-    id: acknowledgements
-    attributes:
-      label: Acknowledgements
-      description: Your issue will be closed if you haven't done these steps.
-      options:
-        - label: I have searched the existing issues and this is a new and no duplicate or related to another open issue.
-          required: true
-        - label: I have written a short but informative title.
-          required: true
-        - label: I filled out all of the requested information in this issue properly.
-          required: true
--- a/.github/ISSUE_TEMPLATE/bug-report.yml
+++ b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -0,0 +1,108 @@
+name: 🐞 Bug report
+description: Report a bug or an issue.
+title: 'bug: '
+labels: ['Bug report']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        <p align="center">
+          <picture>
+            <source
+              width="256px"
+              media="(prefers-color-scheme: dark)"
+              srcset="https://raw.githubusercontent.com/revanced/revanced-patcher/main/assets/revanced-headline/revanced-headline-vertical-dark.svg"
+            >
+            <img 
+              width="256px"
+              src="https://raw.githubusercontent.com/revanced/revanced-patcher/main/assets/revanced-headline/revanced-headline-vertical-light.svg"
+            >
+          </picture>
+          <br>
+          <a href="https://revanced.app/">
+             <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/revanced/revanced-patcher/main/assets/revanced-logo/revanced-logo.svg" />
+                 <img height="24px" src="https://raw.githubusercontent.com/revanced/revanced-patcher/main/assets/revanced-logo/revanced-logo.svg" />
+             </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://github.com/ReVanced">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://i.ibb.co/dMMmCrW/Git-Hub-Mark.png" />
+                   <img height="24px" src="https://i.ibb.co/9wV3HGF/Git-Hub-Mark-Light.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="http://revanced.app/discord">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032563-d4e084b7-244e-4358-af50-26bde6dd4996.png" />
+                   <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032563-d4e084b7-244e-4358-af50-26bde6dd4996.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://reddit.com/r/revancedapp">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032351-9d9d5619-8ef7-470a-9eec-2744ece54553.png" />
+                   <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032351-9d9d5619-8ef7-470a-9eec-2744ece54553.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://t.me/app_revanced">
+              <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032213-faf25ab8-0bc3-4a94-a730-b524c96df124.png" />
+                 <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032213-faf25ab8-0bc3-4a94-a730-b524c96df124.png" />
+              </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://x.com/revancedapp">
+              <picture>
+                 <source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/93124920/270180600-7c1b38bf-889b-4d68-bd5e-b9d86f91421a.png">
+                 <img height="24px" src="https://user-images.githubusercontent.com/93124920/270108715-d80743fa-b330-4809-b1e6-79fbdc60d09c.png" />
+              </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://www.youtube.com/@ReVanced">
+              <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032714-c51c7492-0666-44ac-99c2-f003a695ab50.png" />
+                 <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032714-c51c7492-0666-44ac-99c2-f003a695ab50.png" />
+             </picture>
+           </a>
+           <br>
+           <br>
+           Continuing the legacy of Vanced
+        </p>
+
+        # ReVanced Patcher bug report
+
+        Before creating a new bug report, please keep the following in mind:
+        
+        - **Do not submit a duplicate bug report**: You can review existing bug reports [here](https://github.com/ReVanced/revanced-patcher/labels/Bug%20report).
+        - **Do not use the issue page for support**: If you need help or have questions, check out other platforms on [revanced.app](https://revanced.app).
+  - type: textarea
+    attributes:
+      label: Bug description
+      description: |
+        - Describe your bug in detail
+        - Add steps to reproduce the bug if possible (Step 1. ... Step 2. ...)
+        - Add images and videos if possible
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Error logs
+      description: Exceptions can be captured by running `logcat | grep AndroidRuntime` in a shell.
+      render: shell
+  - type: textarea
+    attributes:
+      label: Solution
+      description: If applicable, add a possible solution to the bug.
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add additional context here.
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Your bug report will be closed if you don't follow the checklist below.
+      options:
+        - label: This issue is not a duplicate of an existing bug report.
+          required: true
+        - label: I have chosen an appropriate title.
+          required: true
+        - label: All requested information has been provided properly.
+          required: true
--- a/.github/ISSUE_TEMPLATE/feature-issue.yml
+++ b/.github/ISSUE_TEMPLATE/feature-issue.yml
@@ -1,58 +0,0 @@
-name: ⭐ Feature request
-description: Create a detailed feature request.
-title: 'feat: <title>'
-labels: [feature-request]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        # ReVanced feature request
-        
-        Do not submit requests for patches here. Please submit them [here](https://github.com/orgs/revanced/discussions/categories/patches) instead.
-        Important to note that your feature request may have already been made before. Please check for existing feature requests [here](https://github.com/revanced/revanced-patcher/labels/feature-request).
-
-  - type: dropdown
-    attributes:
-      label: Type
-      options:
-        - Functionality
-        - Cosmetic
-        - Other
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Issue
-      description: What is the current problem. Why does it require a feature request?
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Feature
-      description: Describe your feature in detail. How does it solve the issue?
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Motivation
-      description: Why should your feature should be considered?
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Additional context
-      description: Add additional context here.
-    validations:
-      required: false
-  - type: checkboxes
-    id: acknowledgements
-    attributes:
-      label: Acknowledgements
-      description: Your issue will be closed if you haven't done these steps.
-      options:
-        - label: I have searched the existing issues and this is a new and no duplicate or related to another open issue.
-          required: true
-        - label: I have written a short but informative title.
-          required: true
-        - label: I filled out all of the requested information in this issue properly.
-          required: true
--- a/.github/ISSUE_TEMPLATE/feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -0,0 +1,106 @@
+name: ⭐ Feature request
+description: Create a detailed request for a new feature.
+title: 'feat: '
+labels: ['Feature request']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        <p align="center">
+          <picture>
+            <source
+              width="256px"
+              media="(prefers-color-scheme: dark)"
+              srcset="https://raw.githubusercontent.com/revanced/revanced-patcher/main/assets/revanced-headline/revanced-headline-vertical-dark.svg"
+            >
+            <img 
+              width="256px"
+              src="https://raw.githubusercontent.com/revanced/revanced-patcher/main/assets/revanced-headline/revanced-headline-vertical-light.svg"
+            >
+          </picture>
+          <br>
+          <a href="https://revanced.app/">
+             <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/revanced/revanced-patcher/main/assets/revanced-logo/revanced-logo.svg" />
+                 <img height="24px" src="https://raw.githubusercontent.com/revanced/revanced-patcher/main/assets/revanced-logo/revanced-logo.svg" />
+             </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://github.com/ReVanced">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://i.ibb.co/dMMmCrW/Git-Hub-Mark.png" />
+                   <img height="24px" src="https://i.ibb.co/9wV3HGF/Git-Hub-Mark-Light.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="http://revanced.app/discord">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032563-d4e084b7-244e-4358-af50-26bde6dd4996.png" />
+                   <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032563-d4e084b7-244e-4358-af50-26bde6dd4996.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://reddit.com/r/revancedapp">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032351-9d9d5619-8ef7-470a-9eec-2744ece54553.png" />
+                   <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032351-9d9d5619-8ef7-470a-9eec-2744ece54553.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://t.me/app_revanced">
+              <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032213-faf25ab8-0bc3-4a94-a730-b524c96df124.png" />
+                 <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032213-faf25ab8-0bc3-4a94-a730-b524c96df124.png" />
+              </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://x.com/revancedapp">
+              <picture>
+                 <source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/93124920/270180600-7c1b38bf-889b-4d68-bd5e-b9d86f91421a.png">
+                 <img height="24px" src="https://user-images.githubusercontent.com/93124920/270108715-d80743fa-b330-4809-b1e6-79fbdc60d09c.png" />
+              </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://www.youtube.com/@ReVanced">
+              <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032714-c51c7492-0666-44ac-99c2-f003a695ab50.png" />
+                 <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032714-c51c7492-0666-44ac-99c2-f003a695ab50.png" />
+             </picture>
+           </a>
+           <br>
+           <br>
+           Continuing the legacy of Vanced
+        </p>
+
+        # ReVanced Patcher feature request
+
+        Before creating a new feature request, please keep the following in mind:
+
+        - **Do not submit a duplicate feature request**: You can review existing feature requests [here](https://github.com/ReVanced/revanced-patcher/labels/Feature%20request).
+        - **Do not use the issue page for support**: If you need help or have questions, check out other platforms on [revanced.app](https://revanced.app).
+
+  - type: textarea
+    attributes:
+      label: Feature description
+      description: |
+        - Describe your feature in detail
+        - Add images, videos, links, examples, references, etc. if possible
+        - Add the target application name in case you request a new patch
+  - type: textarea
+    attributes:
+      label: Motivation
+      description: |
+        A strong motivation is necessary for a feature request to be considered.
+        
+        - Why should this feature be implemented? 
+        - What is the explicit use case?
+        - What are the benefits?
+        - What makes this feature important?
+    validations:
+      required: true
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Your feature request will be closed if you don't follow the checklist below.
+      options:
+        - label: This issue is not a duplicate of an existing feature request.
+          required: true
+        - label: I have chosen an appropriate title.
+          required: true
+        - label: All requested information has been provided properly.
+          required: true
--- a/.github/config.yml
+++ b/.github/config.yml
@@ -1,2 +1,2 @@
 firstPRMergeComment: >
-  Thank you for contributing to ReVanced. Join us on [Discord](https://revanced.app/discord) if you want to receive a contributor role.
+  Thank you for contributing to ReVanced. Join us on [Discord](https://revanced.app/discord) to receive a role for your contribution.
--- a/.github/workflows/pull_request.yml
+++ b/.github/workflows/pull_request.yml
@@ -16,6 +16,7 @@ jobs:
    steps:
      - name: Checkout
        uses: actions/checkout@v4
+
      - name: Open pull request
        uses: repo-sync/pull-request@v2
        with:
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -23,22 +23,25 @@ jobs:
          # https://github.com/cycjimmy/semantic-release-action#private-packages
          persist-credentials: false
          fetch-depth: 0
-      - name: Cache
+
+      - name: Cache Node modules
        uses: actions/cache@v3
        with:
          path: |
-            ${{ runner.home }}/.gradle/caches
-            ${{ runner.home }}/.gradle/wrapper
-            .gradle
-            build
            node_modules
-          key: ${{ runner.os }}-gradle-npm-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties', 'package-lock.json') }}
+          key: npm-${{ hashFiles('package-lock.json') }}
+
+      - name: Cache Gradle
+        uses: burrunan/gradle-cache-action@v1
+
      - name: Build with Gradle
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: ./gradlew build clean --no-daemon
+
      - name: Setup semantic-release
        run: npm install
+
      - name: Release
        env:
          GITHUB_TOKEN: ${{ secrets.REPOSITORY_PUSH_ACCESS }}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,165 @@
+# [19.2.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v19.1.1-dev.1...v19.2.0-dev.1) (2023-12-22)
+
+
+### Features
+
+* Add `PatchExtensions#registerNewPatchOption` function to simplify instantiation and registration of patch options ([4a91845](https://github.com/ReVanced/revanced-patcher/commit/4a9184597be99cd458496cce0ee68994e6b8735c))
+
+## [19.1.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v19.1.0...v19.1.1-dev.1) (2023-12-01)
+
+
+### Bug Fixes
+
+* Accept `PatchSet` in `PatchesConsumer#acceptPatches` ([716825f](https://github.com/ReVanced/revanced-patcher/commit/716825f232bf1aab3a97723968562aa6dbdb20b1))
+
+# [19.1.0](https://github.com/ReVanced/revanced-patcher/compare/v19.0.0...v19.1.0) (2023-12-01)
+
+
+### Features
+
+* Add constructor to initialize patches without annotations ([462fbe2](https://github.com/ReVanced/revanced-patcher/commit/462fbe2cadf56d8b0dde33319256021093bd39d5))
+* Retrieve annotations in super and interface classes ([7aeae93](https://github.com/ReVanced/revanced-patcher/commit/7aeae93f3d9a13e294fe1bdb2586f79908af60af))
+
+
+### Performance Improvements
+
+* Use a hash set for fast lookup ([f1de9b3](https://github.com/ReVanced/revanced-patcher/commit/f1de9b39eff1db44c00acd3e41902b3ec6124776))
+
+# [19.1.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v19.0.0...v19.1.0-dev.1) (2023-11-29)
+
+
+### Features
+
+* Add constructor to initialize patches without annotations ([462fbe2](https://github.com/ReVanced/revanced-patcher/commit/462fbe2cadf56d8b0dde33319256021093bd39d5))
+* Retrieve annotations in super and interface classes ([7aeae93](https://github.com/ReVanced/revanced-patcher/commit/7aeae93f3d9a13e294fe1bdb2586f79908af60af))
+
+
+### Performance Improvements
+
+* Use a hash set for fast lookup ([f1de9b3](https://github.com/ReVanced/revanced-patcher/commit/f1de9b39eff1db44c00acd3e41902b3ec6124776))
+
+# [19.0.0](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0...v19.0.0) (2023-10-24)
+
+
+### Features
+
+* Add `PatchOption#valueType` to handle type erasure ([a46e948](https://github.com/ReVanced/revanced-patcher/commit/a46e948b5a0cf9bc8d31f557e371cd7d7c2f5b1c))
+
+
+### BREAKING CHANGES
+
+* This changes the signature of the `PatchOption` constructor.
+
+# [19.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0...v19.0.0-dev.1) (2023-10-24)
+
+
+### Features
+
+* Add `PatchOption#valueType` to handle type erasure ([a46e948](https://github.com/ReVanced/revanced-patcher/commit/a46e948b5a0cf9bc8d31f557e371cd7d7c2f5b1c))
+
+
+### BREAKING CHANGES
+
+* This changes the signature of the `PatchOption` constructor.
+
+# [18.0.0](https://github.com/ReVanced/revanced-patcher/compare/v17.0.0...v18.0.0) (2023-10-22)
+
+
+### Bug Fixes
+
+* Do not set patch fields if they are empty ([a76ac04](https://github.com/ReVanced/revanced-patcher/commit/a76ac04214a2ab91e3b2f9dddb13ed52816fe723))
+* Only allow setting `MethodFingerprint#result` privately ([aed1eac](https://github.com/ReVanced/revanced-patcher/commit/aed1eac3157317acf87f522750cf2f41509606c3))
+
+
+### Code Refactoring
+
+* Change `PatchOption` from abstract to open class ([09cd6aa](https://github.com/ReVanced/revanced-patcher/commit/09cd6aa568988dd5241bfa6a2e12b7926a7b0683))
+* Change data classes to actual classes ([6192089](https://github.com/ReVanced/revanced-patcher/commit/6192089b71bdca15765369f3e607ddd1f8266205))
+* Convert extension functions to member functions ([e2ca507](https://github.com/ReVanced/revanced-patcher/commit/e2ca50729da7085799c0ff6fc4f7afaf82579738))
+* Move files to simplify package structure ([124a2e9](https://github.com/ReVanced/revanced-patcher/commit/124a2e9d3efb88f0f038ae306d941e918ad3ad3c))
+* Remove deprecated classes and members ([a4212f6](https://github.com/ReVanced/revanced-patcher/commit/a4212f6bf952971541c4550e20f6bf57a382e19a))
+
+
+* refactor!: Remove `Fingerprint` interface ([54a2f8f](https://github.com/ReVanced/revanced-patcher/commit/54a2f8f16fddf2b2ed47eb23717ba3734c4a6c5d))
+
+
+### Features
+
+* Add function to reset options to their default value ([ebbaafb](https://github.com/ReVanced/revanced-patcher/commit/ebbaafb78e88f34faeafe9ff8532afe29231bd79))
+* Add function to reset options to their default value ([e6de90d](https://github.com/ReVanced/revanced-patcher/commit/e6de90d300bc9c82ca1696cb898db04c65a1cd5b))
+* Add getter for default option value ([c7922e9](https://github.com/ReVanced/revanced-patcher/commit/c7922e90d0c6ae83f513611c706ebea33c1a2b63))
+* Make `PatchOption#values` nullable ([56ce9ec](https://github.com/ReVanced/revanced-patcher/commit/56ce9ec2f98ff351c3d42df71b49e5c88f07e665))
+* Name patch option value validator property correctly ([caa634f](https://github.com/ReVanced/revanced-patcher/commit/caa634fac6d7a717f54e3b015827c8858fd637b9))
+* Remove patch annotation processor ([4456031](https://github.com/ReVanced/revanced-patcher/commit/445603145979a6f67823a79f9d6cd140299cff37))
+* Use a map for `PatchOption#values` ([54ac139](https://github.com/ReVanced/revanced-patcher/commit/54ac1394a914d3eed7865ec697e8016834134911))
+
+
+### Performance Improvements
+
+* Run the garbage collector after writing dex files ([d9fb241](https://github.com/ReVanced/revanced-patcher/commit/d9fb241d57b0c4340130c0e5900250e66730ea56))
+
+
+### BREAKING CHANGES
+
+* The `MethodFingerprint#result` member can now only be set inside `MethodFingerprint`.
+* The `Fingerprint` interface is no longer present.
+* Some extension functions are now member functions.
+* This gets rid of data class members.
+* Some deprecated classes and members are not present anymore.
+* Classes and members have changed packages.
+* This gets rid of the existing basic implementations of the `PatchOptions` type and moves extension functions.
+* This changes the getter name of the property.
+* Various patch constructor signatures have changed.
+
+# [18.0.0-dev.6](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.5...v18.0.0-dev.6) (2023-10-22)
+
+
+### Bug Fixes
+
+* Only allow setting `MethodFingerprint#result` privately ([aed1eac](https://github.com/ReVanced/revanced-patcher/commit/aed1eac3157317acf87f522750cf2f41509606c3))
+
+
+### Code Refactoring
+
+* Change data classes to actual classes ([6192089](https://github.com/ReVanced/revanced-patcher/commit/6192089b71bdca15765369f3e607ddd1f8266205))
+* Convert extension functions to member functions ([e2ca507](https://github.com/ReVanced/revanced-patcher/commit/e2ca50729da7085799c0ff6fc4f7afaf82579738))
+* Move files to simplify package structure ([124a2e9](https://github.com/ReVanced/revanced-patcher/commit/124a2e9d3efb88f0f038ae306d941e918ad3ad3c))
+* Remove deprecated classes and members ([a4212f6](https://github.com/ReVanced/revanced-patcher/commit/a4212f6bf952971541c4550e20f6bf57a382e19a))
+
+
+* refactor!: Remove `Fingerprint` interface ([54a2f8f](https://github.com/ReVanced/revanced-patcher/commit/54a2f8f16fddf2b2ed47eb23717ba3734c4a6c5d))
+
+
+### BREAKING CHANGES
+
+* The `MethodFingerprint#result` member can now only be set inside `MethodFingerprint`.
+* The `Fingerprint` interface is no longer present.
+* Some extension functions are now member functions.
+* This gets rid of data class members.
+* Some deprecated classes and members are not present anymore.
+* Classes and members have changed packages.
+
+# [18.0.0-dev.5](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.4...v18.0.0-dev.5) (2023-10-22)
+
+
+### Bug Fixes
+
+* Do not set patch fields if they are empty ([a76ac04](https://github.com/ReVanced/revanced-patcher/commit/a76ac04214a2ab91e3b2f9dddb13ed52816fe723))
+
+# [18.0.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.3...v18.0.0-dev.4) (2023-10-22)
+
+
+### Features
+
+* Use a map for `PatchOption#values` ([54ac139](https://github.com/ReVanced/revanced-patcher/commit/54ac1394a914d3eed7865ec697e8016834134911))
+
+# [18.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.2...v18.0.0-dev.3) (2023-10-22)
+
+
+### Features
+
+* Make `PatchOption#values` nullable ([56ce9ec](https://github.com/ReVanced/revanced-patcher/commit/56ce9ec2f98ff351c3d42df71b49e5c88f07e665))
+
 # [18.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.1...v18.0.0-dev.2) (2023-10-22)


--- a/api/revanced-patcher.api
+++ b/api/revanced-patcher.api
@@ -44,6 +44,7 @@ public final class app/revanced/patcher/Patcher : app/revanced/patcher/Integrati
 	public fun <init> (Lapp/revanced/patcher/PatcherOptions;)V
 	public fun acceptIntegrations (Ljava/util/List;)V
 	public fun acceptPatches (Ljava/util/List;)V
+	public fun acceptPatches (Ljava/util/Set;)V
 	public synthetic fun apply (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun apply (Z)Lkotlinx/coroutines/flow/Flow;
 	public fun close ()V
@@ -65,8 +66,6 @@ public final class app/revanced/patcher/PatcherException$CircularDependencyExcep
 }

 public final class app/revanced/patcher/PatcherOptions {
-	public fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;)V
-	public synthetic fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;Z)V
 	public synthetic fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;ZILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public final fun copy (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;Z)Lapp/revanced/patcher/PatcherOptions;
@@ -101,6 +100,11 @@ public final class app/revanced/patcher/PatcherResult$PatchedDexFile {

 public abstract interface class app/revanced/patcher/PatchesConsumer {
 	public abstract fun acceptPatches (Ljava/util/List;)V
+	public abstract fun acceptPatches (Ljava/util/Set;)V
+}
+
+public final class app/revanced/patcher/PatchesConsumer$DefaultImpls {
+	public static fun acceptPatches (Lapp/revanced/patcher/PatchesConsumer;Ljava/util/List;)V
 }

 public final class app/revanced/patcher/data/BytecodeContext : app/revanced/patcher/data/Context {
@@ -169,148 +173,81 @@ public final class app/revanced/patcher/extensions/InstructionExtensions {

 public final class app/revanced/patcher/extensions/MethodFingerprintExtensions {
 	public static final field INSTANCE Lapp/revanced/patcher/extensions/MethodFingerprintExtensions;
-	public final fun getFuzzyPatternScanMethod (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint;)Lapp/revanced/patcher/fingerprint/method/annotation/FuzzyPatternScanMethod;
+	public final fun getFuzzyPatternScanMethod (Lapp/revanced/patcher/fingerprint/MethodFingerprint;)Lapp/revanced/patcher/fingerprint/annotation/FuzzyPatternScanMethod;
 }

-public abstract interface class app/revanced/patcher/fingerprint/Fingerprint {
-}
-
-public abstract interface annotation class app/revanced/patcher/fingerprint/method/annotation/FuzzyPatternScanMethod : java/lang/annotation/Annotation {
-	public abstract fun threshold ()I
-}
-
-public abstract class app/revanced/patcher/fingerprint/method/impl/MethodFingerprint : app/revanced/patcher/fingerprint/Fingerprint {
-	public static final field Companion Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint$Companion;
+public abstract class app/revanced/patcher/fingerprint/MethodFingerprint {
+	public static final field Companion Lapp/revanced/patcher/fingerprint/MethodFingerprint$Companion;
 	public fun <init> ()V
 	public fun <init> (Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/Iterable;Ljava/lang/Iterable;Ljava/lang/Iterable;Lkotlin/jvm/functions/Function2;)V
 	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/Iterable;Ljava/lang/Iterable;Ljava/lang/Iterable;Lkotlin/jvm/functions/Function2;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public final fun getResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;
-	public final fun setResult (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;)V
+	public final fun getFuzzyPatternScanMethod ()Lapp/revanced/patcher/fingerprint/annotation/FuzzyPatternScanMethod;
+	public final fun getResult ()Lapp/revanced/patcher/fingerprint/MethodFingerprintResult;
+	public final fun resolve (Lapp/revanced/patcher/data/BytecodeContext;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
+	public final fun resolve (Lapp/revanced/patcher/data/BytecodeContext;Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
 }

-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprint$Companion {
-	public final fun resolve (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint;Lapp/revanced/patcher/data/BytecodeContext;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
-	public final fun resolve (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint;Lapp/revanced/patcher/data/BytecodeContext;Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
+public final class app/revanced/patcher/fingerprint/MethodFingerprint$Companion {
 	public final fun resolve (Ljava/lang/Iterable;Lapp/revanced/patcher/data/BytecodeContext;Ljava/lang/Iterable;)V
 }

-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult {
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;)V
-	public final fun component1 ()Lcom/android/tools/smali/dexlib2/iface/Method;
-	public final fun component2 ()Lcom/android/tools/smali/dexlib2/iface/ClassDef;
-	public final fun component3 ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
-	public final fun copy (Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;
-	public fun equals (Ljava/lang/Object;)Z
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult {
+	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;)V
 	public final fun getClassDef ()Lcom/android/tools/smali/dexlib2/iface/ClassDef;
 	public final fun getMethod ()Lcom/android/tools/smali/dexlib2/iface/Method;
 	public final fun getMutableClass ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass;
 	public final fun getMutableMethod ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;
-	public final fun getScanResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
+	public final fun getScanResult ()Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult;
 }

-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult {
-	public fun <init> (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;)V
-	public final fun component1 ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
-	public final fun component2 ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
-	public final fun copy (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getPatternScanResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
-	public final fun getStringsScanResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult {
+	public fun <init> (Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;)V
+	public final fun getPatternScanResult ()Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
+	public final fun getStringsScanResult ()Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
 }

-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult {
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult {
 	public fun <init> (IILjava/util/List;)V
 	public synthetic fun <init> (IILjava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public final fun component1 ()I
-	public final fun component2 ()I
-	public final fun component3 ()Ljava/util/List;
-	public final fun copy (IILjava/util/List;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;IILjava/util/List;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
-	public fun equals (Ljava/lang/Object;)Z
 	public final fun getEndIndex ()I
 	public final fun getStartIndex ()I
 	public final fun getWarnings ()Ljava/util/List;
-	public fun hashCode ()I
 	public final fun setWarnings (Ljava/util/List;)V
-	public fun toString ()Ljava/lang/String;
 }

-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning {
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning {
 	public fun <init> (Lcom/android/tools/smali/dexlib2/Opcode;Lcom/android/tools/smali/dexlib2/Opcode;II)V
-	public final fun component1 ()Lcom/android/tools/smali/dexlib2/Opcode;
-	public final fun component2 ()Lcom/android/tools/smali/dexlib2/Opcode;
-	public final fun component3 ()I
-	public final fun component4 ()I
-	public final fun copy (Lcom/android/tools/smali/dexlib2/Opcode;Lcom/android/tools/smali/dexlib2/Opcode;II)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning;Lcom/android/tools/smali/dexlib2/Opcode;Lcom/android/tools/smali/dexlib2/Opcode;IIILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning;
-	public fun equals (Ljava/lang/Object;)Z
 	public final fun getCorrectOpcode ()Lcom/android/tools/smali/dexlib2/Opcode;
 	public final fun getInstructionIndex ()I
 	public final fun getPatternIndex ()I
 	public final fun getWrongOpcode ()Lcom/android/tools/smali/dexlib2/Opcode;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
 }

-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult {
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult {
 	public fun <init> (Ljava/util/List;)V
-	public final fun component1 ()Ljava/util/List;
-	public final fun copy (Ljava/util/List;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;Ljava/util/List;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
-	public fun equals (Ljava/lang/Object;)Z
 	public final fun getMatches ()Ljava/util/List;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
 }

-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch {
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch {
 	public fun <init> (Ljava/lang/String;I)V
-	public final fun component1 ()Ljava/lang/String;
-	public final fun component2 ()I
-	public final fun copy (Ljava/lang/String;I)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch;Ljava/lang/String;IILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch;
-	public fun equals (Ljava/lang/Object;)Z
 	public final fun getIndex ()I
 	public final fun getString ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
 }

-public abstract interface class app/revanced/patcher/logging/Logger {
-	public abstract fun error (Ljava/lang/String;)V
-	public abstract fun info (Ljava/lang/String;)V
-	public abstract fun trace (Ljava/lang/String;)V
-	public abstract fun warn (Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/logging/Logger$DefaultImpls {
-	public static fun error (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
-	public static fun info (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
-	public static fun trace (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
-	public static fun warn (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/logging/impl/NopLogger : app/revanced/patcher/logging/Logger {
-	public static final field INSTANCE Lapp/revanced/patcher/logging/impl/NopLogger;
-	public fun error (Ljava/lang/String;)V
-	public fun info (Ljava/lang/String;)V
-	public fun trace (Ljava/lang/String;)V
-	public fun warn (Ljava/lang/String;)V
+public abstract interface annotation class app/revanced/patcher/fingerprint/annotation/FuzzyPatternScanMethod : java/lang/annotation/Annotation {
+	public abstract fun threshold ()I
 }

 public abstract class app/revanced/patcher/patch/BytecodePatch : app/revanced/patcher/patch/Patch {
 	public fun <init> ()V
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZLjava/util/Set;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZLjava/util/Set;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public fun <init> (Ljava/util/Set;)V
 	public synthetic fun <init> (Ljava/util/Set;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 }

 public abstract class app/revanced/patcher/patch/Patch {
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZLkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public fun equals (Ljava/lang/Object;)Z
 	public abstract fun execute (Lapp/revanced/patcher/data/Context;)V
 	public final fun getCompatiblePackages ()Ljava/util/Set;
@@ -344,6 +281,8 @@ public final class app/revanced/patcher/patch/PatchResult {

 public abstract class app/revanced/patcher/patch/ResourcePatch : app/revanced/patcher/patch/Patch {
 	public fun <init> ()V
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZ)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZILkotlin/jvm/internal/DefaultConstructorMarker;)V
 }

 public abstract interface annotation class app/revanced/patcher/patch/annotation/CompatiblePackage : java/lang/annotation/Annotation {
@@ -362,7 +301,7 @@ public abstract interface annotation class app/revanced/patcher/patch/annotation

 public class app/revanced/patcher/patch/options/PatchOption {
 	public static final field PatchExtensions Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;
-	public fun <init> (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)V
+	public fun <init> (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLjava/lang/String;Lkotlin/jvm/functions/Function2;)V
 	public final fun getDefault ()Ljava/lang/Object;
 	public final fun getDescription ()Ljava/lang/String;
 	public final fun getKey ()Ljava/lang/String;
@@ -371,7 +310,8 @@ public class app/revanced/patcher/patch/options/PatchOption {
 	public final fun getValidator ()Lkotlin/jvm/functions/Function2;
 	public final fun getValue ()Ljava/lang/Object;
 	public final fun getValue (Ljava/lang/Object;Lkotlin/reflect/KProperty;)Ljava/lang/Object;
-	public final fun getValues ()Ljava/util/Set;
+	public final fun getValueType ()Ljava/lang/String;
+	public final fun getValues ()Ljava/util/Map;
 	public fun reset ()V
 	public final fun setValue (Ljava/lang/Object;)V
 	public final fun setValue (Ljava/lang/Object;Lkotlin/reflect/KProperty;Ljava/lang/Object;)V
@@ -379,26 +319,28 @@ public class app/revanced/patcher/patch/options/PatchOption {
 }

 public final class app/revanced/patcher/patch/options/PatchOption$PatchExtensions {
-	public final fun booleanArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Boolean;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public static synthetic fun booleanArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Boolean;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final fun booleanPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Boolean;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public static synthetic fun booleanPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Boolean;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final fun floatArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Float;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public static synthetic fun floatArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Float;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final fun floatPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Float;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public static synthetic fun floatPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Float;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final fun intArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Integer;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public static synthetic fun intArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Integer;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final fun intPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Integer;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public static synthetic fun intPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Integer;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final fun longArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Long;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public static synthetic fun longArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Long;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final fun longPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Long;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public static synthetic fun longPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Long;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final fun stringArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/String;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public static synthetic fun stringArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/String;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final fun stringPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public static synthetic fun stringPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun booleanArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Boolean;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun booleanArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Boolean;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun booleanPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Boolean;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun booleanPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Boolean;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun floatArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Float;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun floatArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Float;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun floatPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Float;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun floatPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Float;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun intArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Integer;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun intArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Integer;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun intPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Integer;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun intPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Integer;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun longArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Long;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun longArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Long;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun longPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Long;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun longPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Long;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun registerNewPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLjava/lang/String;Lkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun registerNewPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLjava/lang/String;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun stringArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/String;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun stringArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/String;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun stringPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun stringPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
 }

 public abstract class app/revanced/patcher/patch/options/PatchOptionException : java/lang/Exception {
--- a/assets/revanced-headline/revanced-headline-vertical-dark.svg
+++ b/assets/revanced-headline/revanced-headline-vertical-dark.svg
--- a/assets/revanced-headline/revanced-headline-vertical-light.svg
+++ b/assets/revanced-headline/revanced-headline-vertical-light.svg
--- a/assets/revanced-logo/revanced-logo.svg
+++ b/assets/revanced-logo/revanced-logo.svg
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg width="100%" height="100%" viewBox="0 0 800 800" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;"><g id="Logo"><g id="Ring"><circle id="Ring-Background" serif:id="Ring Background" cx="400" cy="400" r="400" style="fill:#1b1b1b;"/><path id="Ring1" serif:id="Ring" d="M400,0c220.766,0 400,179.234 400,400c-0,220.766 -179.234,400 -400,400c-220.766,-0 -400,-179.234 -400,-400c0,-220.766 179.234,-400 400,-400Zm-0,36c200.897,-0 364,163.103 364,364c0,200.897 -163.103,364 -364,364c-200.897,0 -364,-163.103 -364,-364c-0,-200.897 163.103,-364 364,-364Z" style="fill:url(#_Linear1);"/></g><g id="Shape"><path id="V-Shape" serif:id="V Shape" d="M538.74,269.872c1.481,-3.382 1.157,-7.283 -0.863,-10.373c-2.021,-3.091 -5.464,-4.954 -9.156,-4.954c-5.148,0 -10.435,0 -14.165,0c-3.1,0 -5.907,1.834 -7.153,4.672c-12.468,28.396 -78.273,178.273 -100.25,228.328c-1.246,2.838 -4.053,4.671 -7.154,4.671c-3.1,0 -5.907,-1.833 -7.153,-4.671c-21.977,-50.055 -87.782,-199.932 -100.25,-228.328c-1.246,-2.838 -4.053,-4.672 -7.153,-4.672c-3.73,0 -9.017,0 -14.164,0c-3.693,0 -7.135,1.863 -9.156,4.954c-2.02,3.09 -2.344,6.991 -0.863,10.373c23.557,53.766 101.872,232.519 117.871,269.034c1.743,3.979 5.674,6.549 10.018,6.549c6.293,-0 15.408,-0 21.701,-0c4.344,-0 8.275,-2.57 10.018,-6.549c15.999,-36.515 94.315,-215.268 117.872,-269.034Z" style="fill:#fff;"/><path id="Diamond" d="M408.119,395.312c-1.675,2.901 -4.77,4.688 -8.119,4.688c-3.349,-0 -6.444,-1.787 -8.119,-4.688c-16.997,-29.44 -56.156,-97.264 -73.153,-126.704c-1.675,-2.901 -1.675,-6.474 0,-9.375c1.675,-2.901 4.77,-4.688 8.119,-4.688c33.995,0 112.311,0 146.306,0c3.349,0 6.444,1.787 8.119,4.688c1.675,2.901 1.675,6.474 -0,9.375c-16.997,29.44 -56.156,97.264 -73.153,126.704Z" style="fill:url(#_Linear2);"/></g></g><defs><linearGradient id="_Linear1" x1="0" y1="0" x2="1" y2="0" gradientUnits="userSpaceOnUse" gradientTransform="matrix(4.89859e-14,800,-800,4.89859e-14,400.001,3.31681e-10)"><stop offset="0" style="stop-color:#f04e98;stop-opacity:1"/><stop offset="0.5" style="stop-color:#5f65d4;stop-opacity:1"/><stop offset="1" style="stop-color:#4e98f0;stop-opacity:1"/></linearGradient><linearGradient id="_Linear2" x1="0" y1="0" x2="1" y2="0" gradientUnits="userSpaceOnUse" gradientTransform="matrix(1.77155e-14,289.317,-282.535,1.73003e-14,400,254.545)"><stop offset="0" style="stop-color:#f04e98;stop-opacity:1"/><stop offset="0.5" style="stop-color:#5f65d4;stop-opacity:1"/><stop offset="1" style="stop-color:#4e98f0;stop-opacity:1"/></linearGradient></defs></svg>
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,5 +1,5 @@
 plugins {
-    kotlin("jvm") version "1.9.0"
+    kotlin("jvm") version "1.9.10"
    alias(libs.plugins.binary.compatibility.validator)
    `maven-publish`
    signing
@@ -83,4 +83,4 @@ publishing {
            }
        }
    }
-}
+}
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,4 +1,4 @@
 org.gradle.parallel = true
 org.gradle.caching = true
 kotlin.code.style = official
-version = 18.0.0-dev.2
+version = 19.2.0-dev.1
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,8 +1,8 @@
 [versions]
 android = "4.1.1.4"
-kotlin-reflect = "1.9.0"
+kotlin-reflect = "1.9.10"
 apktool-lib = "2.9.1"
-kotlin-test = "1.8.20-RC"
+kotlin-test = "1.9.20"
 kotlinx-coroutines-core = "1.7.3"
 multidexlib2 = "3.0.3.r3"
 smali = "3.0.3"
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,7 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
+distributionSha256Sum=3e1af3ae886920c3ac87f7a91f816c0c7c436f276a6eefdb3da152100fef72ae
 zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
+zipStorePath=wrapper/dist
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,9 +1,9 @@
 {
  "devDependencies": {
-    "@saithodev/semantic-release-backmerge": "^3.1.0",
-    "@semantic-release/changelog": "^6.0.2",
+    "@saithodev/semantic-release-backmerge": "^3.2.1",
+    "@semantic-release/changelog": "^6.0.3",
    "@semantic-release/git": "^10.0.1",
-    "gradle-semantic-release-plugin": "^1.7.6",
-    "semantic-release": "^20.1.0"
+    "gradle-semantic-release-plugin": "^1.8.0",
+    "semantic-release": "^22.0.8"
  }
 }
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1 +1,7 @@
-rootProject.name = "revanced-patcher"
+rootProject.name = "revanced-patcher"
+
+buildCache {
+    local {
+        isEnabled = "CI" !in System.getenv()
+    }
+}
--- a/src/main/kotlin/app/revanced/patcher/IntegrationsConsumer.kt
+++ b/src/main/kotlin/app/revanced/patcher/IntegrationsConsumer.kt
@@ -5,4 +5,4 @@ import java.io.File
@FunctionalInterface
 interface IntegrationsConsumer {
    fun acceptIntegrations(integrations: List<File>)
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/PatchBundleLoader.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatchBundleLoader.kt
@@ -12,6 +12,7 @@ import java.util.jar.JarFile
 import java.util.logging.Logger
 import kotlin.reflect.KClass

+
 /**
 * A set of [Patch]es.
 */
@@ -37,7 +38,7 @@ sealed class PatchBundleLoader private constructor(
    // This constructor parameter is unfortunately necessary,
    // so that a reference to the mutable set is present in the constructor to be able to add patches to it.
    // because the instance itself is a PatchSet, which is immutable, that is delegated by the parameter.
-    private val patchSet: MutableSet<Patch<*>> = mutableSetOf()
+    private val patchSet: MutableSet<Patch<*>> = mutableSetOf(),
 ) : PatchSet by patchSet {
    private val logger = Logger.getLogger(PatchBundleLoader::class.java.name)

@@ -63,22 +64,29 @@ sealed class PatchBundleLoader private constructor(
         * @param silent Whether to suppress logging.
         * @return The instantiated [Patch] or `null` if the [Patch] could not be instantiated.
         */
-        internal fun Class<*>.getInstance(logger: Logger, silent: Boolean = false): Patch<*>? {
+        internal fun Class<*>.getInstance(
+            logger: Logger,
+            silent: Boolean = false,
+        ): Patch<*>? {
            return try {
                getField("INSTANCE").get(null)
            } catch (exception: NoSuchFieldException) {
-                if (!silent) logger.fine(
-                    "Patch class '${name}' has no INSTANCE field, therefor not a singleton. " +
-                            "Will try to instantiate it."
-                )
+                if (!silent) {
+                    logger.fine(
+                        "Patch class '$name' has no INSTANCE field, therefor not a singleton. " +
+                                "Attempting to instantiate it.",
+                    )
+                }

                try {
                    getDeclaredConstructor().newInstance()
                } catch (exception: Exception) {
-                    if (!silent) logger.severe(
-                        "Patch class '${name}' is not singleton and has no suitable constructor, " +
-                                "therefor cannot be instantiated and will be ignored."
-                    )
+                    if (!silent) {
+                        logger.severe(
+                            "Patch class '$name' is not singleton and has no suitable constructor, " +
+                                    "therefor cannot be instantiated and is ignored.",
+                        )
+                    }

                    return null
                }
@@ -97,7 +105,7 @@ sealed class PatchBundleLoader private constructor(
        { patchBundle ->
            JarFile(patchBundle).entries().toList().filter { it.name.endsWith(".class") }
                .map { it.name.replace('/', '.').replace(".class", "") }
-        }
+        },
    )

    /**
@@ -109,9 +117,10 @@ sealed class PatchBundleLoader private constructor(
     */
    class Dex(vararg patchBundles: File, optimizedDexDirectory: File? = null) : PatchBundleLoader(
        DexClassLoader(
-            patchBundles.joinToString(File.pathSeparator) { it.absolutePath }, optimizedDexDirectory?.absolutePath,
+            patchBundles.joinToString(File.pathSeparator) { it.absolutePath },
+            optimizedDexDirectory?.absolutePath,
            null,
-            PatchBundleLoader::class.java.classLoader
+            PatchBundleLoader::class.java.classLoader,
        ),
        patchBundles,
        { patchBundle ->
@@ -119,9 +128,9 @@ sealed class PatchBundleLoader private constructor(
                .map { classDef ->
                    classDef.type.substring(1, classDef.length - 1)
                }
-        }
+        },
    ) {
        @Deprecated("This constructor is deprecated. Use the constructor with the second parameter instead.")
        constructor(vararg patchBundles: File) : this(*patchBundles, optimizedDexDirectory = null)
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/PatchExecutorFunction.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatchExecutorFunction.kt
@@ -5,4 +5,4 @@ import kotlinx.coroutines.flow.Flow
 import java.util.function.Function

@FunctionalInterface
-interface PatchExecutorFunction : Function<Boolean, Flow<PatchResult>>
+interface PatchExecutorFunction : Function<Boolean, Flow<PatchResult>>
--- a/src/main/kotlin/app/revanced/patcher/Patcher.kt
+++ b/src/main/kotlin/app/revanced/patcher/Patcher.kt
@@ -2,8 +2,8 @@ package app.revanced.patcher

 import app.revanced.patcher.PatchBundleLoader.Utils.getInstance
 import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolveUsingLookupMap
+import app.revanced.patcher.fingerprint.LookupMap
+import app.revanced.patcher.fingerprint.MethodFingerprint.Companion.resolveUsingLookupMap
 import app.revanced.patcher.patch.*
 import kotlinx.coroutines.flow.flow
 import java.io.Closeable
@@ -17,7 +17,7 @@ import java.util.logging.Logger
 * @param options The options for the patcher.
 */
 class Patcher(
-    private val options: PatcherOptions
+    private val options: PatcherOptions,
 ) : PatchExecutorFunction, PatchesConsumer, IntegrationsConsumer, Supplier<PatcherResult>, Closeable {
    private val logger = Logger.getLogger(Patcher::class.java.name)

@@ -39,13 +39,14 @@ class Patcher(
    //  * @param patches The [Patch]es to add.
    //  * @throws PatcherException.CircularDependencyException If a circular dependency is detected.
    // */
+
    /**
     * Add [Patch]es to ReVanced [Patcher].
     *
     * @param patches The [Patch]es to add.
-    */
+     */
    @Suppress("NAME_SHADOWING")
-    override fun acceptPatches(patches: List<Patch<*>>) {
+    override fun acceptPatches(patches: PatchSet) {
        /**
         * Add dependencies of a [Patch] recursively to [PatcherContext.allPatches].
         * If a [Patch] is already in [PatcherContext.allPatches], it will not be added again.
@@ -82,7 +83,7 @@ class Patcher(
                dependency.visit()
            }
        }
-        */
+         */

        /**
         * Returns true if at least one patch or its dependencies matches the given predicate.
@@ -126,140 +127,142 @@ class Patcher(
     * @param returnOnError If true, ReVanced [Patcher] will return immediately if a [Patch] fails.
     * @return A pair of the name of the [Patch] and its [PatchResult].
     */
-    override fun apply(returnOnError: Boolean) = flow {
+    override fun apply(returnOnError: Boolean) =
+        flow {
+            /**
+             * Execute a [Patch] and its dependencies recursively.
+             *
+             * @param patch The [Patch] to execute.
+             * @param executedPatches A map to prevent [Patch]es from being executed twice due to dependencies.
+             * @return The result of executing the [Patch].
+             */
+            fun executePatch(
+                patch: Patch<*>,
+                executedPatches: LinkedHashMap<Patch<*>, PatchResult>,
+            ): PatchResult {
+                val patchName = patch.name ?: patch.toString()

-        /**
-         * Execute a [Patch] and its dependencies recursively.
-         *
-         * @param patch The [Patch] to execute.
-         * @param executedPatches A map to prevent [Patch]es from being executed twice due to dependencies.
-         * @return The result of executing the [Patch].
-         */
-        fun executePatch(
-            patch: Patch<*>,
-            executedPatches: LinkedHashMap<Patch<*>, PatchResult>
-        ): PatchResult {
-            val patchName = patch.name ?: patch.toString()
+                executedPatches[patch]?.let { patchResult ->
+                    patchResult.exception ?: return patchResult

-            executedPatches[patch]?.let { patchResult ->
-                patchResult.exception ?: return patchResult
+                    // Return a new result with an exception indicating that the patch was not executed previously,
+                    // because it is a dependency of another patch that failed.
+                    return PatchResult(patch, PatchException("'$patchName' did not succeed previously"))
+                }

-                // Return a new result with an exception indicating that the patch was not executed previously,
-                // because it is a dependency of another patch that failed.
-                return PatchResult(patch, PatchException("'$patchName' did not succeed previously"))
-            }
+                // Recursively execute all dependency patches.
+                patch.dependencies?.forEach { dependencyClass ->
+                    val dependency = context.allPatches[dependencyClass]!!
+                    val result = executePatch(dependency, executedPatches)

-            // Recursively execute all dependency patches.
-            patch.dependencies?.forEach { dependencyClass ->
-                val dependency = context.allPatches[dependencyClass]!!
-                val result = executePatch(dependency, executedPatches)
-
-                result.exception?.let {
-                    return PatchResult(
-                        patch,
-                        PatchException(
-                            "'$patchName' depends on '${dependency.name ?: dependency}' " +
-                                    "that raised an exception:\n${it.stackTraceToString()}"
+                    result.exception?.let {
+                        return PatchResult(
+                            patch,
+                            PatchException(
+                                "'$patchName' depends on '${dependency.name ?: dependency}' " +
+                                    "that raised an exception:\n${it.stackTraceToString()}",
+                            ),
                        )
-                    )
-                }
-            }
-
-            return try {
-                // TODO: Implement this in a more polymorphic way.
-                when (patch) {
-                    is BytecodePatch -> {
-                        patch.fingerprints.resolveUsingLookupMap(context.bytecodeContext)
-                        patch.execute(context.bytecodeContext)
-                    }
-                    is ResourcePatch -> {
-                        patch.execute(context.resourceContext)
                    }
                }

-                PatchResult(patch)
-            } catch (exception: PatchException) {
-                PatchResult(patch, exception)
-            } catch (exception: Exception) {
-                PatchResult(patch, PatchException(exception))
-            }.also { executedPatches[patch] = it }
-        }
+                return try {
+                    // TODO: Implement this in a more polymorphic way.
+                    when (patch) {
+                        is BytecodePatch -> {
+                            patch.fingerprints.resolveUsingLookupMap(context.bytecodeContext)
+                            patch.execute(context.bytecodeContext)
+                        }
+                        is ResourcePatch -> {
+                            patch.execute(context.resourceContext)
+                        }
+                    }

-        if (context.bytecodeContext.integrations.merge) context.bytecodeContext.integrations.flush()
-
-        MethodFingerprint.initializeFingerprintResolutionLookupMaps(context.bytecodeContext)
-
-        // Prevent from decoding the app manifest twice if it is not needed.
-        if (options.resourceDecodingMode == ResourceContext.ResourceDecodingMode.FULL)
-            context.resourceContext.decodeResources(ResourceContext.ResourceDecodingMode.FULL)
-
-        logger.info("Executing patches")
-
-        val executedPatches = LinkedHashMap<Patch<*>, PatchResult>() // Key is name.
-
-        context.executablePatches.values.sortedBy { it.name }.forEach { patch ->
-            val patchResult = executePatch(patch, executedPatches)
-
-            // If the patch failed, emit the result, even if it is closeable.
-            // Results of executed patches that are closeable will be emitted later.
-            patchResult.exception?.let {
-                // Propagate exception to caller instead of wrapping it in a new exception.
-                emit(patchResult)
-
-                if (returnOnError) return@flow
-            } ?: run {
-                if (patch is Closeable) return@run
-
-                emit(patchResult)
-            }
-        }
-
-        executedPatches.values
-            .filter { it.exception == null }
-            .filter { it.patch is Closeable }.asReversed().forEach { executedPatch ->
-                val patch = executedPatch.patch
-
-                val result = try {
-                    (patch as Closeable).close()
-
-                    executedPatch
+                    PatchResult(patch)
                } catch (exception: PatchException) {
                    PatchResult(patch, exception)
                } catch (exception: Exception) {
                    PatchResult(patch, PatchException(exception))
-                }
+                }.also { executedPatches[patch] = it }
+            }

-                result.exception?.let {
-                    emit(
-                        PatchResult(
-                            patch,
-                            PatchException(
-                                "'${patch.name}' raised an exception while being closed: ${it.stackTraceToString()}",
-                                result.exception
-                            )
-                        )
-                    )
+            if (context.bytecodeContext.integrations.merge) context.bytecodeContext.integrations.flush()
+
+            LookupMap.initializeLookupMaps(context.bytecodeContext)
+
+            // Prevent from decoding the app manifest twice if it is not needed.
+            if (options.resourceDecodingMode == ResourceContext.ResourceDecodingMode.FULL) {
+                context.resourceContext.decodeResources(ResourceContext.ResourceDecodingMode.FULL)
+            }
+
+            logger.info("Executing patches")
+
+            val executedPatches = LinkedHashMap<Patch<*>, PatchResult>() // Key is name.
+
+            context.executablePatches.values.sortedBy { it.name }.forEach { patch ->
+                val patchResult = executePatch(patch, executedPatches)
+
+                // If the patch failed, emit the result, even if it is closeable.
+                // Results of executed patches that are closeable will be emitted later.
+                patchResult.exception?.let {
+                    // Propagate exception to caller instead of wrapping it in a new exception.
+                    emit(patchResult)

                    if (returnOnError) return@flow
                } ?: run {
-                    patch.name ?: return@run
+                    if (patch is Closeable) return@run

-                    emit(result)
+                    emit(patchResult)
                }
            }
-    }

-    override fun close() = MethodFingerprint.clearFingerprintResolutionLookupMaps()
+            executedPatches.values
+                .filter { it.exception == null }
+                .filter { it.patch is Closeable }.asReversed().forEach { executedPatch ->
+                    val patch = executedPatch.patch
+
+                    val result =
+                        try {
+                            (patch as Closeable).close()
+
+                            executedPatch
+                        } catch (exception: PatchException) {
+                            PatchResult(patch, exception)
+                        } catch (exception: Exception) {
+                            PatchResult(patch, PatchException(exception))
+                        }
+
+                    result.exception?.let {
+                        emit(
+                            PatchResult(
+                                patch,
+                                PatchException(
+                                    "'${patch.name}' raised an exception while being closed: ${it.stackTraceToString()}",
+                                    result.exception,
+                                ),
+                            ),
+                        )
+
+                        if (returnOnError) return@flow
+                    } ?: run {
+                        patch.name ?: return@run
+
+                        emit(result)
+                    }
+                }
+        }
+
+    override fun close() = LookupMap.clearLookupMaps()

    /**
     * Compile and save the patched APK file.
     *
     * @return The [PatcherResult] containing the patched input files.
     */
-    override fun get() = PatcherResult(
-        context.bytecodeContext.get(),
-        context.resourceContext.get(),
-        context.packageMetadata.apkInfo.doNotCompress?.toList()
-    )
+    override fun get() =
+        PatcherResult(
+            context.bytecodeContext.get(),
+            context.resourceContext.get(),
+            context.packageMetadata.apkInfo.doNotCompress?.toList(),
+        )
 }
-
--- a/src/main/kotlin/app/revanced/patcher/PatcherContext.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatcherContext.kt
@@ -38,4 +38,4 @@ class PatcherContext internal constructor(options: PatcherOptions) {
     * This holds the current state of the bytecode.
     */
    internal val bytecodeContext = BytecodeContext(options)
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/PatcherException.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatcherException.kt
@@ -9,8 +9,7 @@ package app.revanced.patcher
 sealed class PatcherException(errorMessage: String?, cause: Throwable?) : Exception(errorMessage, cause) {
    constructor(errorMessage: String) : this(errorMessage, null)

-
    class CircularDependencyException internal constructor(dependant: String) : PatcherException(
-        "Patch '$dependant' causes a circular dependency"
+        "Patch '$dependant' causes a circular dependency",
    )
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/PatcherOptions.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatcherOptions.kt
@@ -32,41 +32,23 @@ data class PatcherOptions(
    /**
     * The configuration to use for resource decoding and compiling.
     */
-    internal val resourceConfig = Config.getDefaultConfig().apply {
-        useAapt2 = true
-        aaptPath = aaptBinaryPath ?: ""
-        frameworkDirectory = frameworkFileDirectory
-    }
-
-    /**
-     * Options for ReVanced [Patcher].
-     * @param inputFile The input file to patch.
-     * @param resourceCachePath The path to the directory to use for caching resources.
-     * @param aaptBinaryPath The path to a custom aapt binary.
-     * @param frameworkFileDirectory The path to the directory to cache the framework file in.
-     */
-    @Deprecated("Use the constructor with the multithreadingDexFileWriter parameter instead")
-    constructor(
-        inputFile: File,
-        resourceCachePath: File = File("revanced-resource-cache"),
-        aaptBinaryPath: String? = null,
-        frameworkFileDirectory: String? = null,
-    ) : this(
-        inputFile,
-        resourceCachePath,
-        aaptBinaryPath,
-        frameworkFileDirectory,
-        false,
-    )
-
-    fun recreateResourceCacheDirectory() = resourceCachePath.also {
-        if (it.exists()) {
-            logger.info("Deleting existing resource cache directory")
-
-            if (!it.deleteRecursively())
-                logger.severe("Failed to delete existing resource cache directory")
+    internal val resourceConfig =
+        Config.getDefaultConfig().apply {
+            useAapt2 = true
+            aaptPath = aaptBinaryPath ?: ""
+            frameworkDirectory = frameworkFileDirectory
        }

-        it.mkdirs()
-    }
+    fun recreateResourceCacheDirectory() =
+        resourceCachePath.also {
+            if (it.exists()) {
+                logger.info("Deleting existing resource cache directory")
+
+                if (!it.deleteRecursively()) {
+                    logger.severe("Failed to delete existing resource cache directory")
+                }
+            }
+
+            it.mkdirs()
+        }
 }
--- a/src/main/kotlin/app/revanced/patcher/PatcherResult.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatcherResult.kt
@@ -12,7 +12,7 @@ import java.io.InputStream
 data class PatcherResult(
    val dexFiles: List<PatchedDexFile>,
    val resourceFile: File?,
-    val doNotCompress: List<String>? = null
+    val doNotCompress: List<String>? = null,
 ) {
    /**
     * Wrapper for dex files.
@@ -20,4 +20,4 @@ data class PatcherResult(
     * @param stream The dex file as [InputStream].
     */
    class PatchedDexFile(val name: String, val stream: InputStream)
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/PatchesConsumer.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatchesConsumer.kt
@@ -4,5 +4,7 @@ import app.revanced.patcher.patch.Patch

@FunctionalInterface
 interface PatchesConsumer {
-    fun acceptPatches(patches: List<Patch<*>>)
-}
+    @Deprecated("Use acceptPatches(PatchSet) instead.", ReplaceWith("acceptPatches(patches.toSet())"))
+    fun acceptPatches(patches: List<Patch<*>>) = acceptPatches(patches.toSet())
+    fun acceptPatches(patches: PatchSet)
+}
--- a/src/main/kotlin/app/revanced/patcher/data/BytecodeContext.kt
+++ b/src/main/kotlin/app/revanced/patcher/data/BytecodeContext.kt
@@ -28,141 +28,153 @@ import java.util.logging.Logger
 */
 class BytecodeContext internal constructor(private val options: PatcherOptions) :
    Context<List<PatcherResult.PatchedDexFile>> {
-    private val logger = Logger.getLogger(BytecodeContext::class.java.name)
-
-    /**
-     * [Opcodes] of the supplied [PatcherOptions.inputFile].
-     */
-    internal lateinit var opcodes: Opcodes
-
-    /**
-     * The list of classes.
-     */
-    val classes by lazy {
-        ProxyClassList(
-            MultiDexIO.readDexFile(
-                true, options.inputFile, BasicDexFileNamer(), null, null
-            ).also { opcodes = it.opcodes }.classes.toMutableSet()
-        )
-    }
-
-    /**
-     * The [Integrations] of this [PatcherContext].
-     */
-    internal val integrations = Integrations()
-
-    /**
-     * Find a class by a given class name.
-     *
-     * @param className The name of the class.
-     * @return A proxy for the first class that matches the class name.
-     */
-    fun findClass(className: String) = findClass { it.type.contains(className) }
-
-    /**
-     * Find a class by a given predicate.
-     *
-     * @param predicate A predicate to match the class.
-     * @return A proxy for the first class that matches the predicate.
-     */
-    fun findClass(predicate: (ClassDef) -> Boolean) =
-        // if we already proxied the class matching the predicate...
-        classes.proxies.firstOrNull { predicate(it.immutableClass) } ?:
-        // else resolve the class to a proxy and return it, if the predicate is matching a class
-        classes.find(predicate)?.let { proxy(it) }
-
-    /**
-     * Proxy a class.
-     * This will allow the class to be modified.
-     *
-     * @param classDef The class to proxy.
-     * @return A proxy for the class.
-     */
-    fun proxy(classDef: ClassDef) = this.classes.proxies.find { it.immutableClass.type == classDef.type } ?: let {
-        ClassProxy(classDef).also { this.classes.add(it) }
-    }
-
-    /**
-     * Create a [MethodWalker] instance for the current [BytecodeContext].
-     *
-     * @param startMethod The method to start at.
-     * @return A [MethodWalker] instance.
-     */
-    fun toMethodWalker(startMethod: Method) = MethodWalker(this, startMethod)
-
-    /**
-     * Compile bytecode from the [BytecodeContext].
-     *
-     * @return The compiled bytecode.
-     */
-    override fun get(): List<PatcherResult.PatchedDexFile> {
-        logger.info("Compiling patched dex files")
-
-        val patchedDexFileResults = options.resourceCachePath.resolve("dex").also {
-            it.deleteRecursively() // Make sure the directory is empty.
-            it.mkdirs()
-        }.apply {
-            MultiDexIO.writeDexFile(
-                true,
-                if (options.multithreadingDexFileWriter) -1 else 1,
-                this,
-                BasicDexFileNamer(),
-                object : DexFile {
-                    override fun getClasses() = this@BytecodeContext.classes.also(ProxyClassList::replaceClasses)
-                    override fun getOpcodes() = this@BytecodeContext.opcodes
-                },
-                DexIO.DEFAULT_MAX_DEX_POOL_SIZE
-            ) { _, entryName, _ -> logger.info("Compiled $entryName") }
-        }.listFiles(FileFilter { it.isFile })!!.map { PatcherResult.PatchedDexFile(it.name, it.inputStream()) }
-
-        System.gc()
-
-        return patchedDexFileResults
-    }
-
-    /**
-     * The integrations of a [PatcherContext].
-     */
-    internal inner class Integrations : MutableList<File> by mutableListOf(), Flushable {
-        /**
-         * Whether to merge integrations.
-         * Set to true, if the field requiresIntegrations of any supplied [Patch] is true.
-         */
-        var merge = false
+        private val logger = Logger.getLogger(BytecodeContext::class.java.name)

        /**
-         * Merge integrations into the [BytecodeContext] and flush all [Integrations].
+         * [Opcodes] of the supplied [PatcherOptions.inputFile].
         */
-        override fun flush() {
-            if (!merge) return
+        internal lateinit var opcodes: Opcodes

-            logger.info("Merging integrations")
-
-            val classMap = classes.associateBy { it.type }
-
-            this@Integrations.forEach { integrations ->
+        /**
+         * The list of classes.
+         */
+        val classes by lazy {
+            ProxyClassList(
                MultiDexIO.readDexFile(
                    true,
-                    integrations, BasicDexFileNamer(),
+                    options.inputFile,
+                    BasicDexFileNamer(),
                    null,
-                    null
-                ).classes.forEach classDef@{ classDef ->
-                    val existingClass = classMap[classDef.type] ?: run {
-                        logger.fine("Adding $classDef")
-                        classes.add(classDef)
-                        return@classDef
-                    }
+                    null,
+                ).also { opcodes = it.opcodes }.classes.toMutableSet(),
+            )
+        }

-                    logger.fine("$classDef exists. Adding missing methods and fields.")
+        /**
+         * The [Integrations] of this [PatcherContext].
+         */
+        internal val integrations = Integrations()

-                    existingClass.merge(classDef, this@BytecodeContext).let { mergedClass ->
-                        // If the class was merged, replace the original class with the merged class.
-                        if (mergedClass === existingClass) return@let
-                        classes.apply { remove(existingClass); add(mergedClass) }
+        /**
+         * Find a class by a given class name.
+         *
+         * @param className The name of the class.
+         * @return A proxy for the first class that matches the class name.
+         */
+        fun findClass(className: String) = findClass { it.type.contains(className) }
+
+        /**
+         * Find a class by a given predicate.
+         *
+         * @param predicate A predicate to match the class.
+         * @return A proxy for the first class that matches the predicate.
+         */
+        fun findClass(predicate: (ClassDef) -> Boolean) =
+            // if we already proxied the class matching the predicate...
+            classes.proxies.firstOrNull { predicate(it.immutableClass) }
+                ?: // else resolve the class to a proxy and return it, if the predicate is matching a class
+                classes.find(predicate)?.let { proxy(it) }
+
+        /**
+         * Proxy a class.
+         * This will allow the class to be modified.
+         *
+         * @param classDef The class to proxy.
+         * @return A proxy for the class.
+         */
+        fun proxy(classDef: ClassDef) =
+            this.classes.proxies.find { it.immutableClass.type == classDef.type } ?: let {
+                ClassProxy(classDef).also { this.classes.add(it) }
+            }
+
+        /**
+         * Create a [MethodWalker] instance for the current [BytecodeContext].
+         *
+         * @param startMethod The method to start at.
+         * @return A [MethodWalker] instance.
+         */
+        fun toMethodWalker(startMethod: Method) = MethodWalker(this, startMethod)
+
+        /**
+         * Compile bytecode from the [BytecodeContext].
+         *
+         * @return The compiled bytecode.
+         */
+        override fun get(): List<PatcherResult.PatchedDexFile> {
+            logger.info("Compiling patched dex files")
+
+            val patchedDexFileResults =
+                options.resourceCachePath.resolve("dex").also {
+                    it.deleteRecursively() // Make sure the directory is empty.
+                    it.mkdirs()
+                }.apply {
+                    MultiDexIO.writeDexFile(
+                        true,
+                        if (options.multithreadingDexFileWriter) -1 else 1,
+                        this,
+                        BasicDexFileNamer(),
+                        object : DexFile {
+                            override fun getClasses() = this@BytecodeContext.classes.also(ProxyClassList::replaceClasses)
+
+                            override fun getOpcodes() = this@BytecodeContext.opcodes
+                        },
+                        DexIO.DEFAULT_MAX_DEX_POOL_SIZE,
+                    ) { _, entryName, _ -> logger.info("Compiled $entryName") }
+                }.listFiles(FileFilter { it.isFile })!!.map { PatcherResult.PatchedDexFile(it.name, it.inputStream()) }
+
+            System.gc()
+
+            return patchedDexFileResults
+        }
+
+        /**
+         * The integrations of a [PatcherContext].
+         */
+        internal inner class Integrations : MutableList<File> by mutableListOf(), Flushable {
+            /**
+             * Whether to merge integrations.
+             * Set to true, if the field requiresIntegrations of any supplied [Patch] is true.
+             */
+            var merge = false
+
+            /**
+             * Merge integrations into the [BytecodeContext] and flush all [Integrations].
+             */
+            override fun flush() {
+                if (!merge) return
+
+                logger.info("Merging integrations")
+
+                val classMap = classes.associateBy { it.type }
+
+                this@Integrations.forEach { integrations ->
+                    MultiDexIO.readDexFile(
+                        true,
+                        integrations,
+                        BasicDexFileNamer(),
+                        null,
+                        null,
+                    ).classes.forEach classDef@{ classDef ->
+                        val existingClass =
+                            classMap[classDef.type] ?: run {
+                                logger.fine("Adding $classDef")
+                                classes.add(classDef)
+                                return@classDef
+                            }
+
+                        logger.fine("$classDef exists. Adding missing methods and fields.")
+
+                        existingClass.merge(classDef, this@BytecodeContext).let { mergedClass ->
+                            // If the class was merged, replace the original class with the merged class.
+                            if (mergedClass === existingClass) return@let
+                            classes.apply {
+                                remove(existingClass)
+                                add(mergedClass)
+                            }
+                        }
                    }
                }
+                clear()
            }
-            clear()
        }
    }
-}
--- a/src/main/kotlin/app/revanced/patcher/data/Context.kt
+++ b/src/main/kotlin/app/revanced/patcher/data/Context.kt
@@ -6,4 +6,4 @@ import java.util.function.Supplier
 * A common interface for contexts such as [ResourceContext] and [BytecodeContext].
 */

-sealed interface Context<T> : Supplier<T>
+sealed interface Context<T> : Supplier<T>
--- a/src/main/kotlin/app/revanced/patcher/data/ResourceContext.kt
+++ b/src/main/kotlin/app/revanced/patcher/data/ResourceContext.kt
@@ -26,7 +26,7 @@ import java.util.logging.Logger
 */
 class ResourceContext internal constructor(
    private val context: PatcherContext,
-    private val options: PatcherOptions
+    private val options: PatcherOptions,
 ) : Context<File?>, Iterable<File> {
    private val logger = Logger.getLogger(ResourceContext::class.java.name)

@@ -37,52 +37,54 @@ class ResourceContext internal constructor(
     *
     * @param mode The [ResourceDecodingMode] to use when decoding.
     */
-    internal fun decodeResources(mode: ResourceDecodingMode) = with(context.packageMetadata.apkInfo) {
-        // Needed to decode resources.
-        val resourcesDecoder = ResourcesDecoder(options.resourceConfig, this)
+    internal fun decodeResources(mode: ResourceDecodingMode) =
+        with(context.packageMetadata.apkInfo) {
+            // Needed to decode resources.
+            val resourcesDecoder = ResourcesDecoder(options.resourceConfig, this)

-        when (mode) {
-            ResourceDecodingMode.FULL -> {
-                val outDir = options.recreateResourceCacheDirectory()
+            when (mode) {
+                ResourceDecodingMode.FULL -> {
+                    val outDir = options.recreateResourceCacheDirectory()

-                logger.info("Decoding resources")
+                    logger.info("Decoding resources")

-                resourcesDecoder.decodeResources(outDir)
-                resourcesDecoder.decodeManifest(outDir)
+                    resourcesDecoder.decodeResources(outDir)
+                    resourcesDecoder.decodeManifest(outDir)

-                // Needed to record uncompressed files.
-                val apkDecoder = ApkDecoder(options.resourceConfig, this)
-                apkDecoder.recordUncompressedFiles(resourcesDecoder.resFileMapping)
+                    // Needed to record uncompressed files.
+                    val apkDecoder = ApkDecoder(options.resourceConfig, this)
+                    apkDecoder.recordUncompressedFiles(resourcesDecoder.resFileMapping)

-                usesFramework = UsesFramework().apply {
-                    ids = resourcesDecoder.resTable.listFramePackages().map { it.id }
-                }
-            }
-
-            ResourceDecodingMode.MANIFEST_ONLY -> {
-                logger.info("Decoding app manifest")
-
-                // Decode manually instead of using resourceDecoder.decodeManifest
-                // because it does not support decoding to an OutputStream.
-                XmlPullStreamDecoder(
-                    AndroidManifestResourceParser(resourcesDecoder.resTable),
-                    resourcesDecoder.resXmlSerializer
-                ).decodeManifest(
-                    apkFile.directory.getFileInput("AndroidManifest.xml"),
-                    // Older Android versions do not support OutputStream.nullOutputStream()
-                    object : OutputStream() {
-                        override fun write(b: Int) { /* do nothing */
+                    usesFramework =
+                        UsesFramework().apply {
+                            ids = resourcesDecoder.resTable.listFramePackages().map { it.id }
                        }
-                    }
-                )
+                }

-                // Get the package name and version from the manifest using the XmlPullStreamDecoder.
-                // XmlPullStreamDecoder.decodeManifest() sets metadata.apkInfo.
-                context.packageMetadata.let { metadata ->
-                    metadata.packageName = resourcesDecoder.resTable.packageRenamed
-                    versionInfo.let {
-                        metadata.packageVersion = it.versionName ?: it.versionCode
-                    }
+                ResourceDecodingMode.MANIFEST_ONLY -> {
+                    logger.info("Decoding app manifest")
+
+                    // Decode manually instead of using resourceDecoder.decodeManifest
+                    // because it does not support decoding to an OutputStream.
+                    XmlPullStreamDecoder(
+                        AndroidManifestResourceParser(resourcesDecoder.resTable),
+                        resourcesDecoder.resXmlSerializer,
+                    ).decodeManifest(
+                        apkFile.directory.getFileInput("AndroidManifest.xml"),
+                        // Older Android versions do not support OutputStream.nullOutputStream()
+                        object : OutputStream() {
+                            override fun write(b: Int) { // do nothing
+                            }
+                        },
+                    )
+
+                    // Get the package name and version from the manifest using the XmlPullStreamDecoder.
+                    // XmlPullStreamDecoder.decodeManifest() sets metadata.apkInfo.
+                    context.packageMetadata.let { metadata ->
+                        metadata.packageName = resourcesDecoder.resTable.packageRenamed
+                        versionInfo.let {
+                            metadata.packageVersion = it.versionName ?: it.versionCode
+                        }

                    /*
                     The ResTable if flagged as sparse if the main package is not loaded, which is the case here,
@@ -92,18 +94,16 @@ class ResourceContext internal constructor(

                     Set this to false again to prevent the ResTable from being flagged as sparse falsely.
                     */
-                    metadata.apkInfo.sparseResources = false
+                        metadata.apkInfo.sparseResources = false
+                    }
                }
            }
        }

-    }
-
    operator fun get(path: String) = options.resourceCachePath.resolve(path)

    override fun iterator() = options.resourceCachePath.walkTopDown().iterator()

-
    /**
     * Compile resources from the [ResourceContext].
     *
@@ -116,14 +116,17 @@ class ResourceContext internal constructor(
            logger.info("Compiling modified resources")

            val cacheDirectory = ExtFile(options.resourceCachePath)
-            val aaptFile = cacheDirectory.resolve("aapt_temp_file").also {
-                Files.deleteIfExists(it.toPath())
-            }.also { resourceFile = it }
+            val aaptFile =
+                cacheDirectory.resolve("aapt_temp_file").also {
+                    Files.deleteIfExists(it.toPath())
+                }.also { resourceFile = it }

            try {
                AaptInvoker(
-                    options.resourceConfig, context.packageMetadata.apkInfo
-                ).invokeAapt(aaptFile,
+                    options.resourceConfig,
+                    context.packageMetadata.apkInfo,
+                ).invokeAapt(
+                    aaptFile,
                    cacheDirectory.resolve("AndroidManifest.xml").also {
                        ResXmlPatcher.fixingPublicAttrsInProviderAttributes(it)
                    },
@@ -134,7 +137,8 @@ class ResourceContext internal constructor(
                        usesFramework.ids.map { id ->
                            Framework(options.resourceConfig).getFrameworkApk(id, usesFramework.tag)
                        }.toTypedArray()
-                    })
+                    },
+                )
            } finally {
                cacheDirectory.close()
            }
@@ -159,12 +163,10 @@ class ResourceContext internal constructor(
    }

    inner class XmlFileHolder {
-        operator fun get(inputStream: InputStream) =
-            DomFileEditor(inputStream)
+        operator fun get(inputStream: InputStream) = DomFileEditor(inputStream)

        operator fun get(path: String): DomFileEditor {
            return DomFileEditor(this@ResourceContext[path])
        }
-
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/extensions/AnnotationExtensions.kt
+++ b/src/main/kotlin/app/revanced/patcher/extensions/AnnotationExtensions.kt
@@ -1,33 +1,61 @@
+@file:Suppress("UNCHECKED_CAST")
+
 package app.revanced.patcher.extensions

 import kotlin.reflect.KClass

 internal object AnnotationExtensions {
    /**
-     * Recursively find a given annotation on a class.
+     * Search for an annotation recursively.
     *
-     * @param targetAnnotation The annotation to find.
-     * @return The annotation.
+     * @param targetAnnotationClass The annotation class to search for.
+     * @param searchedClasses A set of annotations that have already been searched.
+     * @return The annotation if found, otherwise null.
     */
-    fun <T : Annotation> Class<*>.findAnnotationRecursively(targetAnnotation: KClass<T>): T? {
-        fun <T : Annotation> Class<*>.findAnnotationRecursively(
-            targetAnnotation: Class<T>, traversed: MutableSet<Annotation>
-        ): T? {
-            val found = this.annotations.firstOrNull { it.annotationClass.java.name == targetAnnotation.name }
+    fun <T : Annotation> Class<*>.findAnnotationRecursively(
+        targetAnnotationClass: Class<T>,
+        searchedClasses: HashSet<Annotation> = hashSetOf(),
+    ): T? {
+        annotations.forEach { annotation ->
+            // Terminate if the annotation is already searched.
+            if (annotation in searchedClasses) return@forEach
+            searchedClasses.add(annotation)

-            @Suppress("UNCHECKED_CAST") if (found != null) return found as T
+            // Terminate if the annotation is found.
+            if (targetAnnotationClass == annotation.annotationClass.java) return annotation as T

-            for (annotation in this.annotations) {
-                if (traversed.contains(annotation)) continue
-                traversed.add(annotation)
-
-                return (annotation.annotationClass.java.findAnnotationRecursively(targetAnnotation, traversed))
-                    ?: continue
-            }
-
-            return null
+            return annotation.annotationClass.java.findAnnotationRecursively(
+                targetAnnotationClass,
+                searchedClasses,
+            ) ?: return@forEach
        }

-        return this.findAnnotationRecursively(targetAnnotation.java, mutableSetOf())
+        // Search the super class.
+        superclass?.findAnnotationRecursively(
+            targetAnnotationClass,
+            searchedClasses,
+        )?.let { return it }
+
+        // Search the interfaces.
+        interfaces.forEach { superClass ->
+            return superClass.findAnnotationRecursively(
+                targetAnnotationClass,
+                searchedClasses,
+            ) ?: return@forEach
+        }
+
+        return null
    }
-}
+
+    /**
+     * Search for an annotation recursively.
+     *
+     * First the annotations, then the annotated classes super class and then it's interfaces
+     * are searched for the annotation recursively.
+     *
+     * @param targetAnnotation The annotation to search for.
+     * @return The annotation if found, otherwise null.
+     */
+    fun <T : Annotation> KClass<*>.findAnnotationRecursively(targetAnnotation: KClass<T>) =
+        java.findAnnotationRecursively(targetAnnotation.java)
+}
--- a/src/main/kotlin/app/revanced/patcher/extensions/Extensions.kt
+++ b/src/main/kotlin/app/revanced/patcher/extensions/Extensions.kt
@@ -11,13 +11,6 @@ import com.android.tools.smali.dexlib2.AccessFlags
 */
 fun MutableMethod.newLabel(index: Int) = implementation!!.newLabelForIndex(index)

-/**
- * Perform a bitwise OR operation between two [AccessFlags].
- *
- * @param other The other [AccessFlags] to perform the operation with.
- */
-infix fun AccessFlags.or(other: AccessFlags) = value or other.value
-
 /**
 * Perform a bitwise OR operation between an [AccessFlags] and an [Int].
 *
@@ -25,9 +18,16 @@ infix fun AccessFlags.or(other: AccessFlags) = value or other.value
 */
 infix fun Int.or(other: AccessFlags) = this or other.value

+/**
+ * Perform a bitwise OR operation between two [AccessFlags].
+ *
+ * @param other The other [AccessFlags] to perform the operation with.
+ */
+infix fun AccessFlags.or(other: AccessFlags) = value or other.value
+
 /**
 * Perform a bitwise OR operation between an [Int] and an [AccessFlags].
 *
 * @param other The [AccessFlags] to perform the operation with.
 */
-infix fun AccessFlags.or(other: Int) = value or other
+infix fun AccessFlags.or(other: Int) = value or other
--- a/src/main/kotlin/app/revanced/patcher/extensions/InstructionExtensions.kt
+++ b/src/main/kotlin/app/revanced/patcher/extensions/InstructionExtensions.kt
@@ -12,7 +12,6 @@ import com.android.tools.smali.dexlib2.builder.instruction.*
 import com.android.tools.smali.dexlib2.iface.instruction.Instruction

 object InstructionExtensions {
-
    /**
     * Add instructions to a method at the given index.
     *
@@ -21,7 +20,7 @@ object InstructionExtensions {
     */
    fun MutableMethodImplementation.addInstructions(
        index: Int,
-        instructions: List<BuilderInstruction>
+        instructions: List<BuilderInstruction>,
    ) = instructions.asReversed().forEach { addInstruction(index, it) }

    /**
@@ -39,7 +38,10 @@ object InstructionExtensions {
     * @param index The index to remove the instructions at.
     * @param count The amount of instructions to remove.
     */
-    fun MutableMethodImplementation.removeInstructions(index: Int, count: Int) = repeat(count) {
+    fun MutableMethodImplementation.removeInstructions(
+        index: Int,
+        count: Int,
+    ) = repeat(count) {
        removeInstruction(index)
    }

@@ -57,7 +59,10 @@ object InstructionExtensions {
     * @param index The index to replace the instructions at.
     * @param instructions The instructions to replace the instructions with.
     */
-    fun MutableMethodImplementation.replaceInstructions(index: Int, instructions: List<BuilderInstruction>) {
+    fun MutableMethodImplementation.replaceInstructions(
+        index: Int,
+        instructions: List<BuilderInstruction>,
+    ) {
        // Remove the instructions at the given index.
        removeInstructions(index, instructions.size)

@@ -71,16 +76,17 @@ object InstructionExtensions {
     * @param index The index to add the instruction at.
     * @param instruction The instruction to add.
     */
-    fun MutableMethod.addInstruction(index: Int, instruction: BuilderInstruction) =
-        implementation!!.addInstruction(index, instruction)
+    fun MutableMethod.addInstruction(
+        index: Int,
+        instruction: BuilderInstruction,
+    ) = implementation!!.addInstruction(index, instruction)

    /**
     * Add an instruction to a method.
     *
     * @param instruction The instructions to add.
     */
-    fun MutableMethod.addInstruction(instruction: BuilderInstruction) =
-        implementation!!.addInstruction(instruction)
+    fun MutableMethod.addInstruction(instruction: BuilderInstruction) = implementation!!.addInstruction(instruction)

    /**
     * Add an instruction to a method at the given index.
@@ -88,17 +94,17 @@ object InstructionExtensions {
     * @param index The index to add the instruction at.
     * @param smaliInstructions The instruction to add.
     */
-    fun MutableMethod.addInstruction(index: Int, smaliInstructions: String) =
-        implementation!!.addInstruction(index, smaliInstructions.toInstruction(this))
+    fun MutableMethod.addInstruction(
+        index: Int,
+        smaliInstructions: String,
+    ) = implementation!!.addInstruction(index, smaliInstructions.toInstruction(this))

    /**
     * Add an instruction to a method.
     *
     * @param smaliInstructions The instruction to add.
     */
-    fun MutableMethod.addInstruction(smaliInstructions: String) =
-        implementation!!.addInstruction(smaliInstructions.toInstruction(this))
-
+    fun MutableMethod.addInstruction(smaliInstructions: String) = implementation!!.addInstruction(smaliInstructions.toInstruction(this))

    /**
     * Add instructions to a method at the given index.
@@ -106,32 +112,34 @@ object InstructionExtensions {
     * @param index The index to add the instructions at.
     * @param instructions The instructions to add.
     */
-    fun MutableMethod.addInstructions(index: Int, instructions: List<BuilderInstruction>) =
-        implementation!!.addInstructions(index, instructions)
+    fun MutableMethod.addInstructions(
+        index: Int,
+        instructions: List<BuilderInstruction>,
+    ) = implementation!!.addInstructions(index, instructions)

    /**
     * Add instructions to a method.
     *
     * @param instructions The instructions to add.
     */
-    fun MutableMethod.addInstructions(instructions: List<BuilderInstruction>) =
-        implementation!!.addInstructions(instructions)
+    fun MutableMethod.addInstructions(instructions: List<BuilderInstruction>) = implementation!!.addInstructions(instructions)

    /**
     * Add instructions to a method.
     *
     * @param smaliInstructions The instructions to add.
     */
-    fun MutableMethod.addInstructions(index: Int, smaliInstructions: String) =
-        implementation!!.addInstructions(index, smaliInstructions.toInstructions(this))
+    fun MutableMethod.addInstructions(
+        index: Int,
+        smaliInstructions: String,
+    ) = implementation!!.addInstructions(index, smaliInstructions.toInstructions(this))

    /**
     * Add instructions to a method.
     *
     * @param smaliInstructions The instructions to add.
     */
-    fun MutableMethod.addInstructions(smaliInstructions: String) =
-        implementation!!.addInstructions(smaliInstructions.toInstructions(this))
+    fun MutableMethod.addInstructions(smaliInstructions: String) = implementation!!.addInstructions(smaliInstructions.toInstructions(this))

    /**
     * Add instructions to a method at the given index.
@@ -144,14 +152,15 @@ object InstructionExtensions {
    fun MutableMethod.addInstructionsWithLabels(
        index: Int,
        smaliInstructions: String,
-        vararg externalLabels: ExternalLabel
+        vararg externalLabels: ExternalLabel,
    ) {
        // Create reference dummy instructions for the instructions.
-        val nopSmali = StringBuilder(smaliInstructions).also { builder ->
-            externalLabels.forEach { (name, _) ->
-                builder.append("\n:$name\nnop")
-            }
-        }.toString()
+        val nopSmali =
+            StringBuilder(smaliInstructions).also { builder ->
+                externalLabels.forEach { (name, _) ->
+                    builder.append("\n:$name\nnop")
+                }
+            }.toString()

        // Compile the instructions with the dummy labels
        val compiledInstructions = nopSmali.toInstructions(this)
@@ -159,7 +168,7 @@ object InstructionExtensions {
        // Add the compiled list of instructions to the method.
        addInstructions(
            index,
-            compiledInstructions.subList(0, compiledInstructions.size - externalLabels.size)
+            compiledInstructions.subList(0, compiledInstructions.size - externalLabels.size),
        )

        implementation!!.apply {
@@ -174,22 +183,24 @@ object InstructionExtensions {
                     */
                    fun Instruction.makeNewLabel() {
                        fun replaceOffset(
-                            i: BuilderOffsetInstruction, label: Label
+                            i: BuilderOffsetInstruction,
+                            label: Label,
                        ): BuilderOffsetInstruction {
                            return when (i) {
                                is BuilderInstruction10t -> BuilderInstruction10t(i.opcode, label)
                                is BuilderInstruction20t -> BuilderInstruction20t(i.opcode, label)
                                is BuilderInstruction21t -> BuilderInstruction21t(i.opcode, i.registerA, label)
-                                is BuilderInstruction22t -> BuilderInstruction22t(
-                                    i.opcode,
-                                    i.registerA,
-                                    i.registerB,
-                                    label
-                                )
+                                is BuilderInstruction22t ->
+                                    BuilderInstruction22t(
+                                        i.opcode,
+                                        i.registerA,
+                                        i.registerB,
+                                        label,
+                                    )
                                is BuilderInstruction30t -> BuilderInstruction30t(i.opcode, label)
                                is BuilderInstruction31t -> BuilderInstruction31t(i.opcode, i.registerA, label)
                                else -> throw IllegalStateException(
-                                    "A non-offset instruction was given, this should never happen!"
+                                    "A non-offset instruction was given, this should never happen!",
                                )
                            }
                        }
@@ -198,9 +209,11 @@ object InstructionExtensions {
                        val label = newLabelForIndex(this@apply.instructions.indexOf(this))

                        // Create the final instruction with the new label.
-                        val newInstruction = replaceOffset(
-                            compiledInstruction, label
-                        )
+                        val newInstruction =
+                            replaceOffset(
+                                compiledInstruction,
+                                label,
+                            )

                        // Replace the instruction pointing to the dummy label
                        // with the new instruction pointing to the real instruction.
@@ -233,8 +246,7 @@ object InstructionExtensions {
     *
     * @param index The index to remove the instruction at.
     */
-    fun MutableMethod.removeInstruction(index: Int) =
-        implementation!!.removeInstruction(index)
+    fun MutableMethod.removeInstruction(index: Int) = implementation!!.removeInstruction(index)

    /**
     * Remove instructions at the given index.
@@ -242,16 +254,17 @@ object InstructionExtensions {
     * @param index The index to remove the instructions at.
     * @param count The amount of instructions to remove.
     */
-    fun MutableMethod.removeInstructions(index: Int, count: Int) =
-        implementation!!.removeInstructions(index, count)
+    fun MutableMethod.removeInstructions(
+        index: Int,
+        count: Int,
+    ) = implementation!!.removeInstructions(index, count)

    /**
     * Remove instructions at the given index.
     *
     * @param count The amount of instructions to remove.
     */
-    fun MutableMethod.removeInstructions(count: Int) =
-        implementation!!.removeInstructions(count)
+    fun MutableMethod.removeInstructions(count: Int) = implementation!!.removeInstructions(count)

    /**
     * Replace an instruction at the given index.
@@ -259,8 +272,10 @@ object InstructionExtensions {
     * @param index The index to replace the instruction at.
     * @param instruction The instruction to replace the instruction with.
     */
-    fun MutableMethod.replaceInstruction(index: Int, instruction: BuilderInstruction) =
-        implementation!!.replaceInstruction(index, instruction)
+    fun MutableMethod.replaceInstruction(
+        index: Int,
+        instruction: BuilderInstruction,
+    ) = implementation!!.replaceInstruction(index, instruction)

    /**
     * Replace an instruction at the given index.
@@ -268,8 +283,10 @@ object InstructionExtensions {
     * @param index The index to replace the instruction at.
     * @param smaliInstruction The smali instruction to replace the instruction with.
     */
-    fun MutableMethod.replaceInstruction(index: Int, smaliInstruction: String) =
-        implementation!!.replaceInstruction(index, smaliInstruction.toInstruction(this))
+    fun MutableMethod.replaceInstruction(
+        index: Int,
+        smaliInstruction: String,
+    ) = implementation!!.replaceInstruction(index, smaliInstruction.toInstruction(this))

    /**
     * Replace instructions at the given index.
@@ -277,8 +294,10 @@ object InstructionExtensions {
     * @param index The index to replace the instructions at.
     * @param instructions The instructions to replace the instructions with.
     */
-    fun MutableMethod.replaceInstructions(index: Int, instructions: List<BuilderInstruction>) =
-        implementation!!.replaceInstructions(index, instructions)
+    fun MutableMethod.replaceInstructions(
+        index: Int,
+        instructions: List<BuilderInstruction>,
+    ) = implementation!!.replaceInstructions(index, instructions)

    /**
     * Replace instructions at the given index.
@@ -286,8 +305,10 @@ object InstructionExtensions {
     * @param index The index to replace the instructions at.
     * @param smaliInstructions The smali instructions to replace the instructions with.
     */
-    fun MutableMethod.replaceInstructions(index: Int, smaliInstructions: String) =
-        implementation!!.replaceInstructions(index, smaliInstructions.toInstructions(this))
+    fun MutableMethod.replaceInstructions(
+        index: Int,
+        smaliInstructions: String,
+    ) = implementation!!.replaceInstructions(index, smaliInstructions.toInstructions(this))

    /**
     * Get an instruction at the given index.
@@ -327,4 +348,4 @@ object InstructionExtensions {
     * @return The instructions.
     */
    fun MutableMethod.getInstructions(): MutableList<BuilderInstruction> = implementation!!.instructions
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/extensions/MethodFingerprintExtensions.kt
+++ b/src/main/kotlin/app/revanced/patcher/extensions/MethodFingerprintExtensions.kt
@@ -1,14 +1,16 @@
 package app.revanced.patcher.extensions

-import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
-import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.fingerprint.MethodFingerprint
+import app.revanced.patcher.fingerprint.annotation.FuzzyPatternScanMethod

 object MethodFingerprintExtensions {
-    // TODO: Make this a property.
    /**
     * The [FuzzyPatternScanMethod] annotation of a [MethodFingerprint].
     */
+    @Deprecated(
+        message = "Use the property instead.",
+        replaceWith = ReplaceWith("this.fuzzyPatternScanMethod"),
+    )
    val MethodFingerprint.fuzzyPatternScanMethod
-        get() = javaClass.findAnnotationRecursively(FuzzyPatternScanMethod::class)
-}
+        get() = this.fuzzyPatternScanMethod
+}
--- a/src/main/kotlin/app/revanced/patcher/fingerprint/Fingerprint.kt
+++ b/src/main/kotlin/app/revanced/patcher/fingerprint/Fingerprint.kt
@@ -1,9 +0,0 @@
-package app.revanced.patcher.fingerprint
-
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-
-/**
- * A ReVanced fingerprint.
- * Can be a [MethodFingerprint].
- */
-interface Fingerprint
--- a/src/main/kotlin/app/revanced/patcher/fingerprint/LookupMap.kt
+++ b/src/main/kotlin/app/revanced/patcher/fingerprint/LookupMap.kt
@@ -0,0 +1,125 @@
+package app.revanced.patcher.fingerprint
+
+import app.revanced.patcher.data.BytecodeContext
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
+import com.android.tools.smali.dexlib2.iface.reference.StringReference
+import java.util.*
+
+internal typealias MethodClassPair = Pair<Method, ClassDef>
+
+/**
+ * Lookup map for methods.
+ */
+internal class LookupMap : MutableMap<String, LookupMap.MethodClassList> by mutableMapOf() {
+    /**
+     * Adds a [MethodClassPair] to the list associated with the given key.
+     * If the key does not exist, a new list is created and the [MethodClassPair] is added to it.
+     */
+    fun add(
+        key: String,
+        methodClassPair: MethodClassPair,
+    ) {
+        getOrPut(key) { MethodClassList() }.add(methodClassPair)
+    }
+
+    /**
+     * List of methods and the class they are a member of.
+     */
+    internal class MethodClassList : LinkedList<MethodClassPair>()
+
+    companion object Maps {
+        /**
+         * A list of methods and the class they are a member of.
+         */
+        internal val methods = MethodClassList()
+
+        /**
+         * Lookup map for methods keyed to the methods access flags, return type and parameter.
+         */
+        internal val methodSignatureLookupMap = LookupMap()
+
+        /**
+         * Lookup map for methods associated by strings referenced in the method.
+         */
+        internal val methodStringsLookupMap = LookupMap()
+
+        /**
+         * Initializes lookup maps for [MethodFingerprint] resolution
+         * using attributes of methods such as the method signature or strings.
+         *
+         * @param context The [BytecodeContext] containing the classes to initialize the lookup maps with.
+         */
+        internal fun initializeLookupMaps(context: BytecodeContext) {
+            if (methods.isNotEmpty()) clearLookupMaps()
+
+            context.classes.forEach { classDef ->
+                classDef.methods.forEach { method ->
+                    val methodClassPair = method to classDef
+
+                    // For fingerprints with no access or return type specified.
+                    methods += methodClassPair
+
+                    val accessFlagsReturnKey = method.accessFlags.toString() + method.returnType.first()
+
+                    // Add <access><returnType> as the key.
+                    methodSignatureLookupMap.add(accessFlagsReturnKey, methodClassPair)
+
+                    // Add <access><returnType>[parameters] as the key.
+                    methodSignatureLookupMap.add(
+                        buildString {
+                            append(accessFlagsReturnKey)
+                            appendParameters(method.parameterTypes)
+                        },
+                        methodClassPair,
+                    )
+
+                    // Add strings contained in the method as the key.
+                    method.implementation?.instructions?.forEach instructions@{ instruction ->
+                        if (instruction.opcode != Opcode.CONST_STRING && instruction.opcode != Opcode.CONST_STRING_JUMBO) {
+                            return@instructions
+                        }
+
+                        val string = ((instruction as ReferenceInstruction).reference as StringReference).string
+
+                        methodStringsLookupMap.add(string, methodClassPair)
+                    }
+
+                    // In the future, the class type could be added to the lookup map.
+                    // This would require MethodFingerprint to be changed to include the class type.
+                }
+            }
+        }
+
+        /**
+         * Clears the internal lookup maps created in [initializeLookupMaps].
+         */
+        internal fun clearLookupMaps() {
+            methods.clear()
+            methodSignatureLookupMap.clear()
+            methodStringsLookupMap.clear()
+        }
+
+        /**
+         * Appends a string based on the parameter reference types of this method.
+         */
+        internal fun StringBuilder.appendParameters(parameters: Iterable<CharSequence>) {
+            // Maximum parameters to use in the signature key.
+            // Some apps have methods with an incredible number of parameters (over 100 parameters have been seen).
+            // To keep the signature map from becoming needlessly bloated,
+            // group together in the same map entry all methods with the same access/return and 5 or more parameters.
+            // The value of 5 was chosen based on local performance testing and is not set in stone.
+            val maxSignatureParameters = 5
+            // Must append a unique value before the parameters to distinguish this key includes the parameters.
+            // If this is not appended, then methods with no parameters
+            // will collide with different keys that specify access/return but omit the parameters.
+            append("p:")
+            parameters.forEachIndexed { index, parameter ->
+                if (index >= maxSignatureParameters) return
+                append(parameter.first())
+            }
+        }
+    }
+}
--- a/src/main/kotlin/app/revanced/patcher/fingerprint/MethodFingerprint.kt
+++ b/src/main/kotlin/app/revanced/patcher/fingerprint/MethodFingerprint.kt
@@ -0,0 +1,357 @@
+package app.revanced.patcher.fingerprint
+
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
+import app.revanced.patcher.fingerprint.LookupMap.Maps.appendParameters
+import app.revanced.patcher.fingerprint.LookupMap.Maps.initializeLookupMaps
+import app.revanced.patcher.fingerprint.LookupMap.Maps.methodSignatureLookupMap
+import app.revanced.patcher.fingerprint.LookupMap.Maps.methodStringsLookupMap
+import app.revanced.patcher.fingerprint.LookupMap.Maps.methods
+import app.revanced.patcher.fingerprint.MethodFingerprintResult.MethodFingerprintScanResult.StringsScanResult
+import app.revanced.patcher.fingerprint.annotation.FuzzyPatternScanMethod
+import app.revanced.patcher.patch.PatchException
+import com.android.tools.smali.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.iface.instruction.Instruction
+import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
+import com.android.tools.smali.dexlib2.iface.reference.StringReference
+
+/**
+ * A fingerprint to resolve methods.
+ *
+ * @param returnType The method's return type compared using [String.startsWith].
+ * @param accessFlags The method's exact access flags using values of [AccessFlags].
+ * @param parameters The parameters of the method. Partial matches allowed and follow the same rules as [returnType].
+ * @param opcodes An opcode pattern of the method's instructions. Wildcard or unknown opcodes can be specified by `null`.
+ * @param strings A list of the method's strings compared each using [String.contains].
+ * @param customFingerprint A custom condition for this fingerprint.
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+abstract class MethodFingerprint(
+    internal val returnType: String? = null,
+    internal val accessFlags: Int? = null,
+    internal val parameters: Iterable<String>? = null,
+    internal val opcodes: Iterable<Opcode?>? = null,
+    internal val strings: Iterable<String>? = null,
+    internal val customFingerprint: ((methodDef: Method, classDef: ClassDef) -> Boolean)? = null,
+) {
+    /**
+     * The result of the [MethodFingerprint].
+     */
+    var result: MethodFingerprintResult? = null
+        private set
+
+    /**
+     *  The [FuzzyPatternScanMethod] annotation of the [MethodFingerprint].
+     *
+     *  If the annotation is not present, this property is null.
+     */
+    val fuzzyPatternScanMethod = this::class.findAnnotationRecursively(FuzzyPatternScanMethod::class)
+
+    /**
+     * Resolve a [MethodFingerprint] using the lookup map built by [initializeLookupMaps].
+     *
+     * [MethodFingerprint] resolution is fast, but if many are present they can consume a noticeable
+     * amount of time because they are resolved in sequence.
+     *
+     * For apps with many fingerprints, resolving performance can be improved by:
+     * - Slowest: Specify [opcodes] and nothing else.
+     * - Fast: Specify [accessFlags], [returnType].
+     * - Faster: Specify [accessFlags], [returnType] and [parameters].
+     * - Fastest: Specify [strings], with at least one string being an exact (non-partial) match.
+     */
+    internal fun resolveUsingLookupMap(context: BytecodeContext): Boolean {
+        /**
+         * Lookup [MethodClassPair]s that match the methods strings present in a [MethodFingerprint].
+         *
+         * @return A list of [MethodClassPair]s that match the methods strings present in a [MethodFingerprint].
+         */
+        fun MethodFingerprint.methodStringsLookup(): LookupMap.MethodClassList? {
+            strings?.forEach {
+                val methods = methodStringsLookupMap[it]
+                if (methods != null) return methods
+            }
+            return null
+        }
+
+        /**
+         * Lookup [MethodClassPair]s that match the method signature present in a [MethodFingerprint].
+         *
+         * @return A list of [MethodClassPair]s that match the method signature present in a [MethodFingerprint].
+         */
+        fun MethodFingerprint.methodSignatureLookup(): LookupMap.MethodClassList {
+            if (accessFlags == null) return methods
+
+            var returnTypeValue = returnType
+            if (returnTypeValue == null) {
+                if (AccessFlags.CONSTRUCTOR.isSet(accessFlags)) {
+                    // Constructors always have void return type
+                    returnTypeValue = "V"
+                } else {
+                    return methods
+                }
+            }
+
+            val key =
+                buildString {
+                    append(accessFlags)
+                    append(returnTypeValue.first())
+                    if (parameters != null) appendParameters(parameters)
+                }
+            return methodSignatureLookupMap[key] ?: return LookupMap.MethodClassList()
+        }
+
+        /**
+         * Resolve a [MethodFingerprint] using a list of [MethodClassPair].
+         *
+         * @return True if the resolution was successful, false otherwise.
+         */
+        fun MethodFingerprint.resolveUsingMethodClassPair(methodClasses: LookupMap.MethodClassList): Boolean {
+            methodClasses.forEach { classAndMethod ->
+                if (resolve(context, classAndMethod.first, classAndMethod.second)) return true
+            }
+            return false
+        }
+
+        val methodsWithSameStrings = methodStringsLookup()
+        if (methodsWithSameStrings != null) {
+            if (resolveUsingMethodClassPair(methodsWithSameStrings)) {
+                return true
+            }
+        }
+
+        // No strings declared or none matched (partial matches are allowed).
+        // Use signature matching.
+        return resolveUsingMethodClassPair(methodSignatureLookup())
+    }
+
+    /**
+     * Resolve a [MethodFingerprint] against a [ClassDef].
+     *
+     * @param forClass The class on which to resolve the [MethodFingerprint] in.
+     * @param context The [BytecodeContext] to host proxies.
+     * @return True if the resolution was successful, false otherwise.
+     */
+    fun resolve(
+        context: BytecodeContext,
+        forClass: ClassDef,
+    ): Boolean {
+        for (method in forClass.methods)
+            if (resolve(context, method, forClass)) {
+                return true
+            }
+        return false
+    }
+
+    /**
+     * Resolve a [MethodFingerprint] against a [Method].
+     *
+     * @param method The class on which to resolve the [MethodFingerprint] in.
+     * @param forClass The class on which to resolve the [MethodFingerprint].
+     * @param context The [BytecodeContext] to host proxies.
+     * @return True if the resolution was successful or if the fingerprint is already resolved, false otherwise.
+     */
+    fun resolve(
+        context: BytecodeContext,
+        method: Method,
+        forClass: ClassDef,
+    ): Boolean {
+        val methodFingerprint = this
+
+        if (methodFingerprint.result != null) return true
+
+        if (methodFingerprint.returnType != null && !method.returnType.startsWith(methodFingerprint.returnType)) {
+            return false
+        }
+
+        if (methodFingerprint.accessFlags != null && methodFingerprint.accessFlags != method.accessFlags) {
+            return false
+        }
+
+        fun parametersEqual(
+            parameters1: Iterable<CharSequence>,
+            parameters2: Iterable<CharSequence>,
+        ): Boolean {
+            if (parameters1.count() != parameters2.count()) return false
+            val iterator1 = parameters1.iterator()
+            parameters2.forEach {
+                if (!it.startsWith(iterator1.next())) return false
+            }
+            return true
+        }
+
+        if (methodFingerprint.parameters != null &&
+            !parametersEqual(
+                methodFingerprint.parameters, // TODO: parseParameters()
+                method.parameterTypes,
+            )
+        ) {
+            return false
+        }
+
+        @Suppress("UNNECESSARY_NOT_NULL_ASSERTION")
+        if (methodFingerprint.customFingerprint != null && !methodFingerprint.customFingerprint!!(method, forClass)) {
+            return false
+        }
+
+        val stringsScanResult: StringsScanResult? =
+            if (methodFingerprint.strings != null) {
+                StringsScanResult(
+                    buildList {
+                        val implementation = method.implementation ?: return false
+
+                        val stringsList = methodFingerprint.strings.toMutableList()
+
+                        implementation.instructions.forEachIndexed { instructionIndex, instruction ->
+                            if (
+                                instruction.opcode != Opcode.CONST_STRING &&
+                                instruction.opcode != Opcode.CONST_STRING_JUMBO
+                            ) {
+                                return@forEachIndexed
+                            }
+
+                            val string = ((instruction as ReferenceInstruction).reference as StringReference).string
+                            val index = stringsList.indexOfFirst(string::contains)
+                            if (index == -1) return@forEachIndexed
+
+                            add(StringsScanResult.StringMatch(string, instructionIndex))
+                            stringsList.removeAt(index)
+                        }
+
+                        if (stringsList.isNotEmpty()) return false
+                    },
+                )
+            } else {
+                null
+            }
+
+        val patternScanResult =
+            if (methodFingerprint.opcodes != null) {
+                method.implementation?.instructions ?: return false
+
+                fun MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.newWarnings(
+                    pattern: Iterable<Opcode?>,
+                    instructions: Iterable<Instruction>,
+                ) = buildList {
+                    for ((patternIndex, instructionIndex) in (this@newWarnings.startIndex until this@newWarnings.endIndex).withIndex()) {
+                        val originalOpcode = instructions.elementAt(instructionIndex).opcode
+                        val patternOpcode = pattern.elementAt(patternIndex)
+
+                        if (patternOpcode == null || patternOpcode.ordinal == originalOpcode.ordinal) continue
+
+                        this.add(
+                            MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.Warning(
+                                originalOpcode,
+                                patternOpcode,
+                                instructionIndex,
+                                patternIndex,
+                            ),
+                        )
+                    }
+                }
+
+                fun Method.patternScan(
+                    fingerprint: MethodFingerprint,
+                ): MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult? {
+                    val instructions = this.implementation!!.instructions
+                    val fingerprintFuzzyPatternScanThreshold = fingerprint.fuzzyPatternScanMethod?.threshold ?: 0
+
+                    val pattern = fingerprint.opcodes!!
+                    val instructionLength = instructions.count()
+                    val patternLength = pattern.count()
+
+                    for (index in 0 until instructionLength) {
+                        var patternIndex = 0
+                        var threshold = fingerprintFuzzyPatternScanThreshold
+
+                        while (index + patternIndex < instructionLength) {
+                            val originalOpcode = instructions.elementAt(index + patternIndex).opcode
+                            val patternOpcode = pattern.elementAt(patternIndex)
+
+                            if (patternOpcode != null && patternOpcode.ordinal != originalOpcode.ordinal) {
+                                // reaching maximum threshold (0) means,
+                                // the pattern does not match to the current instructions
+                                if (threshold-- == 0) break
+                            }
+
+                            if (patternIndex < patternLength - 1) {
+                                // if the entire pattern has not been scanned yet
+                                // continue the scan
+                                patternIndex++
+                                continue
+                            }
+                            // the pattern is valid, generate warnings if fuzzyPatternScanMethod is FuzzyPatternScanMethod
+                            val result =
+                                MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult(
+                                    index,
+                                    index + patternIndex,
+                                )
+                            if (fingerprint.fuzzyPatternScanMethod !is FuzzyPatternScanMethod) return result
+                            result.warnings = result.newWarnings(pattern, instructions)
+
+                            return result
+                        }
+                    }
+
+                    return null
+                }
+
+                method.patternScan(methodFingerprint) ?: return false
+            } else {
+                null
+            }
+
+        methodFingerprint.result =
+            MethodFingerprintResult(
+                method,
+                forClass,
+                MethodFingerprintResult.MethodFingerprintScanResult(
+                    patternScanResult,
+                    stringsScanResult,
+                ),
+                context,
+            )
+
+        return true
+    }
+
+    companion object {
+        /**
+         * Resolve a list of [MethodFingerprint] using the lookup map built by [initializeLookupMaps].
+         *
+         * [MethodFingerprint] resolution is fast, but if many are present they can consume a noticeable
+         * amount of time because they are resolved in sequence.
+         *
+         * For apps with many fingerprints, resolving performance can be improved by:
+         * - Slowest: Specify [opcodes] and nothing else.
+         * - Fast: Specify [accessFlags], [returnType].
+         * - Faster: Specify [accessFlags], [returnType] and [parameters].
+         * - Fastest: Specify [strings], with at least one string being an exact (non-partial) match.
+         */
+        internal fun Set<MethodFingerprint>.resolveUsingLookupMap(context: BytecodeContext) {
+            if (methods.isEmpty()) throw PatchException("lookup map not initialized")
+
+            forEach { fingerprint ->
+                fingerprint.resolveUsingLookupMap(context)
+            }
+        }
+
+        /**
+         * Resolve a list of [MethodFingerprint] against a list of [ClassDef].
+         *
+         * @param classes The classes on which to resolve the [MethodFingerprint] in.
+         * @param context The [BytecodeContext] to host proxies.
+         * @return True if the resolution was successful, false otherwise.
+         */
+        fun Iterable<MethodFingerprint>.resolve(
+            context: BytecodeContext,
+            classes: Iterable<ClassDef>,
+        ) = forEach { fingerprint ->
+            for (classDef in classes) {
+                if (fingerprint.resolve(context, classDef)) break
+            }
+        }
+    }
+}
--- a/src/main/kotlin/app/revanced/patcher/fingerprint/MethodFingerprintResult.kt
+++ b/src/main/kotlin/app/revanced/patcher/fingerprint/MethodFingerprintResult.kt
@@ -0,0 +1,94 @@
+package app.revanced.patcher.fingerprint
+
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.util.proxy.ClassProxy
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.util.MethodUtil
+
+/**
+ * Represents the result of a [MethodFingerprintResult].
+ *
+ * @param method The matching method.
+ * @param classDef The [ClassDef] that contains the matching [method].
+ * @param scanResult The result of scanning for the [MethodFingerprint].
+ * @param context The [BytecodeContext] this [MethodFingerprintResult] is attached to, to create proxies.
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+class MethodFingerprintResult(
+    val method: Method,
+    val classDef: ClassDef,
+    val scanResult: MethodFingerprintScanResult,
+    internal val context: BytecodeContext,
+) {
+    /**
+     * Returns a mutable clone of [classDef]
+     *
+     * Please note, this method allocates a [ClassProxy].
+     * Use [classDef] where possible.
+     */
+    @Suppress("MemberVisibilityCanBePrivate")
+    val mutableClass by lazy { context.proxy(classDef).mutableClass }
+
+    /**
+     * Returns a mutable clone of [method]
+     *
+     * Please note, this method allocates a [ClassProxy].
+     * Use [method] where possible.
+     */
+    val mutableMethod by lazy {
+        mutableClass.methods.first {
+            MethodUtil.methodSignaturesMatch(it, this.method)
+        }
+    }
+
+    /**
+     * The result of scanning on the [MethodFingerprint].
+     * @param patternScanResult The result of the pattern scan.
+     * @param stringsScanResult The result of the string scan.
+     */
+    class MethodFingerprintScanResult(
+        val patternScanResult: PatternScanResult?,
+        val stringsScanResult: StringsScanResult?,
+    ) {
+        /**
+         * The result of scanning strings on the [MethodFingerprint].
+         * @param matches The list of strings that were matched.
+         */
+        class StringsScanResult(val matches: List<StringMatch>) {
+            /**
+             * Represents a match for a string at an index.
+             * @param string The string that was matched.
+             * @param index The index of the string.
+             */
+            class StringMatch(val string: String, val index: Int)
+        }
+
+        /**
+         * The result of a pattern scan.
+         * @param startIndex The start index of the instructions where to which this pattern matches.
+         * @param endIndex The end index of the instructions where to which this pattern matches.
+         * @param warnings A list of warnings considering this [PatternScanResult].
+         */
+        class PatternScanResult(
+            val startIndex: Int,
+            val endIndex: Int,
+            var warnings: List<Warning>? = null,
+        ) {
+            /**
+             * Represents warnings of the pattern scan.
+             * @param correctOpcode The opcode the instruction list has.
+             * @param wrongOpcode The opcode the pattern list of the signature currently has.
+             * @param instructionIndex The index of the opcode relative to the instruction list.
+             * @param patternIndex The index of the opcode relative to the pattern list from the signature.
+             */
+            class Warning(
+                val correctOpcode: Opcode,
+                val wrongOpcode: Opcode,
+                val instructionIndex: Int,
+                val patternIndex: Int,
+            )
+        }
+    }
+}
--- a/src/main/kotlin/app/revanced/patcher/fingerprint/method/annotation/MethodFingerprintMetadata.kt
+++ b/src/main/kotlin/app/revanced/patcher/fingerprint/method/annotation/MethodFingerprintMetadata.kt
@@ -1,6 +1,6 @@
-package app.revanced.patcher.fingerprint.method.annotation
+package app.revanced.patcher.fingerprint.annotation

-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.fingerprint.MethodFingerprint

 /**
 * Annotations to scan a pattern [MethodFingerprint] with fuzzy algorithm.
@@ -8,5 +8,5 @@ import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
 */
@Target(AnnotationTarget.CLASS)
 annotation class FuzzyPatternScanMethod(
-    val threshold: Int = 1
-)
+    val threshold: Int = 1,
+)
--- a/src/main/kotlin/app/revanced/patcher/fingerprint/method/impl/MethodFingerprint.kt
+++ b/src/main/kotlin/app/revanced/patcher/fingerprint/method/impl/MethodFingerprint.kt
@@ -1,513 +0,0 @@
-package app.revanced.patcher.fingerprint.method.impl
-
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.extensions.MethodFingerprintExtensions.fuzzyPatternScanMethod
-import app.revanced.patcher.fingerprint.Fingerprint
-import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
-import app.revanced.patcher.patch.PatchException
-import app.revanced.patcher.util.proxy.ClassProxy
-import com.android.tools.smali.dexlib2.AccessFlags
-import com.android.tools.smali.dexlib2.Opcode
-import com.android.tools.smali.dexlib2.iface.ClassDef
-import com.android.tools.smali.dexlib2.iface.Method
-import com.android.tools.smali.dexlib2.iface.instruction.Instruction
-import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
-import com.android.tools.smali.dexlib2.iface.reference.StringReference
-import com.android.tools.smali.dexlib2.util.MethodUtil
-import java.util.*
-
-private typealias StringMatch = MethodFingerprintResult.MethodFingerprintScanResult.StringsScanResult.StringMatch
-private typealias StringsScanResult = MethodFingerprintResult.MethodFingerprintScanResult.StringsScanResult
-private typealias MethodClassPair = Pair<Method, ClassDef>
-
-/**
- * A fingerprint to resolve methods.
- *
- * @param returnType The method's return type compared using [String.startsWith].
- * @param accessFlags The method's exact access flags using values of [AccessFlags].
- * @param parameters The parameters of the method. Partial matches allowed and follow the same rules as [returnType].
- * @param opcodes An opcode pattern of the method's instructions. Wildcard or unknown opcodes can be specified by `null`.
- * @param strings A list of the method's strings compared each using [String.contains].
- * @param customFingerprint A custom condition for this fingerprint.
- */
-abstract class MethodFingerprint(
-    internal val returnType: String? = null,
-    internal val accessFlags: Int? = null,
-    internal val parameters: Iterable<String>? = null,
-    internal val opcodes: Iterable<Opcode?>? = null,
-    internal val strings: Iterable<String>? = null,
-    internal val customFingerprint: ((methodDef: Method, classDef: ClassDef) -> Boolean)? = null
-) : Fingerprint {
-    /**
-     * The result of the [MethodFingerprint].
-     */
-    var result: MethodFingerprintResult? = null
-
-    companion object {
-        /**
-         * A list of methods and the class they were found in.
-         */
-        private val methods = mutableListOf<MethodClassPair>()
-
-        /**
-         * Lookup map for methods keyed to the methods access flags, return type and parameter.
-         */
-        private val methodSignatureLookupMap = mutableMapOf<String, MutableList<MethodClassPair>>()
-
-        /**
-         * Lookup map for methods keyed to the strings contained in the method.
-         */
-        private val methodStringsLookupMap = mutableMapOf<String, MutableList<MethodClassPair>>()
-
-        /**
-         * Appends a string based on the parameter reference types of this method.
-         */
-        private fun StringBuilder.appendParameters(parameters: Iterable<CharSequence>) {
-            // Maximum parameters to use in the signature key.
-            // Some apps have methods with an incredible number of parameters (over 100 parameters have been seen).
-            // To keep the signature map from becoming needlessly bloated,
-            // group together in the same map entry all methods with the same access/return and 5 or more parameters.
-            // The value of 5 was chosen based on local performance testing and is not set in stone.
-            val maxSignatureParameters = 5
-            // Must append a unique value before the parameters to distinguish this key includes the parameters.
-            // If this is not appended, then methods with no parameters
-            // will collide with different keys that specify access/return but omit the parameters.
-            append("p:")
-            parameters.forEachIndexed { index, parameter ->
-                if (index >= maxSignatureParameters) return
-                append(parameter.first())
-            }
-        }
-
-        /**
-         * Initializes lookup maps for [MethodFingerprint] resolution
-         * using attributes of methods such as the method signature or strings.
-         *
-         * @param context The [BytecodeContext] containing the classes to initialize the lookup maps with.
-         */
-        internal fun initializeFingerprintResolutionLookupMaps(context: BytecodeContext) {
-            fun MutableMap<String, MutableList<MethodClassPair>>.add(
-                key: String,
-                methodClassPair: MethodClassPair
-            ) {
-                var methodClassPairs = this[key]
-
-                methodClassPairs ?: run {
-                    methodClassPairs = LinkedList<MethodClassPair>().also { this[key] = it }
-                }
-
-                methodClassPairs!!.add(methodClassPair)
-            }
-
-            if (methods.isNotEmpty()) clearFingerprintResolutionLookupMaps()
-
-            context.classes.forEach { classDef ->
-                classDef.methods.forEach { method ->
-                    val methodClassPair = method to classDef
-
-                    // For fingerprints with no access or return type specified.
-                    methods += methodClassPair
-
-                    val accessFlagsReturnKey = method.accessFlags.toString() + method.returnType.first()
-
-                    // Add <access><returnType> as the key.
-                    methodSignatureLookupMap.add(accessFlagsReturnKey, methodClassPair)
-
-                    // Add <access><returnType>[parameters] as the key.
-                    methodSignatureLookupMap.add(
-                        buildString {
-                            append(accessFlagsReturnKey)
-                            appendParameters(method.parameterTypes)
-                        },
-                        methodClassPair
-                    )
-
-                    // Add strings contained in the method as the key.
-                    method.implementation?.instructions?.forEach instructions@{ instruction ->
-                        if (instruction.opcode != Opcode.CONST_STRING && instruction.opcode != Opcode.CONST_STRING_JUMBO)
-                            return@instructions
-
-                        val string = ((instruction as ReferenceInstruction).reference as StringReference).string
-
-                        methodStringsLookupMap.add(string, methodClassPair)
-                    }
-
-                    // In the future, the class type could be added to the lookup map.
-                    // This would require MethodFingerprint to be changed to include the class type.
-                }
-            }
-        }
-
-        /**
-         * Clears the internal lookup maps created in [initializeFingerprintResolutionLookupMaps]
-         */
-        internal fun clearFingerprintResolutionLookupMaps() {
-            methods.clear()
-            methodSignatureLookupMap.clear()
-            methodStringsLookupMap.clear()
-        }
-
-        /**
-         * Resolve a list of [MethodFingerprint] using the lookup map built by [initializeFingerprintResolutionLookupMaps].
-         *
-         * [MethodFingerprint] resolution is fast, but if many are present they can consume a noticeable
-         * amount of time because they are resolved in sequence.
-         *
-         * For apps with many fingerprints, resolving performance can be improved by:
-         * - Slowest: Specify [opcodes] and nothing else.
-         * - Fast: Specify [accessFlags], [returnType].
-         * - Faster: Specify [accessFlags], [returnType] and [parameters].
-         * - Fastest: Specify [strings], with at least one string being an exact (non-partial) match.
-         */
-        internal fun Set<MethodFingerprint>.resolveUsingLookupMap(context: BytecodeContext) {
-            if (methods.isEmpty()) throw PatchException("lookup map not initialized")
-
-            forEach { fingerprint ->
-                fingerprint.resolveUsingLookupMap(context)
-            }
-        }
-
-        /**
-         * Resolve a [MethodFingerprint] using the lookup map built by [initializeFingerprintResolutionLookupMaps].
-         *
-         * [MethodFingerprint] resolution is fast, but if many are present they can consume a noticeable
-         * amount of time because they are resolved in sequence.
-         *
-         * For apps with many fingerprints, resolving performance can be improved by:
-         * - Slowest: Specify [opcodes] and nothing else.
-         * - Fast: Specify [accessFlags], [returnType].
-         * - Faster: Specify [accessFlags], [returnType] and [parameters].
-         * - Fastest: Specify [strings], with at least one string being an exact (non-partial) match.
-         */
-        internal fun MethodFingerprint.resolveUsingLookupMap(context: BytecodeContext): Boolean {
-            /**
-             * Lookup [MethodClassPair]s that match the methods strings present in a [MethodFingerprint].
-             *
-             * @return A list of [MethodClassPair]s that match the methods strings present in a [MethodFingerprint].
-             */
-            fun MethodFingerprint.methodStringsLookup(): List<MethodClassPair>? {
-                strings?.forEach {
-                    val methods = methodStringsLookupMap[it]
-                    if (methods != null) return methods
-                }
-                return null
-            }
-
-            /**
-             * Lookup [MethodClassPair]s that match the method signature present in a [MethodFingerprint].
-             *
-             * @return A list of [MethodClassPair]s that match the method signature present in a [MethodFingerprint].
-             */
-            fun MethodFingerprint.methodSignatureLookup(): List<MethodClassPair> {
-                if (accessFlags == null) return methods
-
-                var returnTypeValue = returnType
-                if (returnTypeValue == null) {
-                    if (AccessFlags.CONSTRUCTOR.isSet(accessFlags)) {
-                        // Constructors always have void return type
-                        returnTypeValue = "V"
-                    } else {
-                        return methods
-                    }
-                }
-
-                val key = buildString {
-                    append(accessFlags)
-                    append(returnTypeValue.first())
-                    if (parameters != null) appendParameters(parameters)
-                }
-                return methodSignatureLookupMap[key] ?: return emptyList()
-            }
-
-            /**
-             * Resolve a [MethodFingerprint] using a list of [MethodClassPair].
-             *
-             * @return True if the resolution was successful, false otherwise.
-             */
-            fun MethodFingerprint.resolveUsingMethodClassPair(classMethods: Iterable<MethodClassPair>): Boolean {
-                classMethods.forEach { classAndMethod ->
-                    if (resolve(context, classAndMethod.first, classAndMethod.second)) return true
-                }
-                return false
-            }
-
-            val methodsWithSameStrings = methodStringsLookup()
-            if (methodsWithSameStrings != null) if (resolveUsingMethodClassPair(methodsWithSameStrings)) return true
-
-            // No strings declared or none matched (partial matches are allowed).
-            // Use signature matching.
-            return resolveUsingMethodClassPair(methodSignatureLookup())
-        }
-
-        /**
-         * Resolve a list of [MethodFingerprint] against a list of [ClassDef].
-         *
-         * @param classes The classes on which to resolve the [MethodFingerprint] in.
-         * @param context The [BytecodeContext] to host proxies.
-         * @return True if the resolution was successful, false otherwise.
-         */
-        fun Iterable<MethodFingerprint>.resolve(context: BytecodeContext, classes: Iterable<ClassDef>) {
-            for (fingerprint in this) // For each fingerprint...
-                classes@ for (classDef in classes) // ...search through all classes for the MethodFingerprint
-                    if (fingerprint.resolve(context, classDef))
-                        break@classes // ...if the resolution succeeded, continue with the next MethodFingerprint.
-        }
-
-        /**
-         * Resolve a [MethodFingerprint] against a [ClassDef].
-         *
-         * @param forClass The class on which to resolve the [MethodFingerprint] in.
-         * @param context The [BytecodeContext] to host proxies.
-         * @return True if the resolution was successful, false otherwise.
-         */
-        fun MethodFingerprint.resolve(context: BytecodeContext, forClass: ClassDef): Boolean {
-            for (method in forClass.methods)
-                if (this.resolve(context, method, forClass))
-                    return true
-            return false
-        }
-
-        /**
-         * Resolve a [MethodFingerprint] against a [Method].
-         *
-         * @param method The class on which to resolve the [MethodFingerprint] in.
-         * @param forClass The class on which to resolve the [MethodFingerprint].
-         * @param context The [BytecodeContext] to host proxies.
-         * @return True if the resolution was successful or if the fingerprint is already resolved, false otherwise.
-         */
-        fun MethodFingerprint.resolve(context: BytecodeContext, method: Method, forClass: ClassDef): Boolean {
-            val methodFingerprint = this
-
-            if (methodFingerprint.result != null) return true
-
-            if (methodFingerprint.returnType != null && !method.returnType.startsWith(methodFingerprint.returnType))
-                return false
-
-            if (methodFingerprint.accessFlags != null && methodFingerprint.accessFlags != method.accessFlags)
-                return false
-
-
-            fun parametersEqual(
-                parameters1: Iterable<CharSequence>, parameters2: Iterable<CharSequence>
-            ): Boolean {
-                if (parameters1.count() != parameters2.count()) return false
-                val iterator1 = parameters1.iterator()
-                parameters2.forEach {
-                    if (!it.startsWith(iterator1.next())) return false
-                }
-                return true
-            }
-
-            if (methodFingerprint.parameters != null && !parametersEqual(
-                    methodFingerprint.parameters, // TODO: parseParameters()
-                    method.parameterTypes
-                )
-            ) return false
-
-            @Suppress("UNNECESSARY_NOT_NULL_ASSERTION")
-            if (methodFingerprint.customFingerprint != null && !methodFingerprint.customFingerprint!!(method, forClass))
-                return false
-
-            val stringsScanResult: StringsScanResult? =
-                if (methodFingerprint.strings != null) {
-                    StringsScanResult(
-                        buildList {
-                            val implementation = method.implementation ?: return false
-
-                            val stringsList = methodFingerprint.strings.toMutableList()
-
-                            implementation.instructions.forEachIndexed { instructionIndex, instruction ->
-                                if (
-                                    instruction.opcode != Opcode.CONST_STRING &&
-                                    instruction.opcode != Opcode.CONST_STRING_JUMBO
-                                ) return@forEachIndexed
-
-                                val string = ((instruction as ReferenceInstruction).reference as StringReference).string
-                                val index = stringsList.indexOfFirst(string::contains)
-                                if (index == -1) return@forEachIndexed
-
-                                add(
-                                    StringMatch(
-                                        string,
-                                        instructionIndex
-                                    )
-                                )
-                                stringsList.removeAt(index)
-                            }
-
-                            if (stringsList.isNotEmpty()) return false
-                        }
-                    )
-                } else null
-
-            val patternScanResult = if (methodFingerprint.opcodes != null) {
-                method.implementation?.instructions ?: return false
-
-                fun Method.patternScan(
-                    fingerprint: MethodFingerprint
-                ): MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult? {
-                    val instructions = this.implementation!!.instructions
-                    val fingerprintFuzzyPatternScanThreshold = fingerprint.fuzzyPatternScanMethod?.threshold ?: 0
-
-                    val pattern = fingerprint.opcodes!!
-                    val instructionLength = instructions.count()
-                    val patternLength = pattern.count()
-
-                    for (index in 0 until instructionLength) {
-                        var patternIndex = 0
-                        var threshold = fingerprintFuzzyPatternScanThreshold
-
-                        while (index + patternIndex < instructionLength) {
-                            val originalOpcode = instructions.elementAt(index + patternIndex).opcode
-                            val patternOpcode = pattern.elementAt(patternIndex)
-
-                            if (patternOpcode != null && patternOpcode.ordinal != originalOpcode.ordinal) {
-                                // reaching maximum threshold (0) means,
-                                // the pattern does not match to the current instructions
-                                if (threshold-- == 0) break
-                            }
-
-                            if (patternIndex < patternLength - 1) {
-                                // if the entire pattern has not been scanned yet
-                                // continue the scan
-                                patternIndex++
-                                continue
-                            }
-                            // the pattern is valid, generate warnings if fuzzyPatternScanMethod is FuzzyPatternScanMethod
-                            val result =
-                                MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult(
-                                    index,
-                                    index + patternIndex
-                                )
-                            if (fingerprint.fuzzyPatternScanMethod !is FuzzyPatternScanMethod) return result
-                            result.warnings = result.createWarnings(pattern, instructions)
-
-                            return result
-                        }
-                    }
-
-                    return null
-                }
-
-                method.patternScan(methodFingerprint) ?: return false
-            } else null
-
-            methodFingerprint.result = MethodFingerprintResult(
-                method,
-                forClass,
-                MethodFingerprintResult.MethodFingerprintScanResult(
-                    patternScanResult,
-                    stringsScanResult
-                ),
-                context
-            )
-
-            return true
-        }
-
-        private fun MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.createWarnings(
-            pattern: Iterable<Opcode?>, instructions: Iterable<Instruction>
-        ) = buildList {
-            for ((patternIndex, instructionIndex) in (this@createWarnings.startIndex until this@createWarnings.endIndex).withIndex()) {
-                val originalOpcode = instructions.elementAt(instructionIndex).opcode
-                val patternOpcode = pattern.elementAt(patternIndex)
-
-                if (patternOpcode == null || patternOpcode.ordinal == originalOpcode.ordinal) continue
-
-                this.add(
-                    MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.Warning(
-                        originalOpcode,
-                        patternOpcode,
-                        instructionIndex,
-                        patternIndex
-                    )
-                )
-            }
-        }
-    }
-}
-
-/**
- * Represents the result of a [MethodFingerprintResult].
- *
- * @param method The matching method.
- * @param classDef The [ClassDef] that contains the matching [method].
- * @param scanResult The result of scanning for the [MethodFingerprint].
- * @param context The [BytecodeContext] this [MethodFingerprintResult] is attached to, to create proxies.
- */
-data class MethodFingerprintResult(
-    val method: Method,
-    val classDef: ClassDef,
-    val scanResult: MethodFingerprintScanResult,
-    internal val context: BytecodeContext
-) {
-    /**
-     * Returns a mutable clone of [classDef]
-     *
-     * Please note, this method allocates a [ClassProxy].
-     * Use [classDef] where possible.
-     */
-    @Suppress("MemberVisibilityCanBePrivate")
-    val mutableClass by lazy { context.proxy(classDef).mutableClass }
-
-    /**
-     * Returns a mutable clone of [method]
-     *
-     * Please note, this method allocates a [ClassProxy].
-     * Use [method] where possible.
-     */
-    val mutableMethod by lazy {
-        mutableClass.methods.first {
-            MethodUtil.methodSignaturesMatch(it, this.method)
-        }
-    }
-
-    /**
-     * The result of scanning on the [MethodFingerprint].
-     * @param patternScanResult The result of the pattern scan.
-     * @param stringsScanResult The result of the string scan.
-     */
-    data class MethodFingerprintScanResult(
-        val patternScanResult: PatternScanResult?,
-        val stringsScanResult: StringsScanResult?
-    ) {
-        /**
-         * The result of scanning strings on the [MethodFingerprint].
-         * @param matches The list of strings that were matched.
-         */
-        data class StringsScanResult(val matches: List<StringMatch>) {
-            /**
-             * Represents a match for a string at an index.
-             * @param string The string that was matched.
-             * @param index The index of the string.
-             */
-            data class StringMatch(val string: String, val index: Int)
-        }
-
-        /**
-         * The result of a pattern scan.
-         * @param startIndex The start index of the instructions where to which this pattern matches.
-         * @param endIndex The end index of the instructions where to which this pattern matches.
-         * @param warnings A list of warnings considering this [PatternScanResult].
-         */
-        data class PatternScanResult(
-            val startIndex: Int,
-            val endIndex: Int,
-            var warnings: List<Warning>? = null
-        ) {
-            /**
-             * Represents warnings of the pattern scan.
-             * @param correctOpcode The opcode the instruction list has.
-             * @param wrongOpcode The opcode the pattern list of the signature currently has.
-             * @param instructionIndex The index of the opcode relative to the instruction list.
-             * @param patternIndex The index of the opcode relative to the pattern list from the signature.
-             */
-            data class Warning(
-                val correctOpcode: Opcode,
-                val wrongOpcode: Opcode,
-                val instructionIndex: Int,
-                val patternIndex: Int,
-            )
-        }
-    }
-}
--- a/src/main/kotlin/app/revanced/patcher/logging/Logger.kt
+++ b/src/main/kotlin/app/revanced/patcher/logging/Logger.kt
@@ -1,9 +0,0 @@
-package app.revanced.patcher.logging
-
-@Deprecated("This will be removed in a future release")
-interface Logger {
-    fun error(msg: String) {}
-    fun warn(msg: String) {}
-    fun info(msg: String) {}
-    fun trace(msg: String) {}
-}
--- a/src/main/kotlin/app/revanced/patcher/logging/impl/NopLogger.kt
+++ b/src/main/kotlin/app/revanced/patcher/logging/impl/NopLogger.kt
@@ -1,6 +0,0 @@
-package app.revanced.patcher.logging.impl
-
-import app.revanced.patcher.logging.Logger
-
-@Deprecated("This will be removed in a future release")
-object NopLogger : Logger
--- a/src/main/kotlin/app/revanced/patcher/patch/BytecodePatch.kt
+++ b/src/main/kotlin/app/revanced/patcher/patch/BytecodePatch.kt
@@ -1,13 +1,61 @@
 package app.revanced.patcher.patch

+import app.revanced.patcher.PatchClass
+import app.revanced.patcher.Patcher
 import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.fingerprint.MethodFingerprint
+import java.io.Closeable

 /**
- * A ReVanced [Patch] that works on [BytecodeContext].
+ * A ReVanced [Patch] that accesses a [BytecodeContext].
 *
- * @param fingerprints A list of [MethodFingerprint]s which will be resolved before the patch is executed.
+ * If an implementation of [Patch] also implements [Closeable]
+ * it will be closed in reverse execution order of patches executed by ReVanced [Patcher].
 */
-abstract class BytecodePatch(
-    internal val fingerprints : Set<MethodFingerprint> = emptySet(),
-) : Patch<BytecodeContext>()
+@Suppress("unused")
+abstract class BytecodePatch : Patch<BytecodeContext> {
+    /**
+     * The fingerprints to resolve before executing the patch.
+     */
+    internal val fingerprints: Set<MethodFingerprint>
+
+    /**
+     * Create a new [BytecodePatch].
+     *
+     * @param fingerprints The fingerprints to resolve before executing the patch.
+     */
+    constructor(fingerprints: Set<MethodFingerprint> = emptySet()) {
+        this.fingerprints = fingerprints
+    }
+
+    /**
+     * Create a new [BytecodePatch].
+     *
+     * @param name The name of the patch.
+     * @param description The description of the patch.
+     * @param compatiblePackages The packages the patch is compatible with.
+     * @param dependencies Other patches this patch depends on.
+     * @param use Weather or not the patch should be used.
+     * @param requiresIntegrations Weather or not the patch requires integrations.
+     */
+    constructor(
+        name: String? = null,
+        description: String? = null,
+        compatiblePackages: Set<CompatiblePackage>? = null,
+        dependencies: Set<PatchClass>? = null,
+        use: Boolean = true,
+        requiresIntegrations: Boolean = false,
+        fingerprints: Set<MethodFingerprint> = emptySet(),
+    ) : super(name, description, compatiblePackages, dependencies, use, requiresIntegrations) {
+        this.fingerprints = fingerprints
+    }
+
+    /**
+     * Create a new [BytecodePatch].
+     */
+    @Deprecated(
+        "Use the constructor with fingerprints instead.",
+        ReplaceWith("BytecodePatch(emptySet())"),
+    )
+    constructor() : this(emptySet())
+}
--- a/src/main/kotlin/app/revanced/patcher/patch/Patch.kt
+++ b/src/main/kotlin/app/revanced/patcher/patch/Patch.kt
@@ -5,12 +5,13 @@ package app.revanced.patcher.patch
 import app.revanced.patcher.PatchClass
 import app.revanced.patcher.Patcher
 import app.revanced.patcher.data.Context
+import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
 import app.revanced.patcher.patch.options.PatchOptions
 import java.io.Closeable
-import kotlin.reflect.full.findAnnotation

 /**
 * A ReVanced patch.
+ *
 * If an implementation of [Patch] also implements [Closeable]
 * it will be closed in reverse execution order of patches executed by ReVanced [Patcher].
 *
@@ -47,7 +48,6 @@ sealed class Patch<out T : Context<*>> {
    var use = true
        private set

-
    // TODO: Remove this property, once integrations are coupled with patches.
    /**
     * Weather or not the patch requires integrations.
@@ -55,23 +55,41 @@ sealed class Patch<out T : Context<*>> {
    var requiresIntegrations = false
        private set

+    constructor(
+        name: String?,
+        description: String?,
+        compatiblePackages: Set<CompatiblePackage>?,
+        dependencies: Set<PatchClass>?,
+        use: Boolean,
+        requiresIntegrations: Boolean,
+    ) {
+        this.name = name
+        this.description = description
+        this.compatiblePackages = compatiblePackages
+        this.dependencies = dependencies
+        this.use = use
+        this.requiresIntegrations = requiresIntegrations
+    }
+
+    constructor() {
+        this::class.findAnnotationRecursively(app.revanced.patcher.patch.annotation.Patch::class)?.let { annotation ->
+            this.name = annotation.name.ifEmpty { null }
+            this.description = annotation.description.ifEmpty { null }
+            this.compatiblePackages =
+                annotation.compatiblePackages
+                    .map { CompatiblePackage(it.name, it.versions.toSet().ifEmpty { null }) }
+                    .toSet().ifEmpty { null }
+            this.dependencies = annotation.dependencies.toSet().ifEmpty { null }
+            this.use = annotation.use
+            this.requiresIntegrations = annotation.requiresIntegrations
+        }
+    }
+
    /**
     * The options of the patch associated by the options key.
     */
    val options = PatchOptions()

-    init {
-        this::class.findAnnotation<app.revanced.patcher.patch.annotation.Patch>()?.let { annotation ->
-            name = annotation.name.ifEmpty { null }
-            description = annotation.description.ifEmpty { null }
-            compatiblePackages = annotation.compatiblePackages
-                .map { CompatiblePackage(it.name, it.versions.toSet()) }.toSet()
-            dependencies = annotation.dependencies.toSet().ifEmpty { null }
-            use = annotation.use
-            requiresIntegrations = annotation.requiresIntegrations
-        }
-    }
-
    /**
     * The execution function of the patch.
     *
@@ -103,4 +121,4 @@ sealed class Patch<out T : Context<*>> {
        val name: String,
        val versions: Set<String>? = null,
    )
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/patch/PatchException.kt
+++ b/src/main/kotlin/app/revanced/patcher/patch/PatchException.kt
@@ -9,4 +9,4 @@ package app.revanced.patcher.patch
 class PatchException(errorMessage: String?, cause: Throwable?) : Exception(errorMessage, cause) {
    constructor(errorMessage: String) : this(errorMessage, null)
    constructor(cause: Throwable) : this(cause.message, cause)
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/patch/PatchResult.kt
+++ b/src/main/kotlin/app/revanced/patcher/patch/PatchResult.kt
@@ -6,4 +6,4 @@ package app.revanced.patcher.patch
 * @param patch The [Patch] that was executed.
 * @param exception The [PatchException] thrown, if any.
 */
-class PatchResult internal constructor(val patch: Patch<*>, val exception: PatchException? = null)
+class PatchResult internal constructor(val patch: Patch<*>, val exception: PatchException? = null)
--- a/src/main/kotlin/app/revanced/patcher/patch/ResourcePatch.kt
+++ b/src/main/kotlin/app/revanced/patcher/patch/ResourcePatch.kt
@@ -1,8 +1,38 @@
 package app.revanced.patcher.patch

+import app.revanced.patcher.PatchClass
+import app.revanced.patcher.Patcher
 import app.revanced.patcher.data.ResourceContext
+import java.io.Closeable

 /**
- * A ReVanced [Patch] that works on [ResourceContext].
+ * A ReVanced [Patch] that accesses a [ResourceContext].
+ *
+ * If an implementation of [Patch] also implements [Closeable]
+ * it will be closed in reverse execution order of patches executed by ReVanced [Patcher].
 */
-abstract class ResourcePatch : Patch<ResourceContext>()
+abstract class ResourcePatch : Patch<ResourceContext> {
+    /**
+     * Create a new [ResourcePatch].
+     */
+    constructor()
+
+    /**
+     * Create a new [ResourcePatch].
+     *
+     * @param name The name of the patch.
+     * @param description The description of the patch.
+     * @param compatiblePackages The packages the patch is compatible with.
+     * @param dependencies Other patches this patch depends on.
+     * @param use Weather or not the patch should be used.
+     * @param requiresIntegrations Weather or not the patch requires integrations.
+     */
+    constructor(
+        name: String? = null,
+        description: String? = null,
+        compatiblePackages: Set<CompatiblePackage>? = null,
+        dependencies: Set<PatchClass>? = null,
+        use: Boolean = true,
+        requiresIntegrations: Boolean = false,
+    ) : super(name, description, compatiblePackages, dependencies, use, requiresIntegrations)
+}
--- a/src/main/kotlin/app/revanced/patcher/patch/annotation/PatchAnnotations.kt
+++ b/src/main/kotlin/app/revanced/patcher/patch/annotation/PatchAnnotations.kt
@@ -34,4 +34,4 @@ annotation class Patch(
 annotation class CompatiblePackage(
    val name: String,
    val versions: Array<String> = [],
-)
+)
--- a/src/main/kotlin/app/revanced/patcher/patch/options/PatchOption.kt
+++ b/src/main/kotlin/app/revanced/patcher/patch/options/PatchOption.kt
@@ -8,10 +8,11 @@ import kotlin.reflect.KProperty
 *
 * @param key The identifier.
 * @param default The default value.
- * @param values The set of guaranteed valid values.
+ * @param values The set of guaranteed valid values identified by their string representation.
 * @param title The title.
 * @param description A description.
 * @param required Whether the option is required.
+ * @param valueType The type of the option value (to handle type erasure).
 * @param validator The function to validate the option value.
 * @param T The value type of the option.
 */
@@ -19,11 +20,12 @@ import kotlin.reflect.KProperty
 open class PatchOption<T>(
    val key: String,
    val default: T?,
-    val values: Set<T>,
+    val values: Map<String, T?>?,
    val title: String?,
    val description: String?,
    val required: Boolean,
-    val validator: PatchOption<T>.(T?) -> Boolean
+    val valueType: String,
+    val validator: PatchOption<T>.(T?) -> Boolean,
 ) {
    /**
     * The value of the [PatchOption].
@@ -43,6 +45,7 @@ open class PatchOption<T>(

            uncheckedValue = value
        }
+
        /**
         * Get the value of the [PatchOption].
         *
@@ -77,11 +80,19 @@ open class PatchOption<T>(
        if (!validator(value)) throw PatchOptionException.ValueValidationException(value, this)
    }

+
    override fun toString() = value.toString()

-    operator fun getValue(thisRef: Any?, property: KProperty<*>) = value
+    operator fun getValue(
+        thisRef: Any?,
+        property: KProperty<*>,
+    ) = value

-    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T?) {
+    operator fun setValue(
+        thisRef: Any?,
+        property: KProperty<*>,
+        value: T?,
+    ) {
        this.value = value
    }

@@ -105,12 +116,21 @@ open class PatchOption<T>(
        fun <P : Patch<*>> P.stringPatchOption(
            key: String,
            default: String? = null,
-            values: Set<String> = emptySet(),
+            values: Map<String, String?>? = null,
            title: String? = null,
            description: String? = null,
            required: Boolean = false,
-            validator: PatchOption<String>.(String?) -> Boolean = { true }
-        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+            validator: PatchOption<String>.(String?) -> Boolean = { true },
+        ) = registerNewPatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            "String",
+            validator,
+        )

        /**
         * Create a new [PatchOption] with an integer value and add it to the current [Patch].
@@ -130,12 +150,21 @@ open class PatchOption<T>(
        fun <P : Patch<*>> P.intPatchOption(
            key: String,
            default: Int? = null,
-            values: Set<Int> = emptySet(),
+            values: Map<String, Int?>? = null,
            title: String? = null,
            description: String? = null,
            required: Boolean = false,
-            validator: PatchOption<Int?>.(Int?) -> Boolean = { true }
-        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+            validator: PatchOption<Int?>.(Int?) -> Boolean = { true },
+        ) = registerNewPatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            "Int",
+            validator,
+        )

        /**
         * Create a new [PatchOption] with a boolean value and add it to the current [Patch].
@@ -155,12 +184,21 @@ open class PatchOption<T>(
        fun <P : Patch<*>> P.booleanPatchOption(
            key: String,
            default: Boolean? = null,
-            values: Set<Boolean> = emptySet(),
+            values: Map<String, Boolean?>? = null,
            title: String? = null,
            description: String? = null,
            required: Boolean = false,
-            validator: PatchOption<Boolean?>.(Boolean?) -> Boolean = { true }
-        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+            validator: PatchOption<Boolean?>.(Boolean?) -> Boolean = { true },
+        ) = registerNewPatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            "Boolean",
+            validator,
+        )

        /**
         * Create a new [PatchOption] with a float value and add it to the current [Patch].
@@ -180,12 +218,21 @@ open class PatchOption<T>(
        fun <P : Patch<*>> P.floatPatchOption(
            key: String,
            default: Float? = null,
-            values: Set<Float> = emptySet(),
+            values: Map<String, Float?>? = null,
            title: String? = null,
            description: String? = null,
            required: Boolean = false,
-            validator: PatchOption<Float?>.(Float?) -> Boolean = { true }
-        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+            validator: PatchOption<Float?>.(Float?) -> Boolean = { true },
+        ) = registerNewPatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            "Float",
+            validator,
+        )

        /**
         * Create a new [PatchOption] with a long value and add it to the current [Patch].
@@ -205,12 +252,21 @@ open class PatchOption<T>(
        fun <P : Patch<*>> P.longPatchOption(
            key: String,
            default: Long? = null,
-            values: Set<Long> = emptySet(),
+            values: Map<String, Long?>? = null,
            title: String? = null,
            description: String? = null,
            required: Boolean = false,
-            validator: PatchOption<Long?>.(Long?) -> Boolean = { true }
-        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+            validator: PatchOption<Long?>.(Long?) -> Boolean = { true },
+        ) = registerNewPatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            "Long",
+            validator,
+        )

        /**
         * Create a new [PatchOption] with a string array value and add it to the current [Patch].
@@ -230,12 +286,21 @@ open class PatchOption<T>(
        fun <P : Patch<*>> P.stringArrayPatchOption(
            key: String,
            default: Array<String>? = null,
-            values: Set<Array<String>> = emptySet(),
+            values: Map<String, Array<String>?>? = null,
            title: String? = null,
            description: String? = null,
            required: Boolean = false,
-            validator: PatchOption<Array<String>?>.(Array<String>?) -> Boolean = { true }
-        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+            validator: PatchOption<Array<String>?>.(Array<String>?) -> Boolean = { true },
+        ) = registerNewPatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            "StringArray",
+            validator,
+        )

        /**
         * Create a new [PatchOption] with an integer array value and add it to the current [Patch].
@@ -255,12 +320,21 @@ open class PatchOption<T>(
        fun <P : Patch<*>> P.intArrayPatchOption(
            key: String,
            default: Array<Int>? = null,
-            values: Set<Array<Int>> = emptySet(),
+            values: Map<String, Array<Int>?>? = null,
            title: String? = null,
            description: String? = null,
            required: Boolean = false,
-            validator: PatchOption<Array<Int>?>.(Array<Int>?) -> Boolean = { true }
-        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+            validator: PatchOption<Array<Int>?>.(Array<Int>?) -> Boolean = { true },
+        ) = registerNewPatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            "IntArray",
+            validator,
+        )

        /**
         * Create a new [PatchOption] with a boolean array value and add it to the current [Patch].
@@ -280,12 +354,21 @@ open class PatchOption<T>(
        fun <P : Patch<*>> P.booleanArrayPatchOption(
            key: String,
            default: Array<Boolean>? = null,
-            values: Set<Array<Boolean>> = emptySet(),
+            values: Map<String, Array<Boolean>?>? = null,
            title: String? = null,
            description: String? = null,
            required: Boolean = false,
-            validator: PatchOption<Array<Boolean>?>.(Array<Boolean>?) -> Boolean = { true }
-        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+            validator: PatchOption<Array<Boolean>?>.(Array<Boolean>?) -> Boolean = { true },
+        ) = registerNewPatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            "BooleanArray",
+            validator,
+        )

        /**
         * Create a new [PatchOption] with a float array value and add it to the current [Patch].
@@ -305,12 +388,21 @@ open class PatchOption<T>(
        fun <P : Patch<*>> P.floatArrayPatchOption(
            key: String,
            default: Array<Float>? = null,
-            values: Set<Array<Float>> = emptySet(),
+            values: Map<String, Array<Float>?>? = null,
            title: String? = null,
            description: String? = null,
            required: Boolean = false,
-            validator: PatchOption<Array<Float>?>.(Array<Float>?) -> Boolean = { true }
-        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+            validator: PatchOption<Array<Float>?>.(Array<Float>?) -> Boolean = { true },
+        ) = registerNewPatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            "FloatArray",
+            validator,
+        )

        /**
         * Create a new [PatchOption] with a long array value and add it to the current [Patch].
@@ -330,13 +422,56 @@ open class PatchOption<T>(
        fun <P : Patch<*>> P.longArrayPatchOption(
            key: String,
            default: Array<Long>? = null,
-            values: Set<Array<Long>> = emptySet(),
+            values: Map<String, Array<Long>?>? = null,
            title: String? = null,
            description: String? = null,
            required: Boolean = false,
-            validator: PatchOption<Array<Long>?>.(Array<Long>?) -> Boolean = { true }
-        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+            validator: PatchOption<Array<Long>?>.(Array<Long>?) -> Boolean = { true },
+        ) = registerNewPatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            "LongArray",
+            validator,
+        )

-        private fun <P : Patch<*>> P.registerOption(option: PatchOption<*>) = option.also { options.register(it) }
+        /**
+         * Create a new [PatchOption] with a string set value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values identified by their string representation.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param valueType The type of the option value (to handle type erasure).
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>, T> P.registerNewPatchOption(
+            key: String,
+            default: T? = null,
+            values: Map<String, T?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            valueType: String,
+            validator: PatchOption<T>.(T?) -> Boolean = { true },
+        ) = PatchOption(
+            key,
+            default,
+            values,
+            title,
+            description,
+            required,
+            valueType,
+            validator,
+        ).also(options::register)
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/patch/options/PatchOptionException.kt
+++ b/src/main/kotlin/app/revanced/patcher/patch/options/PatchOptionException.kt
@@ -36,6 +36,6 @@ sealed class PatchOptionException(errorMessage: String) : Exception(errorMessage
     *
     * @param key The key of the [PatchOption].
     */
-    class PatchOptionNotFoundException(key: String)
-        : PatchOptionException("No option with key $key")
-}
+    class PatchOptionNotFoundException(key: String) :
+        PatchOptionException("No option with key $key")
+}
--- a/src/main/kotlin/app/revanced/patcher/patch/options/PatchOptions.kt
+++ b/src/main/kotlin/app/revanced/patcher/patch/options/PatchOptions.kt
@@ -1,13 +1,12 @@
 package app.revanced.patcher.patch.options

-
 /**
 * A map of [PatchOption]s associated by their keys.
 *
 * @param options The [PatchOption]s to initialize with.
 */
 class PatchOptions internal constructor(
-    private val options: MutableMap<String, PatchOption<*>> = mutableMapOf()
+    private val options: MutableMap<String, PatchOption<*>> = mutableMapOf(),
 ) : MutableMap<String, PatchOption<*>> by options {
    /**
     * Register a [PatchOption]. Acts like [MutableMap.put].
@@ -23,7 +22,10 @@ class PatchOptions internal constructor(
     * @param value The value.
     * @throws PatchOptionException.PatchOptionNotFoundException If the option does not exist.
     */
-    operator fun <T : Any> set(key: String, value: T?) {
+    operator fun <T : Any> set(
+        key: String,
+        value: T?,
+    ) {
        val option = this[key]

        try {
@@ -40,6 +42,5 @@ class PatchOptions internal constructor(
    /**
     * Get an option.
     */
-    override operator fun get(key: String) =
-        options[key] ?: throw PatchOptionException.PatchOptionNotFoundException(key)
-}
+    override operator fun get(key: String) = options[key] ?: throw PatchOptionException.PatchOptionNotFoundException(key)
+}
--- a/src/main/kotlin/app/revanced/patcher/util/ClassMerger.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/ClassMerger.kt
@@ -34,9 +34,12 @@ internal object ClassMerger {
     * @param context The context to traverse the class hierarchy in.
     * @return The merged class or the original class if no merge was needed.
     */
-    fun ClassDef.merge(otherClass: ClassDef, context: BytecodeContext) = this
-        //.fixFieldAccess(otherClass)
-        //.fixMethodAccess(otherClass)
+    fun ClassDef.merge(
+        otherClass: ClassDef,
+        context: BytecodeContext,
+    ) = this
+        // .fixFieldAccess(otherClass)
+        // .fixMethodAccess(otherClass)
        .addMissingFields(otherClass)
        .addMissingMethods(otherClass)
        .publicize(otherClass, context)
@@ -47,13 +50,14 @@ internal object ClassMerger {
     * @param fromClass The class to add missing methods from.
     */
    private fun ClassDef.addMissingMethods(fromClass: ClassDef): ClassDef {
-        val missingMethods = fromClass.methods.let { fromMethods ->
-            methods.filterNot { method ->
-                fromMethods.any { fromMethod ->
-                    MethodUtil.methodSignaturesMatch(fromMethod, method)
+        val missingMethods =
+            fromClass.methods.let { fromMethods ->
+                methods.filterNot { method ->
+                    fromMethods.any { fromMethod ->
+                        MethodUtil.methodSignaturesMatch(fromMethod, method)
+                    }
                }
            }
-        }

        if (missingMethods.isEmpty()) return this

@@ -70,9 +74,10 @@ internal object ClassMerger {
     * @param fromClass The class to add missing fields from.
     */
    private fun ClassDef.addMissingFields(fromClass: ClassDef): ClassDef {
-        val missingFields = fields.filterNotAny(fromClass.fields) { field, fromField ->
-            fromField.name == field.name
-        }
+        val missingFields =
+            fields.filterNotAny(fromClass.fields) { field, fromField ->
+                fromField.name == field.name
+            }

        if (missingFields.isEmpty()) return this

@@ -88,18 +93,22 @@ internal object ClassMerger {
     * @param reference The class to check the [AccessFlags] of.
     * @param context The context to traverse the class hierarchy in.
     */
-    private fun ClassDef.publicize(reference: ClassDef, context: BytecodeContext) =
-        if (reference.accessFlags.isPublic() && !accessFlags.isPublic())
-            this.asMutableClass().apply {
-                context.traverseClassHierarchy(this) {
-                    if (accessFlags.isPublic()) return@traverseClassHierarchy
+    private fun ClassDef.publicize(
+        reference: ClassDef,
+        context: BytecodeContext,
+    ) = if (reference.accessFlags.isPublic() && !accessFlags.isPublic()) {
+        this.asMutableClass().apply {
+            context.traverseClassHierarchy(this) {
+                if (accessFlags.isPublic()) return@traverseClassHierarchy

-                    logger.fine("Publicizing ${this.type}")
+                logger.fine("Publicizing ${this.type}")

-                    accessFlags = accessFlags.toPublic()
-                }
+                accessFlags = accessFlags.toPublic()
            }
-        else this
+        }
+    } else {
+        this
+    }

    /**
     * Publicize fields if they are public in [reference].
@@ -107,11 +116,12 @@ internal object ClassMerger {
     * @param reference The class to check the [AccessFlags] of the fields in.
     */
    private fun ClassDef.fixFieldAccess(reference: ClassDef): ClassDef {
-        val brokenFields = fields.filterAny(reference.fields) { field, referenceField ->
-            if (field.name != referenceField.name) return@filterAny false
+        val brokenFields =
+            fields.filterAny(reference.fields) { field, referenceField ->
+                if (field.name != referenceField.name) return@filterAny false

-            referenceField.accessFlags.isPublic() && !field.accessFlags.isPublic()
-        }
+                referenceField.accessFlags.isPublic() && !field.accessFlags.isPublic()
+            }

        if (brokenFields.isEmpty()) return this

@@ -135,11 +145,12 @@ internal object ClassMerger {
     * @param reference The class to check the [AccessFlags] of the methods in.
     */
    private fun ClassDef.fixMethodAccess(reference: ClassDef): ClassDef {
-        val brokenMethods = methods.filterAny(reference.methods) { method, referenceMethod ->
-            if (!MethodUtil.methodSignaturesMatch(method, referenceMethod)) return@filterAny false
+        val brokenMethods =
+            methods.filterAny(reference.methods) { method, referenceMethod ->
+                if (!MethodUtil.methodSignaturesMatch(method, referenceMethod)) return@filterAny false

-            referenceMethod.accessFlags.isPublic() && !method.accessFlags.isPublic()
-        }
+                referenceMethod.accessFlags.isPublic() && !method.accessFlags.isPublic()
+            }

        if (brokenMethods.isEmpty()) return this

@@ -164,7 +175,10 @@ internal object ClassMerger {
         * @param targetClass the class to start traversing the class hierarchy from
         * @param callback function that is called for every class in the hierarchy
         */
-        fun BytecodeContext.traverseClassHierarchy(targetClass: MutableClass, callback: MutableClass.() -> Unit) {
+        fun BytecodeContext.traverseClassHierarchy(
+            targetClass: MutableClass,
+            callback: MutableClass.() -> Unit,
+        ) {
            callback(targetClass)
            this.findClass(targetClass.superclass ?: return)?.mutableClass?.let {
                traverseClassHierarchy(it, callback)
@@ -195,7 +209,8 @@ internal object ClassMerger {
         * @return The [this] filtered on [needles] matching the given [predicate].
         */
        fun <HayType, NeedleType> Iterable<HayType>.filterAny(
-            needles: Iterable<NeedleType>, predicate: (HayType, NeedleType) -> Boolean
+            needles: Iterable<NeedleType>,
+            predicate: (HayType, NeedleType) -> Boolean,
        ) = Iterable<HayType>::filter.any(this, needles, predicate)

        /**
@@ -206,17 +221,18 @@ internal object ClassMerger {
         * @return The [this] filtered on [needles] not matching the given [predicate].
         */
        fun <HayType, NeedleType> Iterable<HayType>.filterNotAny(
-            needles: Iterable<NeedleType>, predicate: (HayType, NeedleType) -> Boolean
+            needles: Iterable<NeedleType>,
+            predicate: (HayType, NeedleType) -> Boolean,
        ) = Iterable<HayType>::filterNot.any(this, needles, predicate)

        fun <HayType, NeedleType> KFunction2<Iterable<HayType>, (HayType) -> Boolean, List<HayType>>.any(
            haystack: Iterable<HayType>,
            needles: Iterable<NeedleType>,
-            predicate: (HayType, NeedleType) -> Boolean
+            predicate: (HayType, NeedleType) -> Boolean,
        ) = this(haystack) { hay ->
            needles.any { needle ->
                predicate(hay, needle)
            }
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/DomFileEditor.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/DomFileEditor.kt
@@ -31,9 +31,9 @@ class DomFileEditor internal constructor(
    /**
     * The document of the xml file
     */
-    val file: Document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream)
-        .also(Document::normalize)
-
+    val file: Document =
+        DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream)
+            .also(Document::normalize)

    // lazily open an output stream
    // this is required because when constructing a DomFileEditor the output stream is created along with the input stream, which is not allowed
@@ -58,12 +58,13 @@ class DomFileEditor internal constructor(
        outputStream?.let {
            // prevent writing to same file, if it is being locked
            // isLocked will be false if the editor was created through a stream
-            val isLocked = filePath?.let { path ->
-                val isLocked = locks[path]!! > 1
-                // decrease the lock count if the editor was opened for a file
-                locks.merge(path, -1, Integer::sum)
-                isLocked
-            } ?: false
+            val isLocked =
+                filePath?.let { path ->
+                    val isLocked = locks[path]!! > 1
+                    // decrease the lock count if the editor was opened for a file
+                    locks.merge(path, -1, Integer::sum)
+                    isLocked
+                } ?: false

            // if unlocked, write back to the file
            if (!isLocked) {
@@ -84,4 +85,4 @@ class DomFileEditor internal constructor(
        // map of concurrent open files
        val locks = mutableMapOf<String, Int>()
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/ProxyClassList.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/ProxyClassList.kt
@@ -19,15 +19,16 @@ class ProxyClassList internal constructor(classes: MutableSet<ClassDef>) : Mutab
    /**
     * Replace all classes with their mutated versions.
     */
-    internal fun replaceClasses() = proxies.removeIf { proxy ->
-        // If the proxy is unused, return false to keep it in the proxies list.
+    internal fun replaceClasses() =
+        proxies.removeIf { proxy ->
+            // If the proxy is unused, return false to keep it in the proxies list.
            if (!proxy.resolved) return@removeIf false

-        // If it has been used, replace the original class with the mutable class.
-        remove(proxy.immutableClass)
-        add(proxy.mutableClass)
+            // If it has been used, replace the original class with the mutable class.
+            remove(proxy.immutableClass)
+            add(proxy.mutableClass)

-        // Return true to remove the proxy from the proxies list.
+            // Return true to remove the proxy from the proxies list.
            return@removeIf true
        }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/method/MethodWalker.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/method/MethodWalker.kt
@@ -14,7 +14,7 @@ import com.android.tools.smali.dexlib2.util.MethodUtil
 */
 class MethodWalker internal constructor(
    private val bytecodeContext: BytecodeContext,
-    private var currentMethod: Method
+    private var currentMethod: Method,
 ) {
    /**
     * Get the method which was walked last.
@@ -36,7 +36,10 @@ class MethodWalker internal constructor(
     * @param walkMutable If this is true, the class of the method will be resolved mutably.
     * @return The same [MethodWalker] instance with the method at [offset].
     */
-    fun nextMethod(offset: Int, walkMutable: Boolean = false): MethodWalker {
+    fun nextMethod(
+        offset: Int,
+        walkMutable: Boolean = false,
+    ): MethodWalker {
        currentMethod.implementation?.instructions?.let { instructions ->
            val instruction = instructions.elementAt(offset)

@@ -44,13 +47,14 @@ class MethodWalker internal constructor(
            val proxy = bytecodeContext.findClass(newMethod.definingClass)!!

            val methods = if (walkMutable) proxy.mutableClass.methods else proxy.immutableClass.methods
-            currentMethod = methods.first {
-                return@first MethodUtil.methodSignaturesMatch(it, newMethod)
-            }
+            currentMethod =
+                methods.first {
+                    return@first MethodUtil.methodSignaturesMatch(it, newMethod)
+                }
            return this
        }
        throw MethodNotFoundException("This method can not be walked at offset $offset inside the method ${currentMethod.name}")
    }

    internal class MethodNotFoundException(exception: String) : Exception(exception)
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/ClassProxy.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/ClassProxy.kt
@@ -27,7 +27,8 @@ class ClassProxy internal constructor(
        resolved = true
        if (immutableClass is MutableClass) {
            immutableClass
-        } else
+        } else {
            MutableClass(immutableClass)
+        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableAnnotationElement.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableAnnotationElement.kt
@@ -31,4 +31,4 @@ class MutableAnnotationElement(annotationElement: AnnotationElement) : BaseAnnot
            return MutableAnnotationElement(this)
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableClass.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableClass.kt
@@ -3,11 +3,11 @@ package app.revanced.patcher.util.proxy.mutableTypes
 import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
 import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
-import com.google.common.collect.Iterables
 import com.android.tools.smali.dexlib2.base.reference.BaseTypeReference
 import com.android.tools.smali.dexlib2.iface.ClassDef
 import com.android.tools.smali.dexlib2.util.FieldUtil
 import com.android.tools.smali.dexlib2.util.MethodUtil
+import com.google.common.collect.Iterables

 class MutableClass(classDef: ClassDef) : ClassDef, BaseTypeReference() {
    // Class
@@ -100,4 +100,4 @@ class MutableClass(classDef: ClassDef) : ClassDef, BaseTypeReference() {
            return MutableClass(this)
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableMethod.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableMethod.kt
@@ -77,4 +77,4 @@ class MutableMethod(method: Method) : Method, BaseMethodReference() {
            return MutableMethod(this)
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableAnnotationEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableAnnotationEncodedValue.kt
@@ -5,7 +5,8 @@ import com.android.tools.smali.dexlib2.base.value.BaseAnnotationEncodedValue
 import com.android.tools.smali.dexlib2.iface.AnnotationElement
 import com.android.tools.smali.dexlib2.iface.value.AnnotationEncodedValue

-class MutableAnnotationEncodedValue(annotationEncodedValue: AnnotationEncodedValue) : BaseAnnotationEncodedValue(),
+class MutableAnnotationEncodedValue(annotationEncodedValue: AnnotationEncodedValue) :
+    BaseAnnotationEncodedValue(),
    MutableEncodedValue {
    private var type = annotationEncodedValue.type

--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableBooleanEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableBooleanEncodedValue.kt
@@ -3,7 +3,8 @@ package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 import com.android.tools.smali.dexlib2.base.value.BaseBooleanEncodedValue
 import com.android.tools.smali.dexlib2.iface.value.BooleanEncodedValue

-class MutableBooleanEncodedValue(booleanEncodedValue: BooleanEncodedValue) : BaseBooleanEncodedValue(),
+class MutableBooleanEncodedValue(booleanEncodedValue: BooleanEncodedValue) :
+    BaseBooleanEncodedValue(),
    MutableEncodedValue {
    private var value = booleanEncodedValue.value

@@ -20,4 +21,4 @@ class MutableBooleanEncodedValue(booleanEncodedValue: BooleanEncodedValue) : Bas
            return MutableBooleanEncodedValue(this)
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableByteEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableByteEncodedValue.kt
@@ -19,4 +19,4 @@ class MutableByteEncodedValue(byteEncodedValue: ByteEncodedValue) : BaseByteEnco
            return MutableByteEncodedValue(this)
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableDoubleEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableDoubleEncodedValue.kt
@@ -3,7 +3,8 @@ package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 import com.android.tools.smali.dexlib2.base.value.BaseDoubleEncodedValue
 import com.android.tools.smali.dexlib2.iface.value.DoubleEncodedValue

-class MutableDoubleEncodedValue(doubleEncodedValue: DoubleEncodedValue) : BaseDoubleEncodedValue(),
+class MutableDoubleEncodedValue(doubleEncodedValue: DoubleEncodedValue) :
+    BaseDoubleEncodedValue(),
    MutableEncodedValue {
    private var value = doubleEncodedValue.value

@@ -20,4 +21,4 @@ class MutableDoubleEncodedValue(doubleEncodedValue: DoubleEncodedValue) : BaseDo
            return MutableDoubleEncodedValue(this)
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue.kt
@@ -29,4 +29,4 @@ interface MutableEncodedValue : EncodedValue {
            }
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFloatEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFloatEncodedValue.kt
@@ -19,4 +19,4 @@ class MutableFloatEncodedValue(floatEncodedValue: FloatEncodedValue) : BaseFloat
            return MutableFloatEncodedValue(this)
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableIntEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableIntEncodedValue.kt
@@ -19,4 +19,4 @@ class MutableIntEncodedValue(intEncodedValue: IntEncodedValue) : BaseIntEncodedV
            return MutableIntEncodedValue(this)
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodEncodedValue.kt
@@ -4,7 +4,8 @@ import com.android.tools.smali.dexlib2.base.value.BaseMethodEncodedValue
 import com.android.tools.smali.dexlib2.iface.reference.MethodReference
 import com.android.tools.smali.dexlib2.iface.value.MethodEncodedValue

-class MutableMethodEncodedValue(methodEncodedValue: MethodEncodedValue) : BaseMethodEncodedValue(),
+class MutableMethodEncodedValue(methodEncodedValue: MethodEncodedValue) :
+    BaseMethodEncodedValue(),
    MutableEncodedValue {
    private var value = methodEncodedValue.value

--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodHandleEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodHandleEncodedValue.kt
@@ -22,6 +22,4 @@ class MutableMethodHandleEncodedValue(methodHandleEncodedValue: MethodHandleEnco
            return MutableMethodHandleEncodedValue(this)
        }
    }
-
-
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodTypeEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodTypeEncodedValue.kt
@@ -4,7 +4,8 @@ import com.android.tools.smali.dexlib2.base.value.BaseMethodTypeEncodedValue
 import com.android.tools.smali.dexlib2.iface.reference.MethodProtoReference
 import com.android.tools.smali.dexlib2.iface.value.MethodTypeEncodedValue

-class MutableMethodTypeEncodedValue(methodTypeEncodedValue: MethodTypeEncodedValue) : BaseMethodTypeEncodedValue(),
+class MutableMethodTypeEncodedValue(methodTypeEncodedValue: MethodTypeEncodedValue) :
+    BaseMethodTypeEncodedValue(),
    MutableEncodedValue {
    private var value = methodTypeEncodedValue.value

@@ -21,6 +22,4 @@ class MutableMethodTypeEncodedValue(methodTypeEncodedValue: MethodTypeEncodedVal
            return MutableMethodTypeEncodedValue(this)
        }
    }
-
-
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableNullEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableNullEncodedValue.kt
@@ -9,4 +9,4 @@ class MutableNullEncodedValue : BaseNullEncodedValue(), MutableEncodedValue {
            return MutableByteEncodedValue(this)
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableStringEncodedValue.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableStringEncodedValue.kt
@@ -4,7 +4,8 @@ import com.android.tools.smali.dexlib2.base.value.BaseStringEncodedValue
 import com.android.tools.smali.dexlib2.iface.value.ByteEncodedValue
 import com.android.tools.smali.dexlib2.iface.value.StringEncodedValue

-class MutableStringEncodedValue(stringEncodedValue: StringEncodedValue) : BaseStringEncodedValue(),
+class MutableStringEncodedValue(stringEncodedValue: StringEncodedValue) :
+    BaseStringEncodedValue(),
    MutableEncodedValue {
    private var value = stringEncodedValue.value

@@ -21,4 +22,4 @@ class MutableStringEncodedValue(stringEncodedValue: StringEncodedValue) : BaseSt
            return MutableByteEncodedValue(this)
        }
    }
-}
+}
--- a/src/main/kotlin/app/revanced/patcher/util/smali/InlineSmaliCompiler.kt
+++ b/src/main/kotlin/app/revanced/patcher/util/smali/InlineSmaliCompiler.kt
@@ -1,9 +1,6 @@
 package app.revanced.patcher.util.smali

 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
-import org.antlr.runtime.CommonTokenStream
-import org.antlr.runtime.TokenSource
-import org.antlr.runtime.tree.CommonTreeNodeStream
 import com.android.tools.smali.dexlib2.AccessFlags
 import com.android.tools.smali.dexlib2.Opcodes
 import com.android.tools.smali.dexlib2.builder.BuilderInstruction
@@ -12,6 +9,9 @@ import com.android.tools.smali.smali.LexerErrorInterface
 import com.android.tools.smali.smali.smaliFlexLexer
 import com.android.tools.smali.smali.smaliParser
 import com.android.tools.smali.smali.smaliTreeWalker
+import org.antlr.runtime.CommonTokenStream
+import org.antlr.runtime.TokenSource
+import org.antlr.runtime.tree.CommonTreeNodeStream
 import java.io.InputStreamReader
 import java.util.Locale

@@ -32,15 +32,23 @@ class InlineSmaliCompiler {
         * if the parameters and registers of the method are passed.
         */
        fun compile(
-            instructions: String, parameters: String, registers: Int, forStaticMethod: Boolean
+            instructions: String,
+            parameters: String,
+            registers: Int,
+            forStaticMethod: Boolean,
        ): List<BuilderInstruction> {
-            val input = METHOD_TEMPLATE.format(Locale.ENGLISH,
-                if (forStaticMethod) {
-                    "static"
-                } else {
-                    ""
-                }, parameters, registers, instructions
-            )
+            val input =
+                METHOD_TEMPLATE.format(
+                    Locale.ENGLISH,
+                    if (forStaticMethod) {
+                        "static"
+                    } else {
+                        ""
+                    },
+                    parameters,
+                    registers,
+                    instructions,
+                )
            val reader = InputStreamReader(input.byteInputStream())
            val lexer: LexerErrorInterface = smaliFlexLexer(reader, 15)
            val tokens = CommonTokenStream(lexer as TokenSource)
@@ -48,7 +56,7 @@ class InlineSmaliCompiler {
            val result = parser.smali_file()
            if (parser.numberOfSyntaxErrors > 0 || lexer.numberOfSyntaxErrors > 0) {
                throw IllegalStateException(
-                    "Encountered ${parser.numberOfSyntaxErrors} parser syntax errors and ${lexer.numberOfSyntaxErrors} lexer syntax errors!"
+                    "Encountered ${parser.numberOfSyntaxErrors} parser syntax errors and ${lexer.numberOfSyntaxErrors} lexer syntax errors!",
                )
            }
            val treeStream = CommonTreeNodeStream(result.tree)
@@ -70,10 +78,11 @@ class InlineSmaliCompiler {
 * @returns A list of instructions.
 */
 fun String.toInstructions(method: MutableMethod? = null): List<BuilderInstruction> {
-    return InlineSmaliCompiler.compile(this,
+    return InlineSmaliCompiler.compile(
+        this,
        method?.parameters?.joinToString("") { it } ?: "",
        method?.implementation?.registerCount ?: 1,
-        method?.let { AccessFlags.STATIC.isSet(it.accessFlags) } ?: true
+        method?.let { AccessFlags.STATIC.isSet(it.accessFlags) } ?: true,
    )
 }

@@ -82,4 +91,4 @@ fun String.toInstructions(method: MutableMethod? = null): List<BuilderInstructio
 * @param templateMethod The method to compile the instructions against.
 * @return The instruction.
 */
-fun String.toInstruction(templateMethod: MutableMethod? = null) = this.toInstructions(templateMethod).first()
+fun String.toInstruction(templateMethod: MutableMethod? = null) = this.toInstructions(templateMethod).first()
--- a/src/test/kotlin/app/revanced/patcher/extensions/AnnotationExtensionsTest.kt
+++ b/src/test/kotlin/app/revanced/patcher/extensions/AnnotationExtensionsTest.kt
@@ -0,0 +1,50 @@
+package app.revanced.patcher.extensions
+
+import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
+import kotlin.test.Test
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+
+private object AnnotationExtensionsTest {
+    @Test
+    fun `find annotation in annotated class`() {
+        assertNotNull(TestClasses.Annotation2::class.findAnnotationRecursively(TestClasses.Annotation::class))
+    }
+
+    @Test
+    fun `find annotation`() {
+        assertNotNull(TestClasses.AnnotatedClass::class.findAnnotationRecursively(TestClasses.Annotation::class))
+    }
+
+    @Test
+    fun `find annotation recursively in super class`() {
+        assertNotNull(TestClasses.AnnotatedClass2::class.findAnnotationRecursively(TestClasses.Annotation::class))
+    }
+
+    @Test
+    fun `find annotation recursively in super class with annotation`() {
+        assertNotNull(TestClasses.AnnotatedTestClass3::class.findAnnotationRecursively(TestClasses.Annotation::class))
+    }
+
+    @Test
+    fun `don't find unknown annotation in annotated class`() {
+        assertNull(TestClasses.AnnotatedClass::class.findAnnotationRecursively(TestClasses.UnknownAnnotation::class))
+    }
+
+    object TestClasses {
+        annotation class Annotation
+
+        @Annotation
+        annotation class Annotation2
+
+        annotation class UnknownAnnotation
+
+        @Annotation
+        abstract class AnnotatedClass
+
+        @Annotation2
+        class AnnotatedTestClass3
+
+        abstract class AnnotatedClass2 : AnnotatedClass()
+    }
+}
--- a/src/test/kotlin/app/revanced/patcher/extensions/InstructionExtensionsTest.kt
+++ b/src/test/kotlin/app/revanced/patcher/extensions/InstructionExtensionsTest.kt
@@ -27,180 +27,202 @@ private object InstructionExtensionsTest {
    private lateinit var testMethodImplementation: MutableMethodImplementation

    @BeforeEach
-    fun createTestMethod() = ImmutableMethod(
-        "TestClass;",
-        "testMethod",
-        null,
-        "V",
-        AccessFlags.PUBLIC.value,
-        null,
-        null,
-        MutableMethodImplementation(16).also { testMethodImplementation = it }.apply {
-            repeat(10) { i -> this.addInstruction(TestInstruction(i)) }
-        },
-    ).let { testMethod = it.toMutable() }
+    fun createTestMethod() =
+        ImmutableMethod(
+            "TestClass;",
+            "testMethod",
+            null,
+            "V",
+            AccessFlags.PUBLIC.value,
+            null,
+            null,
+            MutableMethodImplementation(16).also { testMethodImplementation = it }.apply {
+                repeat(10) { i -> this.addInstruction(TestInstruction(i)) }
+            },
+        ).let { testMethod = it.toMutable() }

    @Test
-    fun addInstructionsToImplementationIndexed() = applyToImplementation {
-        addInstructions(5, getTestInstructions(5..6)).also {
-            assertRegisterIs(5, 5)
-            assertRegisterIs(6, 6)
+    fun addInstructionsToImplementationIndexed() =
+        applyToImplementation {
+            addInstructions(5, getTestInstructions(5..6)).also {
+                assertRegisterIs(5, 5)
+                assertRegisterIs(6, 6)

-            assertRegisterIs(5, 7)
+                assertRegisterIs(5, 7)
+            }
        }
-    }

    @Test
-    fun addInstructionsToImplementation() = applyToImplementation {
-        addInstructions(getTestInstructions(10..11)).also {
-            assertRegisterIs(10, 10)
-            assertRegisterIs(11, 11)
+    fun addInstructionsToImplementation() =
+        applyToImplementation {
+            addInstructions(getTestInstructions(10..11)).also {
+                assertRegisterIs(10, 10)
+                assertRegisterIs(11, 11)
+            }
        }
-    }

    @Test
-    fun removeInstructionsFromImplementationIndexed() = applyToImplementation {
-        removeInstructions(5, 5).also { assertRegisterIs(4, 4) }
-    }
-
-    @Test
-    fun removeInstructionsFromImplementation() = applyToImplementation {
-        removeInstructions(0).also { assertRegisterIs(9, 9) }
-        removeInstructions(1).also { assertRegisterIs(1, 0) }
-        removeInstructions(2).also { assertRegisterIs(3, 0) }
-    }
-
-    @Test
-    fun replaceInstructionsInImplementationIndexed() = applyToImplementation {
-        replaceInstructions(5, getTestInstructions(0..1)).also {
-            assertRegisterIs(0, 5)
-            assertRegisterIs(1, 6)
-            assertRegisterIs(7, 7)
+    fun removeInstructionsFromImplementationIndexed() =
+        applyToImplementation {
+            removeInstructions(5, 5).also { assertRegisterIs(4, 4) }
        }
-    }

    @Test
-    fun addInstructionToMethodIndexed() = applyToMethod {
-        addInstruction(5, TestInstruction(0)).also { assertRegisterIs(0, 5) }
-    }
-
-    @Test
-    fun addInstructionToMethod() = applyToMethod {
-        addInstruction(TestInstruction(0)).also { assertRegisterIs(0, 10) }
-    }
-
-    @Test
-    fun addSmaliInstructionToMethodIndexed() = applyToMethod {
-        addInstruction(5, getTestSmaliInstruction(0)).also { assertRegisterIs(0, 5) }
-    }
-
-    @Test
-    fun addSmaliInstructionToMethod() = applyToMethod {
-        addInstruction(getTestSmaliInstruction(0)).also { assertRegisterIs(0, 10) }
-    }
-
-    @Test
-    fun addInstructionsToMethodIndexed() = applyToMethod {
-        addInstructions(5, getTestInstructions(0..1)).also {
-            assertRegisterIs(0, 5)
-            assertRegisterIs(1, 6)
-
-            assertRegisterIs(5, 7)
+    fun removeInstructionsFromImplementation() =
+        applyToImplementation {
+            removeInstructions(0).also { assertRegisterIs(9, 9) }
+            removeInstructions(1).also { assertRegisterIs(1, 0) }
+            removeInstructions(2).also { assertRegisterIs(3, 0) }
        }
-    }

    @Test
-    fun addInstructionsToMethod() = applyToMethod {
-        addInstructions(getTestInstructions(0..1)).also {
-            assertRegisterIs(0, 10)
-            assertRegisterIs(1, 11)
-
-            assertRegisterIs(9, 9)
+    fun replaceInstructionsInImplementationIndexed() =
+        applyToImplementation {
+            replaceInstructions(5, getTestInstructions(0..1)).also {
+                assertRegisterIs(0, 5)
+                assertRegisterIs(1, 6)
+                assertRegisterIs(7, 7)
+            }
        }
-    }

    @Test
-    fun addSmaliInstructionsToMethodIndexed() = applyToMethod {
-        addInstructionsWithLabels(5, getTestSmaliInstructions(0..1)).also {
-            assertRegisterIs(0, 5)
-            assertRegisterIs(1, 6)
-
-            assertRegisterIs(5, 7)
+    fun addInstructionToMethodIndexed() =
+        applyToMethod {
+            addInstruction(5, TestInstruction(0)).also { assertRegisterIs(0, 5) }
        }
-    }

    @Test
-    fun addSmaliInstructionsToMethod() = applyToMethod {
-        addInstructions(getTestSmaliInstructions(0..1)).also {
-            assertRegisterIs(0, 10)
-            assertRegisterIs(1, 11)
-
-            assertRegisterIs(9, 9)
+    fun addInstructionToMethod() =
+        applyToMethod {
+            addInstruction(TestInstruction(0)).also { assertRegisterIs(0, 10) }
        }
-    }

    @Test
-    fun addSmaliInstructionsWithExternalLabelToMethodIndexed() = applyToMethod {
-        val label = ExternalLabel("testLabel", getInstruction(5))
-
-        addInstructionsWithLabels(
-            5,
-            getTestSmaliInstructions(0..1).plus("\n").plus("goto :${label.name}"),
-            label
-        ).also {
-            assertRegisterIs(0, 5)
-            assertRegisterIs(1, 6)
-            assertRegisterIs(5, 8)
-
-            val gotoTarget = getInstruction<BuilderOffsetInstruction>(7)
-                .target.location.instruction as OneRegisterInstruction
-
-            assertEquals(5, gotoTarget.registerA)
+    fun addSmaliInstructionToMethodIndexed() =
+        applyToMethod {
+            addInstruction(5, getTestSmaliInstruction(0)).also { assertRegisterIs(0, 5) }
        }
-    }

    @Test
-    fun removeInstructionFromMethodIndexed() = applyToMethod {
-        removeInstruction(5).also {
-            assertRegisterIs(4, 4)
-            assertRegisterIs(6, 5)
+    fun addSmaliInstructionToMethod() =
+        applyToMethod {
+            addInstruction(getTestSmaliInstruction(0)).also { assertRegisterIs(0, 10) }
        }
-    }

    @Test
-    fun removeInstructionsFromMethodIndexed() = applyToMethod {
-        removeInstructions(5, 5).also { assertRegisterIs(4, 4) }
-    }
+    fun addInstructionsToMethodIndexed() =
+        applyToMethod {
+            addInstructions(5, getTestInstructions(0..1)).also {
+                assertRegisterIs(0, 5)
+                assertRegisterIs(1, 6)

-    @Test
-    fun removeInstructionsFromMethod() = applyToMethod {
-        removeInstructions(0).also { assertRegisterIs(9, 9) }
-        removeInstructions(1).also { assertRegisterIs(1, 0) }
-        removeInstructions(2).also { assertRegisterIs(3, 0) }
-    }
-
-    @Test
-    fun replaceInstructionInMethodIndexed() = applyToMethod {
-        replaceInstruction(5, TestInstruction(0)).also { assertRegisterIs(0, 5) }
-    }
-
-    @Test
-    fun replaceInstructionsInMethodIndexed() = applyToMethod {
-        replaceInstructions(5, getTestInstructions(0..1)).also {
-            assertRegisterIs(0, 5)
-            assertRegisterIs(1, 6)
-            assertRegisterIs(7, 7)
+                assertRegisterIs(5, 7)
+            }
        }
-    }

    @Test
-    fun replaceSmaliInstructionsInMethodIndexed() = applyToMethod {
-        replaceInstructions(5, getTestSmaliInstructions(0..1)).also {
-            assertRegisterIs(0, 5)
-            assertRegisterIs(1, 6)
-            assertRegisterIs(7, 7)
+    fun addInstructionsToMethod() =
+        applyToMethod {
+            addInstructions(getTestInstructions(0..1)).also {
+                assertRegisterIs(0, 10)
+                assertRegisterIs(1, 11)
+
+                assertRegisterIs(9, 9)
+            }
+        }
+
+    @Test
+    fun addSmaliInstructionsToMethodIndexed() =
+        applyToMethod {
+            addInstructionsWithLabels(5, getTestSmaliInstructions(0..1)).also {
+                assertRegisterIs(0, 5)
+                assertRegisterIs(1, 6)
+
+                assertRegisterIs(5, 7)
+            }
+        }
+
+    @Test
+    fun addSmaliInstructionsToMethod() =
+        applyToMethod {
+            addInstructions(getTestSmaliInstructions(0..1)).also {
+                assertRegisterIs(0, 10)
+                assertRegisterIs(1, 11)
+
+                assertRegisterIs(9, 9)
+            }
+        }
+
+    @Test
+    fun addSmaliInstructionsWithExternalLabelToMethodIndexed() =
+        applyToMethod {
+            val label = ExternalLabel("testLabel", getInstruction(5))
+
+            addInstructionsWithLabels(
+                5,
+                getTestSmaliInstructions(0..1).plus("\n").plus("goto :${label.name}"),
+                label,
+            ).also {
+                assertRegisterIs(0, 5)
+                assertRegisterIs(1, 6)
+                assertRegisterIs(5, 8)
+
+                val gotoTarget =
+                    getInstruction<BuilderOffsetInstruction>(7)
+                        .target.location.instruction as OneRegisterInstruction
+
+                assertEquals(5, gotoTarget.registerA)
+            }
+        }
+
+    @Test
+    fun removeInstructionFromMethodIndexed() =
+        applyToMethod {
+            removeInstruction(5).also {
+                assertRegisterIs(4, 4)
+                assertRegisterIs(6, 5)
+            }
+        }
+
+    @Test
+    fun removeInstructionsFromMethodIndexed() =
+        applyToMethod {
+            removeInstructions(5, 5).also { assertRegisterIs(4, 4) }
+        }
+
+    @Test
+    fun removeInstructionsFromMethod() =
+        applyToMethod {
+            removeInstructions(0).also { assertRegisterIs(9, 9) }
+            removeInstructions(1).also { assertRegisterIs(1, 0) }
+            removeInstructions(2).also { assertRegisterIs(3, 0) }
+        }
+
+    @Test
+    fun replaceInstructionInMethodIndexed() =
+        applyToMethod {
+            replaceInstruction(5, TestInstruction(0)).also { assertRegisterIs(0, 5) }
+        }
+
+    @Test
+    fun replaceInstructionsInMethodIndexed() =
+        applyToMethod {
+            replaceInstructions(5, getTestInstructions(0..1)).also {
+                assertRegisterIs(0, 5)
+                assertRegisterIs(1, 6)
+                assertRegisterIs(7, 7)
+            }
+        }
+
+    @Test
+    fun replaceSmaliInstructionsInMethodIndexed() =
+        applyToMethod {
+            replaceInstructions(5, getTestSmaliInstructions(0..1)).also {
+                assertRegisterIs(0, 5)
+                assertRegisterIs(1, 6)
+                assertRegisterIs(7, 7)
+            }
        }
-    }

    // region Helper methods

@@ -212,22 +234,29 @@ private object InstructionExtensionsTest {
        testMethod.apply(block)
    }

-    private fun MutableMethodImplementation.assertRegisterIs(register: Int, atIndex: Int) = assertEquals(
-        register, getInstruction<OneRegisterInstruction>(atIndex).registerA
+    private fun MutableMethodImplementation.assertRegisterIs(
+        register: Int,
+        atIndex: Int,
+    ) = assertEquals(
+        register,
+        getInstruction<OneRegisterInstruction>(atIndex).registerA,
    )

-    private fun MutableMethod.assertRegisterIs(register: Int, atIndex: Int) =
-        implementation!!.assertRegisterIs(register, atIndex)
+    private fun MutableMethod.assertRegisterIs(
+        register: Int,
+        atIndex: Int,
+    ) = implementation!!.assertRegisterIs(register, atIndex)

    private fun getTestInstructions(range: IntRange) = range.map { TestInstruction(it) }

    private fun getTestSmaliInstruction(register: Int) = "const/16 v$register, 0"

-    private fun getTestSmaliInstructions(range: IntRange) = range.joinToString("\n") {
-        getTestSmaliInstruction(it)
-    }
+    private fun getTestSmaliInstructions(range: IntRange) =
+        range.joinToString("\n") {
+            getTestSmaliInstruction(it)
+        }

    // endregion

    private class TestInstruction(register: Int) : BuilderInstruction21s(Opcode.CONST_16, register, 0)
-}
+}
--- a/src/test/kotlin/app/revanced/patcher/patch/PatchInitializationTest.kt
+++ b/src/test/kotlin/app/revanced/patcher/patch/PatchInitializationTest.kt
@@ -0,0 +1,29 @@
+package app.revanced.patcher.patch
+
+import app.revanced.patcher.data.ResourceContext
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.Test
+import app.revanced.patcher.patch.annotation.Patch as PatchAnnotation
+
+object PatchInitializationTest {
+    @Test
+    fun `initialize using constructor`() {
+        val patch =
+            object : ResourcePatch(name = "Resource patch test") {
+                override fun execute(context: ResourceContext) {}
+            }
+
+        assert(patch.name == "Resource patch test")
+    }
+
+    @Test
+    fun `initialize using annotation`() {
+        val patch =
+            @PatchAnnotation("Resource patch test")
+            object : ResourcePatch() {
+                override fun execute(context: ResourceContext) {}
+            }
+
+        assert(patch.name == "Resource patch test")
+    }
+}
--- a/src/test/kotlin/app/revanced/patcher/patch/options/PatchOptionsTest.kt
+++ b/src/test/kotlin/app/revanced/patcher/patch/options/PatchOptionsTest.kt
@@ -62,13 +62,12 @@ internal class PatchOptionsTest {
    @Test
    fun `should allow setting value from values`() =
        with(OptionsTestPatch.options["choices"] as PatchOption<String>) {
-            value = values.last()
+            value = values!!.values.last()
            assertTrue(value == "valid")
        }

    @Test
-    fun `should allow setting custom value`() =
-        assertDoesNotThrow { OptionsTestPatch.stringOptionWithChoices = "unknown" }
+    fun `should allow setting custom value`() = assertDoesNotThrow { OptionsTestPatch.stringOptionWithChoices = "unknown" }

    @Test
    fun `should allow resetting value`() = assertDoesNotThrow { OptionsTestPatch.stringOptionWithChoices = null }
@@ -86,17 +85,43 @@ internal class PatchOptionsTest {
    }

    @Test
-    fun `getting default value should work`() =
-        assertDoesNotThrow { assertNull(OptionsTestPatch.resettableOption.default) }
+    fun `option types should be known`() = assertTrue(OptionsTestPatch.options["array"].valueType == "StringArray")

+    @Test
+    fun `getting default value should work`() = assertDoesNotThrow { assertNull(OptionsTestPatch.resettableOption.default) }
+
+    @Suppress("DEPRECATION")
    private object OptionsTestPatch : BytecodePatch() {
-        var booleanOption by booleanPatchOption("bool", true)
-        var requiredStringOption by stringPatchOption("required", "default", required = true)
-        var stringArrayOption = stringArrayPatchOption("array", arrayOf("1", "2"))
-        var stringOptionWithChoices by stringPatchOption("choices", "value", values = setOf("valid"))
-        var validatedOption by stringPatchOption("validated", "default") { it == "valid" }
-        var resettableOption = stringPatchOption("resettable", null, required = true)
+        var booleanOption by booleanPatchOption(
+            "bool",
+            true,
+        )
+        var requiredStringOption by stringPatchOption(
+            "required",
+            "default",
+            required = true,
+        )
+        var stringArrayOption =
+            stringArrayPatchOption(
+                "array",
+                arrayOf("1", "2"),
+            )
+        var stringOptionWithChoices by stringPatchOption(
+            "choices",
+            "value",
+            values = mapOf("Valid option value" to "valid"),
+        )
+        var validatedOption by stringPatchOption(
+            "validated",
+            "default",
+        ) { it == "valid" }
+        var resettableOption =
+            stringPatchOption(
+                "resettable",
+                null,
+                required = true,
+            )

        override fun execute(context: BytecodeContext) {}
    }
-}
+}
--- a/src/test/kotlin/app/revanced/patcher/patch/usage/ExampleBytecodePatch.kt
+++ b/src/test/kotlin/app/revanced/patcher/patch/usage/ExampleBytecodePatch.kt
@@ -32,7 +32,7 @@ import com.google.common.collect.ImmutableList
    name = "Example bytecode patch",
    description = "Example demonstration of a bytecode patch.",
    dependencies = [ExampleResourcePatch::class],
-    compatiblePackages = [CompatiblePackage("com.example.examplePackage", arrayOf("0.0.1", "0.0.2"))]
+    compatiblePackages = [CompatiblePackage("com.example.examplePackage", arrayOf("0.0.1", "0.0.2"))],
 )
 object ExampleBytecodePatch : BytecodePatch(setOf(ExampleFingerprint)) {
    // Entry point of a patch. Supplied fingerprints are resolved at this point.
@@ -60,7 +60,7 @@ object ExampleBytecodePatch : BytecodePatch(setOf(ExampleFingerprint)) {
                        invoke-static { }, LTestClass;->returnHello()Ljava/lang/String;
                        move-result-object v1
                        invoke-virtual { v0, v1 }, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
-                    """
+                    """,
                )
            }

@@ -82,14 +82,14 @@ object ExampleBytecodePatch : BytecodePatch(setOf(ExampleFingerprint)) {
                                BuilderInstruction21c(
                                    Opcode.CONST_STRING,
                                    0,
-                                    ImmutableStringReference("Hello, ReVanced! Adding bytecode.")
+                                    ImmutableStringReference("Hello, ReVanced! Adding bytecode."),
                                ),
-                                BuilderInstruction11x(Opcode.RETURN_OBJECT, 0)
+                                BuilderInstruction11x(Opcode.RETURN_OBJECT, 0),
                            ),
                            null,
-                            null
-                        )
-                    ).toMutable()
+                            null,
+                        ),
+                    ).toMutable(),
                )

                // Add a field in the main class.
@@ -105,12 +105,12 @@ object ExampleBytecodePatch : BytecodePatch(setOf(ExampleFingerprint)) {
                            ImmutableFieldReference(
                                "Ljava/lang/System;",
                                "out",
-                                "Ljava/io/PrintStream;"
-                            )
+                                "Ljava/io/PrintStream;",
+                            ),
                        ),
                        null,
-                        null
-                    ).toMutable()
+                        null,
+                    ).toMutable(),
                )
            }
        } ?: throw PatchException("Fingerprint failed to resolve.")
@@ -121,7 +121,10 @@ object ExampleBytecodePatch : BytecodePatch(setOf(ExampleFingerprint)) {
     * @param index The index of the instruction to replace.
     * @param string The replacement string.
     */
-    private fun MutableMethod.replaceStringAt(index: Int, string: String) {
+    private fun MutableMethod.replaceStringAt(
+        index: Int,
+        string: String,
+    ) {
        val instruction = getInstruction(index)

        // Utility method of dexlib2.
@@ -139,8 +142,7 @@ object ExampleBytecodePatch : BytecodePatch(setOf(ExampleFingerprint)) {
        // At last, use the method replaceInstruction to replace it at the given index startIndex.
        replaceInstruction(
            index,
-            "const-string ${strInstruction.registerA}, ${ImmutableStringReference(string)}"
+            "const-string ${strInstruction.registerA}, ${ImmutableStringReference(string)}",
        )
    }
 }
-
--- a/src/test/kotlin/app/revanced/patcher/patch/usage/ExampleFingerprint.kt
+++ b/src/test/kotlin/app/revanced/patcher/patch/usage/ExampleFingerprint.kt
@@ -1,7 +1,7 @@
 package app.revanced.patcher.patch.usage
 import app.revanced.patcher.extensions.or
-import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.fingerprint.MethodFingerprint
+import app.revanced.patcher.fingerprint.annotation.FuzzyPatternScanMethod
 import com.android.tools.smali.dexlib2.AccessFlags
 import com.android.tools.smali.dexlib2.Opcode

@@ -12,9 +12,9 @@ object ExampleFingerprint : MethodFingerprint(
    listOf("[L"),
    listOf(
        Opcode.SGET_OBJECT,
-        null,                 // Matching unknown opcodes.
+        null, // Matching unknown opcodes.
        Opcode.INVOKE_STATIC, // This is intentionally wrong to test fuzzy matching.
-        Opcode.RETURN_VOID
+        Opcode.RETURN_VOID,
    ),
-    null
-)
+    null,
+)
--- a/src/test/kotlin/app/revanced/patcher/patch/usage/ExampleResourcePatch.kt
+++ b/src/test/kotlin/app/revanced/patcher/patch/usage/ExampleResourcePatch.kt
@@ -4,19 +4,19 @@ import app.revanced.patcher.data.ResourceContext
 import app.revanced.patcher.patch.ResourcePatch
 import org.w3c.dom.Element

-
 class ExampleResourcePatch : ResourcePatch() {
    override fun execute(context: ResourceContext) {
        context.xmlEditor["AndroidManifest.xml"].use { editor ->
-            val element = editor // regular DomFileEditor
-                .file
-                .getElementsByTagName("application")
-                .item(0) as Element
+            val element =
+                editor // regular DomFileEditor
+                    .file
+                    .getElementsByTagName("application")
+                    .item(0) as Element
            element
                .setAttribute(
                    "exampleAttribute",
-                    "exampleValue"
+                    "exampleValue",
                )
        }
    }
-}
+}
--- a/src/test/kotlin/app/revanced/patcher/util/smali/InlineSmaliCompilerTest.kt
+++ b/src/test/kotlin/app/revanced/patcher/util/smali/InlineSmaliCompilerTest.kt
@@ -33,16 +33,18 @@ internal class InlineSmaliCompilerTest {
        val insnIndex = insnAmount - 2
        val targetIndex = insnIndex - 1

-        method.addInstructions(arrayOfNulls<String>(insnAmount).also {
-            Arrays.fill(it, "const/4 v0, 0x0")
-        }.joinToString("\n"))
+        method.addInstructions(
+            arrayOfNulls<String>(insnAmount).also {
+                Arrays.fill(it, "const/4 v0, 0x0")
+            }.joinToString("\n"),
+        )
        method.addInstructionsWithLabels(
            targetIndex,
            """
                :test
                const/4 v0, 0x1
                if-eqz v0, :test
-            """
+            """,
        )

        val insn = method.getInstruction<BuilderInstruction21t>(insnIndex)
@@ -59,7 +61,7 @@ internal class InlineSmaliCompilerTest {
            """
                const/4 v0, 0x1
                const/4 v0, 0x0
-            """
+            """,
        )

        assertEquals(labelIndex, method.newLabel(labelIndex).location.index)
@@ -71,7 +73,7 @@ internal class InlineSmaliCompilerTest {
                if-eqz v0, :test
                return-void
            """,
-            ExternalLabel("test", method.getInstruction(1))
+            ExternalLabel("test", method.getInstruction(1)),
        )

        val insn = method.getInstruction<BuilderInstruction21t>(insnIndex)
@@ -93,13 +95,16 @@ internal class InlineSmaliCompilerTest {
            accessFlags,
            emptySet(),
            emptySet(),
-            MutableMethodImplementation(registerCount)
+            MutableMethodImplementation(registerCount),
        ).toMutable()

-        private fun instructionEquals(want: BuilderInstruction, have: BuilderInstruction) {
+        private fun instructionEquals(
+            want: BuilderInstruction,
+            have: BuilderInstruction,
+        ) {
            assertEquals(want.opcode, have.opcode)
            assertEquals(want.format, have.format)
            assertEquals(want.codeUnits, have.codeUnits)
        }
    }
-}
+}
Author	SHA1	Message	Date
semantic-release-bot	d03591b735	chore(release): 19.2.0-dev.1 [skip ci] # [19.2.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v19.1.1-dev.1...v19.2.0-dev.1) (2023-12-22) ### Features * Add `PatchExtensions#registerNewPatchOption` function to simplify instantiation and registration of patch options ([`4a91845`](`4a9184597b`))	2023-12-22 02:23:04 +00:00
oSumAtrIX	4a9184597b	feat: Add `PatchExtensions#registerNewPatchOption` function to simplify instantiation and registration of patch options	2023-12-22 03:20:50 +01:00
oSumAtrIX	0a482f8c9a	refactor: Reduce duplicate code by using a common function to register options	2023-12-22 03:09:42 +01:00
oSumAtrIX	e7dacfba8c	build: Simplify enabling local build cache	2023-12-10 21:57:10 +01:00
semantic-release-bot	2d7fffd4ec	chore(release): 19.1.1-dev.1 [skip ci] ## [19.1.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v19.1.0...v19.1.1-dev.1) (2023-12-01) ### Bug Fixes * Accept `PatchSet` in `PatchesConsumer#acceptPatches` ([`716825f`](`716825f232`))	2023-12-01 22:15:43 +00:00
oSumAtrIX	f8baabbcec	build: Bump dependencies	2023-12-01 23:13:49 +01:00
oSumAtrIX	716825f232	fix: Accept `PatchSet` in `PatchesConsumer#acceptPatches` This deprecates accepting `List<Patch<*>>`	2023-12-01 23:10:23 +01:00
semantic-release-bot	58bd46750b	chore(release): 19.1.0 [skip ci] # [19.1.0](https://github.com/ReVanced/revanced-patcher/compare/v19.0.0...v19.1.0) (2023-12-01) ### Features * Add constructor to initialize patches without annotations ([`462fbe2`](`462fbe2cad`)) * Retrieve annotations in super and interface classes ([`7aeae93`](`7aeae93f3d`)) ### Performance Improvements * Use a hash set for fast lookup ([`f1de9b3`](`f1de9b39ef`))	2023-12-01 00:19:54 +00:00
oSumAtrIX	288240f163	chore: Merge branch `dev` to `main` (#260 )	2023-12-01 01:17:47 +01:00
semantic-release-bot	ff02452cb8	chore(release): 19.1.0-dev.1 [skip ci] # [19.1.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v19.0.0...v19.1.0-dev.1) (2023-11-29) ### Features * Add constructor to initialize patches without annotations ([`462fbe2`](`462fbe2cad`)) * Retrieve annotations in super and interface classes ([`7aeae93`](`7aeae93f3d`)) ### Performance Improvements * Use a hash set for fast lookup ([`f1de9b3`](`f1de9b39ef`))	2023-11-29 19:28:24 +00:00
oSumAtrIX	462fbe2cad	feat: Add constructor to initialize patches without annotations	2023-11-29 20:26:20 +01:00
oSumAtrIX	7aeae93f3d	feat: Retrieve annotations in super and interface classes	2023-11-29 01:14:46 +01:00
oSumAtrIX	f1de9b39ef	perf: Use a hash set for fast lookup	2023-11-28 20:17:46 +01:00
oSumAtrIX	db5b0ed7be	refactor: Convert extension property to member	2023-11-28 20:17:02 +01:00
oSumAtrIX	9f28a01c03	refactor: Group related extension functions together	2023-11-28 19:59:18 +01:00
oSumAtrIX	80407b6102	chore: Lint code	2023-11-26 05:57:41 +01:00
oSumAtrIX	287841d806	chore: Add heading to issue templates	2023-11-23 00:56:53 +01:00
oSumAtrIX	10c3be1195	build: Bump Gradle wrapper	2023-11-22 01:04:49 +01:00
oSumAtrIX	0c0e22013b	build: Use dedicated Gradle cache action	2023-11-22 01:04:49 +01:00
oSumAtrIX	f35c8d4446	build: Use Gradle build cache	2023-11-22 01:04:48 +01:00
oSumAtrIX	17418d4b9c	ci: Simplify cache paths	2023-11-22 01:04:48 +01:00
oSumAtrIX	ec1fbdf2ae	chore: Reword comment for first PR merge	2023-11-22 01:04:48 +01:00
oSumAtrIX	56e5a46fd5	chore: Add a newline between steps	2023-11-22 01:04:48 +01:00
oSumAtrIX	32e86d44a3	chore: Simplify issue templates	2023-11-22 01:04:47 +01:00
oSumAtrIX	7100606dfc	build: Bump dependencies	2023-11-22 01:04:47 +01:00
oSumAtrIX	d7eb111460	ci: Update cache key	2023-11-22 01:04:47 +01:00
oSumAtrIX	27ea46653e	chore: Update packages	2023-11-22 01:04:46 +01:00
oSumAtrIX	12c43072cb	refactor: Include class of method in call expression	2023-11-03 23:31:15 +01:00
semantic-release-bot	671aa6d507	chore(release): 19.0.0 [skip ci] # [19.0.0](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0...v19.0.0) (2023-10-24) ### Features * Add `PatchOption#valueType` to handle type erasure ([`a46e948`](`a46e948b5a`)) ### BREAKING CHANGES * This changes the signature of the `PatchOption` constructor.	2023-10-24 20:39:50 +00:00
oSumAtrIX	b697bbad2b	chore: Merge branch `dev` to `main` (#258 )	2023-10-24 22:37:05 +02:00
semantic-release-bot	f05a404e48	chore(release): 19.0.0-dev.1 [skip ci] # [19.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0...v19.0.0-dev.1) (2023-10-24) ### Features * Add `PatchOption#valueType` to handle type erasure ([`a46e948`](`a46e948b5a`)) ### BREAKING CHANGES * This changes the signature of the `PatchOption` constructor.	2023-10-24 20:35:38 +00:00
oSumAtrIX	a46e948b5a	feat: Add `PatchOption#valueType` to handle type erasure Without this new property, it is not possible to infer the type without abusing `ClassCastException` at runtime to infer the type of the option value. BREAKING CHANGE: This changes the signature of the `PatchOption` constructor.	2023-10-24 22:33:10 +02:00
semantic-release-bot	dc09ea639f	chore(release): 18.0.0 [skip ci] # [18.0.0](https://github.com/ReVanced/revanced-patcher/compare/v17.0.0...v18.0.0) (2023-10-22) ### Bug Fixes * Do not set patch fields if they are empty ([`a76ac04`](`a76ac04214`)) * Only allow setting `MethodFingerprint#result` privately ([`aed1eac`](`aed1eac315`)) ### Code Refactoring * Change `PatchOption` from abstract to open class ([`09cd6aa`](`09cd6aa568`)) * Change data classes to actual classes ([`6192089`](`6192089b71`)) * Convert extension functions to member functions ([`e2ca507`](`e2ca50729d`)) * Move files to simplify package structure ([`124a2e9`](`124a2e9d3e`)) * Remove deprecated classes and members ([`a4212f6`](`a4212f6bf9`)) * refactor!: Remove `Fingerprint` interface ([`54a2f8f`](`54a2f8f16f`)) ### Features * Add function to reset options to their default value ([`ebbaafb`](`ebbaafb78e`)) * Add function to reset options to their default value ([`e6de90d`](`e6de90d300`)) * Add getter for default option value ([`c7922e9`](`c7922e90d0`)) * Make `PatchOption#values` nullable ([`56ce9ec`](`56ce9ec2f9`)) * Name patch option value validator property correctly ([`caa634f`](`caa634fac6`)) * Remove patch annotation processor ([`4456031`](`4456031459`)) * Use a map for `PatchOption#values` ([`54ac139`](`54ac1394a9`)) ### Performance Improvements * Run the garbage collector after writing dex files ([`d9fb241`](`d9fb241d57`)) ### BREAKING CHANGES * The `MethodFingerprint#result` member can now only be set inside `MethodFingerprint`. * The `Fingerprint` interface is no longer present. * Some extension functions are now member functions. * This gets rid of data class members. * Some deprecated classes and members are not present anymore. * Classes and members have changed packages. * This gets rid of the existing basic implementations of the `PatchOptions` type and moves extension functions. * This changes the getter name of the property. * Various patch constructor signatures have changed.	2023-10-22 23:59:31 +00:00
oSumAtrIX	49ed096e85	chore: Merge branch `dev` to `main` (#257 )	2023-10-23 01:56:40 +02:00
semantic-release-bot	167bd83f4e	chore(release): 18.0.0-dev.6 [skip ci] # [18.0.0-dev.6](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.5...v18.0.0-dev.6) (2023-10-22) ### Bug Fixes * Only allow setting `MethodFingerprint#result` privately ([`aed1eac`](`aed1eac315`)) ### Code Refactoring * Change data classes to actual classes ([`6192089`](`6192089b71`)) * Convert extension functions to member functions ([`e2ca507`](`e2ca50729d`)) * Move files to simplify package structure ([`124a2e9`](`124a2e9d3e`)) * Remove deprecated classes and members ([`a4212f6`](`a4212f6bf9`)) * refactor!: Remove `Fingerprint` interface ([`54a2f8f`](`54a2f8f16f`)) ### BREAKING CHANGES * The `MethodFingerprint#result` member can now only be set inside `MethodFingerprint`. * The `Fingerprint` interface is no longer present. * Some extension functions are now member functions. * This gets rid of data class members. * Some deprecated classes and members are not present anymore. * Classes and members have changed packages.	2023-10-22 23:54:59 +00:00
oSumAtrIX	aed1eac315	fix: Only allow setting `MethodFingerprint#result` privately BREAKING CHANGE: The `MethodFingerprint#result` member can now only be set inside `MethodFingerprint`.	2023-10-23 01:52:43 +02:00
oSumAtrIX	54a2f8f16f	refactor!: Remove `Fingerprint` interface It served no purpose so far. BREAKING CHANGE: The `Fingerprint` interface is no longer present.	2023-10-23 01:52:04 +02:00
oSumAtrIX	2ca543ffb9	refactor: Move lookup related classes and members to own file	2023-10-23 01:51:48 +02:00
oSumAtrIX	58e7f815a5	refactor: Move `MethodFingerprintResult` to own file	2023-10-23 01:51:34 +02:00
oSumAtrIX	15b38fc841	refactor: Simplify method implementation	2023-10-23 01:50:54 +02:00
oSumAtrIX	e2ca50729d	refactor: Convert extension functions to member functions BREAKING CHANGE: Some extension functions are now member functions.	2023-10-23 01:50:53 +02:00
oSumAtrIX	6192089b71	refactor: Change data classes to actual classes The data class members did not serve any actual purpose. BREAKING CHANGE: This gets rid of data class members.	2023-10-23 01:49:57 +02:00
oSumAtrIX	a4212f6bf9	refactor: Remove deprecated classes and members BREAKING CHANGE: Some deprecated classes and members are not present anymore.	2023-10-23 01:49:23 +02:00
oSumAtrIX	124a2e9d3e	refactor: Move files to simplify package structure BREAKING CHANGE: Classes and members have changed packages.	2023-10-23 01:48:52 +02:00
semantic-release-bot	f77624b3b9	chore(release): 18.0.0-dev.5 [skip ci] # [18.0.0-dev.5](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.4...v18.0.0-dev.5) (2023-10-22) ### Bug Fixes * Do not set patch fields if they are empty ([`a76ac04`](`a76ac04214`))	2023-10-22 16:10:54 +00:00
oSumAtrIX	a76ac04214	fix: Do not set patch fields if they are empty	2023-10-22 18:08:28 +02:00
semantic-release-bot	0447fa9c28	chore(release): 18.0.0-dev.4 [skip ci] # [18.0.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.3...v18.0.0-dev.4) (2023-10-22) ### Features * Use a map for `PatchOption#values` ([`54ac139`](`54ac1394a9`))	2023-10-22 15:39:57 +00:00
oSumAtrIX	54ac1394a9	feat: Use a map for `PatchOption#values` This allows to display a string representation associated to the option value.	2023-10-22 17:07:22 +02:00
oSumAtrIX	0b04c73ac5	build: Bump Kotlin Gradle plugin version	2023-10-22 16:14:46 +02:00
semantic-release-bot	079de45238	chore(release): 18.0.0-dev.3 [skip ci] # [18.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.2...v18.0.0-dev.3) (2023-10-22) ### Features * Make `PatchOption#values` nullable ([`56ce9ec`](`56ce9ec2f9`))	2023-10-22 14:09:28 +00:00
oSumAtrIX	56ce9ec2f9	feat: Make `PatchOption#values` nullable There is no difference semantically, but this change allows passing null as a parameter which is simpler than having to use `emptySet()`.	2023-10-22 16:07:01 +02:00
				`@@ -0,0 +1 @@`
				<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg width="100%" height="100%" viewBox="0 0 800 800" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;"><g id="Logo"><g id="Ring"><circle id="Ring-Background" serif:id="Ring Background" cx="400" cy="400" r="400" style="fill:#1b1b1b;"/><path id="Ring1" serif:id="Ring" d="M400,0c220.766,0 400,179.234 400,400c-0,220.766 -179.234,400 -400,400c-220.766,-0 -400,-179.234 -400,-400c0,-220.766 179.234,-400 400,-400Zm-0,36c200.897,-0 364,163.103 364,364c0,200.897 -163.103,364 -364,364c-200.897,0 -364,-163.103 -364,-364c-0,-200.897 163.103,-364 364,-364Z" style="fill:url(#_Linear1);"/></g><g id="Shape"><path id="V-Shape" serif:id="V Shape" d="M538.74,269.872c1.481,-3.382 1.157,-7.283 -0.863,-10.373c-2.021,-3.091 -5.464,-4.954 -9.156,-4.954c-5.148,0 -10.435,0 -14.165,0c-3.1,0 -5.907,1.834 -7.153,4.672c-12.468,28.396 -78.273,178.273 -100.25,228.328c-1.246,2.838 -4.053,4.671 -7.154,4.671c-3.1,0 -5.907,-1.833 -7.153,-4.671c-21.977,-50.055 -87.782,-199.932 -100.25,-228.328c-1.246,-2.838 -4.053,-4.672 -7.153,-4.672c-3.73,0 -9.017,0 -14.164,0c-3.693,0 -7.135,1.863 -9.156,4.954c-2.02,3.09 -2.344,6.991 -0.863,10.373c23.557,53.766 101.872,232.519 117.871,269.034c1.743,3.979 5.674,6.549 10.018,6.549c6.293,-0 15.408,-0 21.701,-0c4.344,-0 8.275,-2.57 10.018,-6.549c15.999,-36.515 94.315,-215.268 117.872,-269.034Z" style="fill:#fff;"/><path id="Diamond" d="M408.119,395.312c-1.675,2.901 -4.77,4.688 -8.119,4.688c-3.349,-0 -6.444,-1.787 -8.119,-4.688c-16.997,-29.44 -56.156,-97.264 -73.153,-126.704c-1.675,-2.901 -1.675,-6.474 0,-9.375c1.675,-2.901 4.77,-4.688 8.119,-4.688c33.995,0 112.311,0 146.306,0c3.349,0 6.444,1.787 8.119,4.688c1.675,2.901 1.675,6.474 -0,9.375c-16.997,29.44 -56.156,97.264 -73.153,126.704Z" style="fill:url(#_Linear2);"/></g></g><defs><linearGradient id="_Linear1" x1="0" y1="0" x2="1" y2="0" gradientUnits="userSpaceOnUse" gradientTransform="matrix(4.89859e-14,800,-800,4.89859e-14,400.001,3.31681e-10)"><stop offset="0" style="stop-color:#f04e98;stop-opacity:1"/><stop offset="0.5" style="stop-color:#5f65d4;stop-opacity:1"/><stop offset="1" style="stop-color:#4e98f0;stop-opacity:1"/></linearGradient><linearGradient id="_Linear2" x1="0" y1="0" x2="1" y2="0" gradientUnits="userSpaceOnUse" gradientTransform="matrix(1.77155e-14,289.317,-282.535,1.73003e-14,400,254.545)"><stop offset="0" style="stop-color:#f04e98;stop-opacity:1"/><stop offset="0.5" style="stop-color:#5f65d4;stop-opacity:1"/><stop offset="1" style="stop-color:#4e98f0;stop-opacity:1"/></linearGradient></defs></svg>