fix nullability

use context params for apis
contextualize delegate variants and composite api
2026-01-17 08:23:58 +00:00 · 2026-01-11 03:09:49 +01:00 · 2026-01-09 19:06:50 +01:00 · 2026-01-09 18:53:35 +01:00 · 2026-01-09 16:02:46 +01:00 · 2026-01-08 00:51:56 +01:00
143 changed files with 13208 additions and 7605 deletions
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,3 +0,0 @@
-[*.{kt,kts}]
-ktlint_code_style = intellij_idea
-ktlint_standard_no-wildcard-imports = disabled
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -11,18 +11,18 @@ body:
            <source
              width="256px"
              media="(prefers-color-scheme: dark)"
-              srcset="../../assets/revanced-headline/revanced-headline-vertical-dark.svg"
+              srcset="https://raw.githubusercontent.com/revanced/revanced-patcher/main/assets/revanced-headline/revanced-headline-vertical-dark.svg"
            >
            <img 
              width="256px"
-              src="../../assets/revanced-headline/revanced-headline-vertical-light.svg"
+              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="../../assets/revanced-logo/revanced-logo.svg" />
-                 <img height="24px" src="../../assets/revanced-logo/revanced-logo.svg" />
+                 <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">
@@ -70,7 +70,8 @@ body:

        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 submit a duplicate bug report**: Search for existing bug reports [here](https://github.com/ReVanced/revanced-patcher/issues?q=label%3A%22Bug+report%22).
+        - **Review the contribution guidelines**: Make sure your bug report adheres to it. You can find the guidelines [here](https://github.com/ReVanced/revanced-patcher/blob/main/CONTRIBUTING.md).
        - **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:
@@ -100,7 +101,7 @@ body:
      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.
+        - label: I have checked all open and closed bug reports and this is not a duplicate.
          required: true
        - label: I have chosen an appropriate title.
          required: true
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -11,18 +11,18 @@ body:
            <source
              width="256px"
              media="(prefers-color-scheme: dark)"
-              srcset="../../assets/revanced-headline/revanced-headline-vertical-dark.svg"
+              srcset="https://raw.githubusercontent.com/revanced/revanced-patcher/main/assets/revanced-headline/revanced-headline-vertical-dark.svg"
            >
            <img 
              width="256px"
-              src="../../assets/revanced-headline/revanced-headline-vertical-light.svg"
+              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="../../assets/revanced-logo/revanced-logo.svg" />
-                 <img height="24px" src="../../assets/revanced-logo/revanced-logo.svg" />
+                 <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">
@@ -70,7 +70,8 @@ body:

        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 submit a duplicate feature request**: Search for existing feature requests [here](https://github.com/ReVanced/revanced-patcher/issues?q=label%3A%22Feature+request%22).
+        - **Review the contribution guidelines**: Make sure your feature request adheres to it. You can find the guidelines [here](https://github.com/ReVanced/revanced-patcher/blob/main/CONTRIBUTING.md).
        - **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
@@ -98,7 +99,7 @@ body:
      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.
+        - label: I have checked all open and closed feature requests and this is not a duplicate.
          required: true
        - label: I have chosen an appropriate title.
          required: true
--- a/.github/workflows/build_pull_request.yml
+++ b/.github/workflows/build_pull_request.yml
@@ -12,12 +12,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
        with:
          fetch-depth: 0

      - name: Cache Gradle
-        uses: burrunan/gradle-cache-action@v1
+        uses: burrunan/gradle-cache-action@v3

      - name: Build
        env:
--- a/.github/workflows/open_pull_request.yml
+++ b/.github/workflows/open_pull_request.yml
@@ -15,7 +15,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: Open pull request
        uses: repo-sync/pull-request@v2
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -10,26 +10,25 @@ on:
 jobs:
  release:
    name: Release
+    permissions:
+      contents: write
+      packages: write
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          # Make sure the release step uses its own credentials:
-          # https://github.com/cycjimmy/semantic-release-action#private-packages
-          persist-credentials: false
-          fetch-depth: 0
+        uses: actions/checkout@v5

      - name: Cache Gradle
-        uses: burrunan/gradle-cache-action@v1
+        uses: burrunan/gradle-cache-action@v3

      - name: Build
        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ORG_GRADLE_PROJECT_githubPackagesUsername: ${{ env.GITHUB_ACTOR }}
+          ORG_GRADLE_PROJECT_githubPackagesPassword: ${{ secrets.GITHUB_TOKEN }}
        run: ./gradlew build clean

      - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v5
        with:
          node-version: "lts/*"
          cache: 'npm'
@@ -42,9 +41,10 @@ jobs:
        with:
          gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
          passphrase: ${{ secrets.GPG_PASSPHRASE }}
-          fingerprint: ${{ env.GPG_FINGERPRINT }}
+          fingerprint: ${{ vars.GPG_FINGERPRINT }}

      - name: Release
+        uses: cycjimmy/semantic-release-action@v4
        env:
-          GITHUB_TOKEN: ${{ secrets.REPOSITORY_PUSH_ACCESS }}
-        run: npm exec semantic-release
+          ORG_GRADLE_PROJECT_githubPackagesUsername: ${{ env.GITHUB_ACTOR }}
+          ORG_GRADLE_PROJECT_githubPackagesPassword: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/update_documentation.yml
+++ b/.github/workflows/update_documentation.yml
@@ -11,7 +11,7 @@ jobs:
    name: Dispatch event to documentation repository
    if: github.ref == 'refs/heads/main'
    steps:
-      - uses: peter-evans/repository-dispatch@v2
+      - uses: peter-evans/repository-dispatch@v3
        with:
          token: ${{ secrets.DOCUMENTATION_REPO_ACCESS_TOKEN  }}
          repository: revanced/revanced-documentation
--- a/.gitignore
+++ b/.gitignore
@@ -1,124 +1,19 @@
-### Java template
-# Compiled class file
-*.class
-
-# Log file
-*.log
-
-# BlueJ files
-*.ctxt
-
-# Mobile Tools for Java (J2ME)
-.mtj.tmp/
-
-# Package Files #
-*.jar
-*.war
-*.nar
-*.ear
-*.zip
-*.tar.gz
-*.rar
-
-# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
-hs_err_pid*
-
-### JetBrains template
-# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
-# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
-
-# User-specific stuff
-.idea/**/workspace.xml
-.idea/**/tasks.xml
-.idea/**/usage.statistics.xml
-.idea/**/dictionaries
-.idea/**/shelf
-
-# Generated files
-.idea/**/contentModel.xml
-
-# Sensitive or high-churn files
-.idea/**/dataSources/
-.idea/**/dataSources.ids
-.idea/**/dataSources.local.xml
-.idea/**/sqlDataSources.xml
-.idea/**/dynamic.xml
-.idea/**/uiDesigner.xml
-.idea/**/dbnavigator.xml
-
-# Gradle
-.idea/**/gradle.xml
-.idea/**/libraries
-
-# Gradle and Maven with auto-import
-# When using Gradle or Maven with auto-import, you should exclude module files,
-# since they will be recreated, and may cause churn.  Uncomment if using
-# auto-import.
-.idea/artifacts
-.idea/compiler.xml
-.idea/jarRepositories.xml
-.idea/modules.xml
-.idea/*.iml
-.idea/modules
 *.iml
-*.ipr
-
-# CMake
-cmake-build-*/
-
-# Mongo Explorer plugin
-.idea/**/mongoSettings.xml
-
-# File-based project format
-*.iws
-
-# IntelliJ
-out/
-.idea/
-
-# mpeltonen/sbt-idea plugin
-.idea_modules/
-
-# JIRA plugin
-atlassian-ide-plugin.xml
-
-# Cursive Clojure plugin
-.idea/replstate.xml
-
-# Crashlytics plugin (for Android Studio and IntelliJ)
-com_crashlytics_export_strings.xml
-crashlytics.properties
-crashlytics-build.properties
-fabric.properties
-
-# Editor-based Rest Client
-.idea/httpRequests
-
-# Android studio 3.1+ serialized cache file
-.idea/caches/build_file_checksums.ser
-
-### Gradle template
+.kotlin
 .gradle
 **/build/
+xcuserdata
 !src/**/build/
-
-# Ignore Gradle GUI config
-gradle-app.setting
-
-# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
-!gradle-wrapper.jar
-
-# Cache of project
-.gradletasknamecache
-
-# # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
-# gradle/wrapper/gradle-wrapper.properties
-
-# Avoid ignoring test resources
-!src/test/resources/*
-
-# Dependency directories
+local.properties
+.idea
+.DS_Store
+captures
+.externalNativeBuild
+.cxx
+*.xcodeproj/*
+!*.xcodeproj/project.pbxproj
+!*.xcodeproj/xcshareddata/
+!*.xcodeproj/project.xcworkspace/
+!*.xcworkspace/contents.xcworkspacedata
+**/xcshareddata/WorkspaceSettings.xcsettings
 node_modules/
-
-# Gradle props, to avoid sharing the gpr key
-gradle.properties
--- a/.releaserc
+++ b/.releaserc
@@ -23,7 +23,8 @@
        "assets": [
          "CHANGELOG.md",
          "gradle.properties"
-        ]
+        ],
+        "message": "chore: Release v${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
      }
    ],
    [
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,230 @@
+# [21.1.0-dev.5](https://github.com/ReVanced/revanced-patcher/compare/v21.1.0-dev.4...v21.1.0-dev.5) (2025-10-16)
+
+# [21.1.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v21.1.0-dev.3...v21.1.0-dev.4) (2025-07-18)
+
+
+### Bug Fixes
+
+* Correctly save XML files in UTF-8 by using a bufferedWriter ([#356](https://github.com/ReVanced/revanced-patcher/issues/356)) ([33fadcb](https://github.com/ReVanced/revanced-patcher/commit/33fadcbd0c7076b848bdca4d62a9c684d5781232))
+
+# [21.1.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v21.1.0-dev.2...v21.1.0-dev.3) (2025-06-20)
+
+
+### Bug Fixes
+
+* Encode XML files as UTF-8 to fix compilation of resources ([#339](https://github.com/ReVanced/revanced-patcher/issues/339)) ([4f2ef3c](https://github.com/ReVanced/revanced-patcher/commit/4f2ef3c47cea76a26c464cfb45d4bb57fe7198b5))
+
+# [21.1.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v21.1.0-dev.1...v21.1.0-dev.2) (2025-06-20)
+
+
+### Bug Fixes
+
+* Add back missing log by naming logger correctly ([#332](https://github.com/ReVanced/revanced-patcher/issues/332)) ([e4e66b0](https://github.com/ReVanced/revanced-patcher/commit/e4e66b0d8bb0986b79fb150b9c15da35b8e11561))
+* Support UTF-8 chars when compiling instructions in Smali in non UTF-8 environments ([#331](https://github.com/ReVanced/revanced-patcher/issues/331)) ([bb8771b](https://github.com/ReVanced/revanced-patcher/commit/bb8771bb8b8ab1724d957e56f4de88c02684d87b))
+
+
+### Features
+
+* Use option name as key for simplicity and consistency ([754b02e](https://github.com/ReVanced/revanced-patcher/commit/754b02e4ca66ec10764d5205c6643f2d86d0c6a2))
+
+
+### Performance Improvements
+
+* Use a buffered writer to reduce IO overhead ([#347](https://github.com/ReVanced/revanced-patcher/issues/347)) ([99f4318](https://github.com/ReVanced/revanced-patcher/commit/99f431897eb9e607987fd5d09b879d7eda442f3e))
+
+# [21.1.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0...v21.1.0-dev.1) (2024-12-07)
+
+
+### Features
+
+* Add identity hash code to unnamed patches ([88a3252](https://github.com/ReVanced/revanced-patcher/commit/88a325257494939a79fb30dd51d60c5c52546755))
+
+# [21.0.0](https://github.com/ReVanced/revanced-patcher/compare/v20.0.2...v21.0.0) (2024-11-05)
+
+
+### Bug Fixes
+
+* Match fingerprint before delegating the match property ([5d996de](https://github.com/ReVanced/revanced-patcher/commit/5d996def4d3de4e2bfc34562e5a6c7d89a8cddf0))
+* Merge extension only when patch executes ([#315](https://github.com/ReVanced/revanced-patcher/issues/315)) ([aa472eb](https://github.com/ReVanced/revanced-patcher/commit/aa472eb9857145b53b49f843406a9764fbb7e5ce))
+
+
+### Features
+
+* Improve Fingerprint API ([#316](https://github.com/ReVanced/revanced-patcher/issues/316)) ([0abf1c6](https://github.com/ReVanced/revanced-patcher/commit/0abf1c6c0279708fdef5cb66b141d07d17682693))
+* Improve various APIs  ([#317](https://github.com/ReVanced/revanced-patcher/issues/317)) ([b824978](https://github.com/ReVanced/revanced-patcher/commit/b8249789df8b90129f7b7ad0e523a8d0ceaab848))
+* Move fingerprint match members to fingerprint for ease of access by using context receivers ([0746c22](https://github.com/ReVanced/revanced-patcher/commit/0746c22743a9561bae2284d234b151f2f8511ca5))
+
+
+### Performance Improvements
+
+* Use smallest lookup map for strings ([1358d3f](https://github.com/ReVanced/revanced-patcher/commit/1358d3fa10cb8ba011b6b89cfe3684ecf9849d2f))
+
+
+### BREAKING CHANGES
+
+* Various APIs have been changed.
+* Many APIs have been changed.
+
+# [21.0.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0-dev.3...v21.0.0-dev.4) (2024-11-05)
+
+
+### Performance Improvements
+
+* Use smallest lookup map for strings ([1358d3f](https://github.com/ReVanced/revanced-patcher/commit/1358d3fa10cb8ba011b6b89cfe3684ecf9849d2f))
+
+# [21.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0-dev.2...v21.0.0-dev.3) (2024-11-05)
+
+
+### Features
+
+* Move fingerprint match members to fingerprint for ease of access by using context receivers ([0746c22](https://github.com/ReVanced/revanced-patcher/commit/0746c22743a9561bae2284d234b151f2f8511ca5))
+
+# [21.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0-dev.1...v21.0.0-dev.2) (2024-11-01)
+
+
+### Bug Fixes
+
+* Match fingerprint before delegating the match property ([5d996de](https://github.com/ReVanced/revanced-patcher/commit/5d996def4d3de4e2bfc34562e5a6c7d89a8cddf0))
+
+# [21.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v20.0.2...v21.0.0-dev.1) (2024-10-27)
+
+
+### Bug Fixes
+
+* Merge extension only when patch executes ([#315](https://github.com/ReVanced/revanced-patcher/issues/315)) ([aa472eb](https://github.com/ReVanced/revanced-patcher/commit/aa472eb9857145b53b49f843406a9764fbb7e5ce))
+
+
+### Features
+
+* Improve Fingerprint API ([#316](https://github.com/ReVanced/revanced-patcher/issues/316)) ([0abf1c6](https://github.com/ReVanced/revanced-patcher/commit/0abf1c6c0279708fdef5cb66b141d07d17682693))
+* Improve various APIs  ([#317](https://github.com/ReVanced/revanced-patcher/issues/317)) ([b824978](https://github.com/ReVanced/revanced-patcher/commit/b8249789df8b90129f7b7ad0e523a8d0ceaab848))
+
+
+### BREAKING CHANGES
+
+* Various APIs have been changed.
+* Many APIs have been changed.
+
+## [20.0.2](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1...v20.0.2) (2024-10-17)
+
+
+### Bug Fixes
+
+* Make it work on Android 12 and lower by using existing APIs ([#312](https://github.com/ReVanced/revanced-patcher/issues/312)) ([a44802e](https://github.com/ReVanced/revanced-patcher/commit/a44802ef4ebf59ae47213854ba761c81dadc51f3))
+
+## [20.0.2-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1...v20.0.2-dev.1) (2024-10-15)
+
+
+### Bug Fixes
+
+* Make it work on Android 12 and lower by using existing APIs ([#312](https://github.com/ReVanced/revanced-patcher/issues/312)) ([a44802e](https://github.com/ReVanced/revanced-patcher/commit/a44802ef4ebf59ae47213854ba761c81dadc51f3))
+
+## [20.0.1](https://github.com/ReVanced/revanced-patcher/compare/v20.0.0...v20.0.1) (2024-10-13)
+
+
+### Bug Fixes
+
+* Check for class type exactly instead of with contains ([#310](https://github.com/ReVanced/revanced-patcher/issues/310)) ([69f2f20](https://github.com/ReVanced/revanced-patcher/commit/69f2f20fd99162f91cd9c531dfe47d00d3152ead))
+* Make it work on Android by not using APIs from JVM unavailable to Android. ([2be6e97](https://github.com/ReVanced/revanced-patcher/commit/2be6e97817437f40e17893dfff3bea2cd4c3ff9e))
+* Use non-nullable type for options ([ea6fc70](https://github.com/ReVanced/revanced-patcher/commit/ea6fc70caab055251ad4d0d3f1b5cf53865abb85))
+
+
+### Performance Improvements
+
+* Free memory earlier and remove negligible lookup maps ([d53aacd](https://github.com/ReVanced/revanced-patcher/commit/d53aacdad4ed3750ddae526fb307577ea36e6171))
+
+## [20.0.1-dev.5](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1-dev.4...v20.0.1-dev.5) (2024-10-11)
+
+
+### Bug Fixes
+
+* Use non-nullable type for options ([ea6fc70](https://github.com/ReVanced/revanced-patcher/commit/ea6fc70caab055251ad4d0d3f1b5cf53865abb85))
+
+## [20.0.1-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1-dev.3...v20.0.1-dev.4) (2024-10-07)
+
+
+### Bug Fixes
+
+* Make it work on Android by not using APIs from JVM unavailable to Android. ([2be6e97](https://github.com/ReVanced/revanced-patcher/commit/2be6e97817437f40e17893dfff3bea2cd4c3ff9e))
+
+## [20.0.1-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1-dev.2...v20.0.1-dev.3) (2024-10-03)
+
+
+### Performance Improvements
+
+* Free memory earlier and remove negligible lookup maps ([d53aacd](https://github.com/ReVanced/revanced-patcher/commit/d53aacdad4ed3750ddae526fb307577ea36e6171))
+
+## [20.0.1-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1-dev.1...v20.0.1-dev.2) (2024-10-01)
+
+## [20.0.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v20.0.0...v20.0.1-dev.1) (2024-09-18)
+
+
+### Bug Fixes
+
+* Check for class type exactly instead of with contains ([#310](https://github.com/ReVanced/revanced-patcher/issues/310)) ([69f2f20](https://github.com/ReVanced/revanced-patcher/commit/69f2f20fd99162f91cd9c531dfe47d00d3152ead))
+
+# [20.0.0](https://github.com/ReVanced/revanced-patcher/compare/v19.3.1...v20.0.0) (2024-08-06)
+
+
+### Bug Fixes
+
+* Downgrade smali to fix dex compilation issue ([5227e98](https://github.com/ReVanced/revanced-patcher/commit/5227e98abfaa2ff1204eb20a0f2671f58c489930))
+* Improve exception message wording ([5481d0c](https://github.com/ReVanced/revanced-patcher/commit/5481d0c54ccecc91cd8d15af1ba2d3285a33e5ab))
+* Make constructor internal as supposed ([7f44174](https://github.com/ReVanced/revanced-patcher/commit/7f44174d91f0af0d50a83d80a7103c779241e094))
+* Merge all extensions before initializing lookup maps ([8c4dd5b](https://github.com/ReVanced/revanced-patcher/commit/8c4dd5b3a309077fa9a3827b4931fc28b0517809))
+* Use null for compatible package version when adding packages only ([736b3ee](https://github.com/ReVanced/revanced-patcher/commit/736b3eebbfdd7279b8d5fcfc5c46c9e3aadbee12))
+
+
+### Features
+
+* Add ability to create options outside of a patch ([d310246](https://github.com/ReVanced/revanced-patcher/commit/d310246852504b08a15f6376bbf25ac7c6fae76f))
+* Convert APIs to Kotlin DSL ([#298](https://github.com/ReVanced/revanced-patcher/issues/298)) ([11a911d](https://github.com/ReVanced/revanced-patcher/commit/11a911dc674eb0801649949dd3f28dfeb00efe97))
+
+
+### BREAKING CHANGES
+
+* Various old APIs are removed, and DSL APIs are added instead.
+
+# [20.0.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v20.0.0-dev.3...v20.0.0-dev.4) (2024-08-06)
+
+
+### Bug Fixes
+
+* Improve exception message wording ([bd434ce](https://github.com/ReVanced/revanced-patcher/commit/bd434ceb3394d1d5292e8b94e5bfd6da0e4e9c72))
+
+# [20.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v20.0.0-dev.2...v20.0.0-dev.3) (2024-08-01)
+
+
+### Bug Fixes
+
+* Make constructor internal as supposed ([e95fcd1](https://github.com/ReVanced/revanced-patcher/commit/e95fcd1c0b641164bbf0840ec7e562aeb3bacc3e))
+
+
+### Features
+
+* Add ability to create options outside of a patch ([b8d763a](https://github.com/ReVanced/revanced-patcher/commit/b8d763a66e0601627dd71c8c24247726aa300146))
+
+# [20.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v20.0.0-dev.1...v20.0.0-dev.2) (2024-07-31)
+
+
+### Bug Fixes
+
+* Downgrade smali to fix dex compilation issue ([714447d](https://github.com/ReVanced/revanced-patcher/commit/714447de70096bf736e8e1d31c14bb5f24195070))
+* Merge all extensions before initializing lookup maps ([328aa87](https://github.com/ReVanced/revanced-patcher/commit/328aa876d8ed7826be3713754b6404195e9fe84b))
+* Use null for compatible package version when adding packages only ([a8e8fa4](https://github.com/ReVanced/revanced-patcher/commit/a8e8fa4093deb8cffbd7a582409f41867f6b568b))
+
+# [20.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v19.3.1...v20.0.0-dev.1) (2024-07-22)
+
+
+### Features
+
+* Convert APIs to Kotlin DSL ([#298](https://github.com/ReVanced/revanced-patcher/issues/298)) ([3f9cbd2](https://github.com/ReVanced/revanced-patcher/commit/3f9cbd2408fa085690a062b357e11e42c51e7f8b))
+
+
+### BREAKING CHANGES
+
+* Various old APIs are removed, and DSL APIs are added instead.
+
 ## [19.3.1](https://github.com/ReVanced/revanced-patcher/compare/v19.3.0...v19.3.1) (2024-02-14)

 ## [19.3.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v19.3.0...v19.3.1-dev.1) (2024-02-14)
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -72,7 +72,7 @@ This document describes how to contribute to ReVanced Patcher.
 ## 🙏 Submitting a feature request

 Features can be requested by opening an issue using the
-[Feature request issue template](https://github.com/ReVanced/revanced-patcher/issues/new?assignees=&labels=Feature+request&projects=&template=feature-request.yml&title=feat%3A+).
+[Feature request issue template](https://github.com/ReVanced/revanced-patcher/issues/new?assignees=&labels=Feature+request&projects=&template=feature_request.yml&title=feat%3A+).

 > **Note**
 > Requests can be accepted or rejected at the discretion of maintainers of ReVanced Patcher.
@@ -81,7 +81,7 @@ Features can be requested by opening an issue using the
 ## 🐞 Submitting a bug report

 If you encounter a bug while using ReVanced Patcher, open an issue using the
-[Bug report issue template](https://github.com/ReVanced/revanced-patcher/issues/new?assignees=&labels=Bug+report&projects=&template=bug-report.yml&title=bug%3A+).
+[Bug report issue template](https://github.com/ReVanced/revanced-patcher/issues/new?assignees=&labels=Bug+report&projects=&template=bug_report.yml&title=bug%3A+).

 ## 📝 How to contribute

--- a/README.md
+++ b/README.md
@@ -115,7 +115,7 @@ you can follow the [ReVanced documentation](https://github.com/ReVanced/revanced
 ### 📃 Documentation

 The documentation contains the fundamentals of ReVanced Patcher and how to use ReVanced Patcher to create patches.
-You can find it [here](https://github.com/ReVanced/revanced-patcher/tree/docs/docs).
+You can find it [here](https://github.com/ReVanced/revanced-patcher/tree/main/docs).

 ## 📜 Licence

--- a/api/revanced-patcher.api
+++ b/api/revanced-patcher.api
@@ -1,892 +0,0 @@
-public abstract interface class app/revanced/patcher/IntegrationsConsumer {
-	public abstract fun acceptIntegrations (Ljava/util/List;)V
-	public abstract fun acceptIntegrations (Ljava/util/Set;)V
-}
-
-public abstract interface annotation class app/revanced/patcher/InternalApi : java/lang/annotation/Annotation {
-}
-
-public final class app/revanced/patcher/PackageMetadata {
-	public final fun getPackageName ()Ljava/lang/String;
-	public final fun getPackageVersion ()Ljava/lang/String;
-}
-
-public abstract class app/revanced/patcher/PatchBundleLoader : java/util/Set, kotlin/jvm/internal/markers/KMappedMarker {
-	public synthetic fun <init> (Ljava/lang/ClassLoader;[Ljava/io/File;Lkotlin/jvm/functions/Function1;Ljava/util/Set;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public fun add (Lapp/revanced/patcher/patch/Patch;)Z
-	public synthetic fun add (Ljava/lang/Object;)Z
-	public fun addAll (Ljava/util/Collection;)Z
-	public fun clear ()V
-	public fun contains (Lapp/revanced/patcher/patch/Patch;)Z
-	public final fun contains (Ljava/lang/Object;)Z
-	public fun containsAll (Ljava/util/Collection;)Z
-	public fun getSize ()I
-	public fun isEmpty ()Z
-	public fun iterator ()Ljava/util/Iterator;
-	public fun remove (Ljava/lang/Object;)Z
-	public fun removeAll (Ljava/util/Collection;)Z
-	public fun retainAll (Ljava/util/Collection;)Z
-	public final fun size ()I
-	public fun toArray ()[Ljava/lang/Object;
-	public fun toArray ([Ljava/lang/Object;)[Ljava/lang/Object;
-}
-
-public final class app/revanced/patcher/PatchBundleLoader$Dex : app/revanced/patcher/PatchBundleLoader {
-	public fun <init> ([Ljava/io/File;)V
-	public fun <init> ([Ljava/io/File;Ljava/io/File;)V
-	public synthetic fun <init> ([Ljava/io/File;Ljava/io/File;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/PatchBundleLoader$Jar : app/revanced/patcher/PatchBundleLoader {
-	public fun <init> ([Ljava/io/File;)V
-}
-
-public abstract interface class app/revanced/patcher/PatchExecutorFunction : java/util/function/Function {
-}
-
-public final class app/revanced/patcher/Patcher : app/revanced/patcher/IntegrationsConsumer, app/revanced/patcher/PatchExecutorFunction, app/revanced/patcher/PatchesConsumer, java/io/Closeable, java/util/function/Supplier {
-	public fun <init> (Lapp/revanced/patcher/PatcherConfig;)V
-	public fun <init> (Lapp/revanced/patcher/PatcherOptions;)V
-	public fun acceptIntegrations (Ljava/util/List;)V
-	public fun acceptIntegrations (Ljava/util/Set;)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
-	public fun get ()Lapp/revanced/patcher/PatcherResult;
-	public synthetic fun get ()Ljava/lang/Object;
-	public final fun getContext ()Lapp/revanced/patcher/PatcherContext;
-}
-
-public final class app/revanced/patcher/PatcherConfig {
-	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 class app/revanced/patcher/PatcherContext {
-	public final fun getPackageMetadata ()Lapp/revanced/patcher/PackageMetadata;
-}
-
-public abstract class app/revanced/patcher/PatcherException : java/lang/Exception {
-	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Throwable;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public synthetic fun <init> (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/PatcherException$CircularDependencyException : app/revanced/patcher/PatcherException {
-}
-
-public final class app/revanced/patcher/PatcherOptions {
-	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;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/PatcherOptions;Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;ZILjava/lang/Object;)Lapp/revanced/patcher/PatcherOptions;
-	public fun equals (Ljava/lang/Object;)Z
-	public fun hashCode ()I
-	public final fun recreateResourceCacheDirectory ()Ljava/io/File;
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class app/revanced/patcher/PatcherResult {
-	public fun <init> (Ljava/util/List;Ljava/io/File;Ljava/util/List;)V
-	public synthetic fun <init> (Ljava/util/List;Ljava/io/File;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public final fun component1 ()Ljava/util/List;
-	public final fun component2 ()Ljava/io/File;
-	public final fun component3 ()Ljava/util/List;
-	public final fun copy (Ljava/util/List;Ljava/io/File;Ljava/util/List;)Lapp/revanced/patcher/PatcherResult;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/PatcherResult;Ljava/util/List;Ljava/io/File;Ljava/util/List;ILjava/lang/Object;)Lapp/revanced/patcher/PatcherResult;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getDexFiles ()Ljava/util/List;
-	public final fun getDexFiles ()Ljava/util/Set;
-	public final fun getDoNotCompress ()Ljava/util/List;
-	public final fun getResourceFile ()Ljava/io/File;
-	public final fun getResources ()Lapp/revanced/patcher/PatcherResult$PatchedResources;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class app/revanced/patcher/PatcherResult$PatchedDexFile {
-	public fun <init> (Ljava/lang/String;Ljava/io/InputStream;)V
-	public final fun getName ()Ljava/lang/String;
-	public final fun getStream ()Ljava/io/InputStream;
-}
-
-public final class app/revanced/patcher/PatcherResult$PatchedResources {
-	public final fun getDeleteResources ()Ljava/util/Set;
-	public final fun getDoNotCompress ()Ljava/util/Set;
-	public final fun getOtherResources ()Ljava/io/File;
-	public final fun getResourcesApk ()Ljava/io/File;
-}
-
-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 {
-	public final fun findClass (Ljava/lang/String;)Lapp/revanced/patcher/util/proxy/ClassProxy;
-	public final fun findClass (Lkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/util/proxy/ClassProxy;
-	public synthetic fun get ()Ljava/lang/Object;
-	public fun get ()Ljava/util/Set;
-	public final fun getClasses ()Lapp/revanced/patcher/util/ProxyClassList;
-	public final fun proxy (Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Lapp/revanced/patcher/util/proxy/ClassProxy;
-	public final fun toMethodWalker (Lcom/android/tools/smali/dexlib2/iface/Method;)Lapp/revanced/patcher/util/method/MethodWalker;
-}
-
-public abstract interface class app/revanced/patcher/data/Context : java/util/function/Supplier {
-}
-
-public final class app/revanced/patcher/data/ResourceContext : app/revanced/patcher/data/Context, java/lang/Iterable, kotlin/jvm/internal/markers/KMappedMarker {
-	public fun get ()Lapp/revanced/patcher/PatcherResult$PatchedResources;
-	public synthetic fun get ()Ljava/lang/Object;
-	public final fun get (Ljava/lang/String;)Ljava/io/File;
-	public final fun get (Ljava/lang/String;Z)Ljava/io/File;
-	public static synthetic fun get$default (Lapp/revanced/patcher/data/ResourceContext;Ljava/lang/String;ZILjava/lang/Object;)Ljava/io/File;
-	public final fun getDocument ()Lapp/revanced/patcher/data/ResourceContext$DocumentOperatable;
-	public final fun getXmlEditor ()Lapp/revanced/patcher/data/ResourceContext$XmlFileHolder;
-	public fun iterator ()Ljava/util/Iterator;
-	public final fun stageDelete (Lkotlin/jvm/functions/Function1;)Z
-}
-
-public final class app/revanced/patcher/data/ResourceContext$DocumentOperatable {
-	public fun <init> (Lapp/revanced/patcher/data/ResourceContext;)V
-	public final fun get (Ljava/io/InputStream;)Lapp/revanced/patcher/util/Document;
-	public final fun get (Ljava/lang/String;)Lapp/revanced/patcher/util/Document;
-}
-
-public final class app/revanced/patcher/data/ResourceContext$XmlFileHolder {
-	public fun <init> (Lapp/revanced/patcher/data/ResourceContext;)V
-	public final fun get (Ljava/io/InputStream;)Lapp/revanced/patcher/util/DomFileEditor;
-	public final fun get (Ljava/lang/String;)Lapp/revanced/patcher/util/DomFileEditor;
-}
-
-public final class app/revanced/patcher/extensions/ExtensionsKt {
-	public static final fun newLabel (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;I)Lcom/android/tools/smali/dexlib2/builder/Label;
-	public static final fun or (ILcom/android/tools/smali/dexlib2/AccessFlags;)I
-	public static final fun or (Lcom/android/tools/smali/dexlib2/AccessFlags;I)I
-	public static final fun or (Lcom/android/tools/smali/dexlib2/AccessFlags;Lcom/android/tools/smali/dexlib2/AccessFlags;)I
-}
-
-public final class app/revanced/patcher/extensions/InstructionExtensions {
-	public static final field INSTANCE Lapp/revanced/patcher/extensions/InstructionExtensions;
-	public final fun addInstruction (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILcom/android/tools/smali/dexlib2/builder/BuilderInstruction;)V
-	public final fun addInstruction (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILjava/lang/String;)V
-	public final fun addInstruction (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;Lcom/android/tools/smali/dexlib2/builder/BuilderInstruction;)V
-	public final fun addInstruction (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;Ljava/lang/String;)V
-	public final fun addInstructions (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILjava/lang/String;)V
-	public final fun addInstructions (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILjava/util/List;)V
-	public final fun addInstructions (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;Ljava/lang/String;)V
-	public final fun addInstructions (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;Ljava/util/List;)V
-	public final fun addInstructions (Lcom/android/tools/smali/dexlib2/builder/MutableMethodImplementation;ILjava/util/List;)V
-	public final fun addInstructions (Lcom/android/tools/smali/dexlib2/builder/MutableMethodImplementation;Ljava/util/List;)V
-	public final fun addInstructionsWithLabels (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILjava/lang/String;[Lapp/revanced/patcher/util/smali/ExternalLabel;)V
-	public final fun getInstruction (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;I)Lcom/android/tools/smali/dexlib2/builder/BuilderInstruction;
-	public final fun getInstruction (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;I)Ljava/lang/Object;
-	public final fun getInstruction (Lcom/android/tools/smali/dexlib2/builder/MutableMethodImplementation;I)Lcom/android/tools/smali/dexlib2/builder/BuilderInstruction;
-	public final fun getInstruction (Lcom/android/tools/smali/dexlib2/builder/MutableMethodImplementation;I)Ljava/lang/Object;
-	public final fun getInstructions (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;)Ljava/util/List;
-	public final fun removeInstruction (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;I)V
-	public final fun removeInstructions (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;I)V
-	public final fun removeInstructions (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;II)V
-	public final fun removeInstructions (Lcom/android/tools/smali/dexlib2/builder/MutableMethodImplementation;I)V
-	public final fun removeInstructions (Lcom/android/tools/smali/dexlib2/builder/MutableMethodImplementation;II)V
-	public final fun replaceInstruction (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILcom/android/tools/smali/dexlib2/builder/BuilderInstruction;)V
-	public final fun replaceInstruction (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILjava/lang/String;)V
-	public final fun replaceInstructions (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILjava/lang/String;)V
-	public final fun replaceInstructions (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILjava/util/List;)V
-	public final fun replaceInstructions (Lcom/android/tools/smali/dexlib2/builder/MutableMethodImplementation;ILjava/util/List;)V
-}
-
-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/MethodFingerprint;)Lapp/revanced/patcher/fingerprint/annotation/FuzzyPatternScanMethod;
-}
-
-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 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/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/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/MethodFingerprintResult$MethodFingerprintScanResult;
-}
-
-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/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 getEndIndex ()I
-	public final fun getStartIndex ()I
-	public final fun getWarnings ()Ljava/util/List;
-	public final fun setWarnings (Ljava/util/List;)V
-}
-
-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 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 final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult {
-	public fun <init> (Ljava/util/List;)V
-	public final fun getMatches ()Ljava/util/List;
-}
-
-public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch {
-	public fun <init> (Ljava/lang/String;I)V
-	public final fun getIndex ()I
-	public final fun getString ()Ljava/lang/String;
-}
-
-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;
-	public final fun getDependencies ()Ljava/util/Set;
-	public final fun getDescription ()Ljava/lang/String;
-	public final fun getName ()Ljava/lang/String;
-	public final fun getOptions ()Lapp/revanced/patcher/patch/options/PatchOptions;
-	public final fun getRequiresIntegrations ()Z
-	public final fun getUse ()Z
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class app/revanced/patcher/patch/Patch$CompatiblePackage {
-	public fun <init> (Ljava/lang/String;Ljava/util/Set;)V
-	public synthetic fun <init> (Ljava/lang/String;Ljava/util/Set;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public final fun getName ()Ljava/lang/String;
-	public final fun getVersions ()Ljava/util/Set;
-}
-
-public final class app/revanced/patcher/patch/PatchException : java/lang/Exception {
-	public fun <init> (Ljava/lang/String;)V
-	public fun <init> (Ljava/lang/String;Ljava/lang/Throwable;)V
-	public fun <init> (Ljava/lang/Throwable;)V
-}
-
-public final class app/revanced/patcher/patch/PatchResult {
-	public final fun getException ()Lapp/revanced/patcher/patch/PatchException;
-	public final fun getPatch ()Lapp/revanced/patcher/patch/Patch;
-}
-
-public abstract class app/revanced/patcher/patch/RawResourcePatch : 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 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 {
-	public abstract fun name ()Ljava/lang/String;
-	public abstract fun versions ()[Ljava/lang/String;
-}
-
-public abstract interface annotation class app/revanced/patcher/patch/annotation/Patch : java/lang/annotation/Annotation {
-	public abstract fun compatiblePackages ()[Lapp/revanced/patcher/patch/annotation/CompatiblePackage;
-	public abstract fun dependencies ()[Ljava/lang/Class;
-	public abstract fun description ()Ljava/lang/String;
-	public abstract fun name ()Ljava/lang/String;
-	public abstract fun requiresIntegrations ()Z
-	public abstract fun use ()Z
-}
-
-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/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;
-	public final fun getRequired ()Z
-	public final fun getTitle ()Ljava/lang/String;
-	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 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
-	public fun toString ()Ljava/lang/String;
-}
-
-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/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 {
-	public synthetic fun <init> (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/PatchOptionException$InvalidValueTypeException : app/revanced/patcher/patch/options/PatchOptionException {
-	public fun <init> (Ljava/lang/String;Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/patch/options/PatchOptionException$PatchOptionNotFoundException : app/revanced/patcher/patch/options/PatchOptionException {
-	public fun <init> (Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/patch/options/PatchOptionException$ValueRequiredException : app/revanced/patcher/patch/options/PatchOptionException {
-	public fun <init> (Lapp/revanced/patcher/patch/options/PatchOption;)V
-}
-
-public final class app/revanced/patcher/patch/options/PatchOptionException$ValueValidationException : app/revanced/patcher/patch/options/PatchOptionException {
-	public fun <init> (Ljava/lang/Object;Lapp/revanced/patcher/patch/options/PatchOption;)V
-}
-
-public final class app/revanced/patcher/patch/options/PatchOptions : java/util/Map, kotlin/jvm/internal/markers/KMutableMap {
-	public fun <init> ()V
-	public fun clear ()V
-	public final fun containsKey (Ljava/lang/Object;)Z
-	public fun containsKey (Ljava/lang/String;)Z
-	public fun containsValue (Lapp/revanced/patcher/patch/options/PatchOption;)Z
-	public final fun containsValue (Ljava/lang/Object;)Z
-	public final fun entrySet ()Ljava/util/Set;
-	public final fun get (Ljava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final synthetic fun get (Ljava/lang/Object;)Ljava/lang/Object;
-	public fun get (Ljava/lang/String;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public fun getEntries ()Ljava/util/Set;
-	public fun getKeys ()Ljava/util/Set;
-	public fun getSize ()I
-	public fun getValues ()Ljava/util/Collection;
-	public fun isEmpty ()Z
-	public final fun keySet ()Ljava/util/Set;
-	public synthetic fun put (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
-	public fun put (Ljava/lang/String;Lapp/revanced/patcher/patch/options/PatchOption;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public fun putAll (Ljava/util/Map;)V
-	public final fun register (Lapp/revanced/patcher/patch/options/PatchOption;)V
-	public final fun remove (Ljava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final synthetic fun remove (Ljava/lang/Object;)Ljava/lang/Object;
-	public fun remove (Ljava/lang/String;)Lapp/revanced/patcher/patch/options/PatchOption;
-	public final fun set (Ljava/lang/String;Ljava/lang/Object;)V
-	public final fun size ()I
-	public final fun values ()Ljava/util/Collection;
-}
-
-public final class app/revanced/patcher/util/Document : java/io/Closeable, org/w3c/dom/Document {
-	public fun adoptNode (Lorg/w3c/dom/Node;)Lorg/w3c/dom/Node;
-	public fun appendChild (Lorg/w3c/dom/Node;)Lorg/w3c/dom/Node;
-	public fun cloneNode (Z)Lorg/w3c/dom/Node;
-	public fun close ()V
-	public fun compareDocumentPosition (Lorg/w3c/dom/Node;)S
-	public fun createAttribute (Ljava/lang/String;)Lorg/w3c/dom/Attr;
-	public fun createAttributeNS (Ljava/lang/String;Ljava/lang/String;)Lorg/w3c/dom/Attr;
-	public fun createCDATASection (Ljava/lang/String;)Lorg/w3c/dom/CDATASection;
-	public fun createComment (Ljava/lang/String;)Lorg/w3c/dom/Comment;
-	public fun createDocumentFragment ()Lorg/w3c/dom/DocumentFragment;
-	public fun createElement (Ljava/lang/String;)Lorg/w3c/dom/Element;
-	public fun createElementNS (Ljava/lang/String;Ljava/lang/String;)Lorg/w3c/dom/Element;
-	public fun createEntityReference (Ljava/lang/String;)Lorg/w3c/dom/EntityReference;
-	public fun createProcessingInstruction (Ljava/lang/String;Ljava/lang/String;)Lorg/w3c/dom/ProcessingInstruction;
-	public fun createTextNode (Ljava/lang/String;)Lorg/w3c/dom/Text;
-	public fun getAttributes ()Lorg/w3c/dom/NamedNodeMap;
-	public fun getBaseURI ()Ljava/lang/String;
-	public fun getChildNodes ()Lorg/w3c/dom/NodeList;
-	public fun getDoctype ()Lorg/w3c/dom/DocumentType;
-	public fun getDocumentElement ()Lorg/w3c/dom/Element;
-	public fun getDocumentURI ()Ljava/lang/String;
-	public fun getDomConfig ()Lorg/w3c/dom/DOMConfiguration;
-	public fun getElementById (Ljava/lang/String;)Lorg/w3c/dom/Element;
-	public fun getElementsByTagName (Ljava/lang/String;)Lorg/w3c/dom/NodeList;
-	public fun getElementsByTagNameNS (Ljava/lang/String;Ljava/lang/String;)Lorg/w3c/dom/NodeList;
-	public fun getFeature (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
-	public fun getFirstChild ()Lorg/w3c/dom/Node;
-	public fun getImplementation ()Lorg/w3c/dom/DOMImplementation;
-	public fun getInputEncoding ()Ljava/lang/String;
-	public fun getLastChild ()Lorg/w3c/dom/Node;
-	public fun getLocalName ()Ljava/lang/String;
-	public fun getNamespaceURI ()Ljava/lang/String;
-	public fun getNextSibling ()Lorg/w3c/dom/Node;
-	public fun getNodeName ()Ljava/lang/String;
-	public fun getNodeType ()S
-	public fun getNodeValue ()Ljava/lang/String;
-	public fun getOwnerDocument ()Lorg/w3c/dom/Document;
-	public fun getParentNode ()Lorg/w3c/dom/Node;
-	public fun getPrefix ()Ljava/lang/String;
-	public fun getPreviousSibling ()Lorg/w3c/dom/Node;
-	public fun getStrictErrorChecking ()Z
-	public fun getTextContent ()Ljava/lang/String;
-	public fun getUserData (Ljava/lang/String;)Ljava/lang/Object;
-	public fun getXmlEncoding ()Ljava/lang/String;
-	public fun getXmlStandalone ()Z
-	public fun getXmlVersion ()Ljava/lang/String;
-	public fun hasAttributes ()Z
-	public fun hasChildNodes ()Z
-	public fun importNode (Lorg/w3c/dom/Node;Z)Lorg/w3c/dom/Node;
-	public fun insertBefore (Lorg/w3c/dom/Node;Lorg/w3c/dom/Node;)Lorg/w3c/dom/Node;
-	public fun isDefaultNamespace (Ljava/lang/String;)Z
-	public fun isEqualNode (Lorg/w3c/dom/Node;)Z
-	public fun isSameNode (Lorg/w3c/dom/Node;)Z
-	public fun isSupported (Ljava/lang/String;Ljava/lang/String;)Z
-	public fun lookupNamespaceURI (Ljava/lang/String;)Ljava/lang/String;
-	public fun lookupPrefix (Ljava/lang/String;)Ljava/lang/String;
-	public fun normalize ()V
-	public fun normalizeDocument ()V
-	public fun removeChild (Lorg/w3c/dom/Node;)Lorg/w3c/dom/Node;
-	public fun renameNode (Lorg/w3c/dom/Node;Ljava/lang/String;Ljava/lang/String;)Lorg/w3c/dom/Node;
-	public fun replaceChild (Lorg/w3c/dom/Node;Lorg/w3c/dom/Node;)Lorg/w3c/dom/Node;
-	public fun setDocumentURI (Ljava/lang/String;)V
-	public fun setNodeValue (Ljava/lang/String;)V
-	public fun setPrefix (Ljava/lang/String;)V
-	public fun setStrictErrorChecking (Z)V
-	public fun setTextContent (Ljava/lang/String;)V
-	public fun setUserData (Ljava/lang/String;Ljava/lang/Object;Lorg/w3c/dom/UserDataHandler;)Ljava/lang/Object;
-	public fun setXmlStandalone (Z)V
-	public fun setXmlVersion (Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/util/DomFileEditor : java/io/Closeable {
-	public fun <init> (Ljava/io/File;)V
-	public fun close ()V
-	public final fun getFile ()Lorg/w3c/dom/Document;
-}
-
-public final class app/revanced/patcher/util/ProxyClassList : java/util/Set, kotlin/jvm/internal/markers/KMutableSet {
-	public final fun add (Lapp/revanced/patcher/util/proxy/ClassProxy;)Z
-	public fun add (Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
-	public synthetic fun add (Ljava/lang/Object;)Z
-	public fun addAll (Ljava/util/Collection;)Z
-	public fun clear ()V
-	public fun contains (Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
-	public final fun contains (Ljava/lang/Object;)Z
-	public fun containsAll (Ljava/util/Collection;)Z
-	public fun getSize ()I
-	public fun isEmpty ()Z
-	public fun iterator ()Ljava/util/Iterator;
-	public fun remove (Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
-	public final fun remove (Ljava/lang/Object;)Z
-	public fun removeAll (Ljava/util/Collection;)Z
-	public fun retainAll (Ljava/util/Collection;)Z
-	public final fun size ()I
-	public fun toArray ()[Ljava/lang/Object;
-	public fun toArray ([Ljava/lang/Object;)[Ljava/lang/Object;
-}
-
-public final class app/revanced/patcher/util/method/MethodWalker {
-	public final fun getMethod ()Lcom/android/tools/smali/dexlib2/iface/Method;
-	public final fun nextMethod (IZ)Lapp/revanced/patcher/util/method/MethodWalker;
-	public static synthetic fun nextMethod$default (Lapp/revanced/patcher/util/method/MethodWalker;IZILjava/lang/Object;)Lapp/revanced/patcher/util/method/MethodWalker;
-}
-
-public final class app/revanced/patcher/util/proxy/ClassProxy {
-	public final fun getImmutableClass ()Lcom/android/tools/smali/dexlib2/iface/ClassDef;
-	public final fun getMutableClass ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableAnnotation : com/android/tools/smali/dexlib2/base/BaseAnnotation {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/MutableAnnotation$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/Annotation;)V
-	public fun getElements ()Ljava/util/Set;
-	public fun getType ()Ljava/lang/String;
-	public fun getVisibility ()I
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableAnnotation$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/Annotation;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableAnnotation;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableAnnotationElement : com/android/tools/smali/dexlib2/base/BaseAnnotationElement {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/MutableAnnotationElement$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/AnnotationElement;)V
-	public fun getName ()Ljava/lang/String;
-	public fun getValue ()Lcom/android/tools/smali/dexlib2/iface/value/EncodedValue;
-	public final fun setName (Ljava/lang/String;)V
-	public final fun setValue (Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableAnnotationElement$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/AnnotationElement;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableAnnotationElement;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableClass : com/android/tools/smali/dexlib2/base/reference/BaseTypeReference, com/android/tools/smali/dexlib2/iface/ClassDef {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/ClassDef;)V
-	public final fun charAt (I)C
-	public fun get (I)C
-	public fun getAccessFlags ()I
-	public fun getAnnotations ()Ljava/util/Set;
-	public synthetic fun getDirectMethods ()Ljava/lang/Iterable;
-	public fun getDirectMethods ()Ljava/util/Set;
-	public synthetic fun getFields ()Ljava/lang/Iterable;
-	public fun getFields ()Ljava/util/Set;
-	public synthetic fun getInstanceFields ()Ljava/lang/Iterable;
-	public fun getInstanceFields ()Ljava/util/Set;
-	public fun getInterfaces ()Ljava/util/List;
-	public fun getLength ()I
-	public synthetic fun getMethods ()Ljava/lang/Iterable;
-	public fun getMethods ()Ljava/util/Set;
-	public fun getSourceFile ()Ljava/lang/String;
-	public synthetic fun getStaticFields ()Ljava/lang/Iterable;
-	public fun getStaticFields ()Ljava/util/Set;
-	public fun getSuperclass ()Ljava/lang/String;
-	public fun getType ()Ljava/lang/String;
-	public synthetic fun getVirtualMethods ()Ljava/lang/Iterable;
-	public fun getVirtualMethods ()Ljava/util/Set;
-	public final fun length ()I
-	public final fun setAccessFlags (I)V
-	public final fun setSourceFile (Ljava/lang/String;)V
-	public final fun setSuperClass (Ljava/lang/String;)V
-	public final fun setType (Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableClass$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableField : com/android/tools/smali/dexlib2/base/reference/BaseFieldReference, com/android/tools/smali/dexlib2/iface/Field {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/MutableField$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/Field;)V
-	public fun getAccessFlags ()I
-	public fun getAnnotations ()Ljava/util/Set;
-	public fun getDefiningClass ()Ljava/lang/String;
-	public fun getHiddenApiRestrictions ()Ljava/util/Set;
-	public fun getInitialValue ()Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue;
-	public synthetic fun getInitialValue ()Lcom/android/tools/smali/dexlib2/iface/value/EncodedValue;
-	public fun getName ()Ljava/lang/String;
-	public fun getType ()Ljava/lang/String;
-	public final fun setAccessFlags (I)V
-	public final fun setDefiningClass (Ljava/lang/String;)V
-	public final fun setInitialValue (Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue;)V
-	public final fun setName (Ljava/lang/String;)V
-	public final fun setType (Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableField$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/Field;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableField;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableMethod : com/android/tools/smali/dexlib2/base/reference/BaseMethodReference, com/android/tools/smali/dexlib2/iface/Method {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/Method;)V
-	public fun getAccessFlags ()I
-	public fun getAnnotations ()Ljava/util/Set;
-	public fun getDefiningClass ()Ljava/lang/String;
-	public fun getHiddenApiRestrictions ()Ljava/util/Set;
-	public fun getImplementation ()Lcom/android/tools/smali/dexlib2/builder/MutableMethodImplementation;
-	public synthetic fun getImplementation ()Lcom/android/tools/smali/dexlib2/iface/MethodImplementation;
-	public fun getName ()Ljava/lang/String;
-	public fun getParameterTypes ()Ljava/util/List;
-	public fun getParameters ()Ljava/util/List;
-	public fun getReturnType ()Ljava/lang/String;
-	public final fun setAccessFlags (I)V
-	public final fun setDefiningClass (Ljava/lang/String;)V
-	public final fun setName (Ljava/lang/String;)V
-	public final fun setReturnType (Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableMethod$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/Method;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableMethodParameter : com/android/tools/smali/dexlib2/base/BaseMethodParameter, com/android/tools/smali/dexlib2/iface/MethodParameter {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethodParameter$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/MethodParameter;)V
-	public final fun charAt (I)C
-	public fun get (I)C
-	public fun getAnnotations ()Ljava/util/Set;
-	public fun getLength ()I
-	public fun getName ()Ljava/lang/String;
-	public fun getSignature ()Ljava/lang/String;
-	public fun getType ()Ljava/lang/String;
-	public final fun length ()I
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/MutableMethodParameter$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/MethodParameter;)Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethodParameter;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableAnnotationEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseAnnotationEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableAnnotationEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/AnnotationEncodedValue;)V
-	public fun getElements ()Ljava/util/Set;
-	public fun getType ()Ljava/lang/String;
-	public final fun setType (Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableAnnotationEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/AnnotationEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableAnnotationEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableArrayEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseArrayEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableArrayEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/ArrayEncodedValue;)V
-	public fun getValue ()Ljava/util/List;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableArrayEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/ArrayEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableArrayEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableBooleanEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseBooleanEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableBooleanEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/BooleanEncodedValue;)V
-	public fun getValue ()Z
-	public final fun setValue (Z)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableBooleanEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/BooleanEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableBooleanEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableByteEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseByteEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableByteEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/ByteEncodedValue;)V
-	public fun getValue ()B
-	public final fun setValue (B)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableByteEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/ByteEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableByteEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableCharEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseCharEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableCharEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/CharEncodedValue;)V
-	public fun getValue ()C
-	public final fun setValue (C)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableCharEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/CharEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableCharEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableDoubleEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseDoubleEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableDoubleEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/DoubleEncodedValue;)V
-	public fun getValue ()D
-	public final fun setValue (D)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableDoubleEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/DoubleEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableDoubleEncodedValue;
-}
-
-public abstract interface class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue : com/android/tools/smali/dexlib2/iface/value/EncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue$Companion;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/EncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEnumEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseEnumEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEnumEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/EnumEncodedValue;)V
-	public fun getValue ()Lcom/android/tools/smali/dexlib2/iface/reference/FieldReference;
-	public final fun setValue (Lcom/android/tools/smali/dexlib2/iface/reference/FieldReference;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEnumEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/EnumEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEnumEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFieldEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseFieldEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFieldEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/FieldEncodedValue;)V
-	public fun getValue ()Lcom/android/tools/smali/dexlib2/iface/reference/FieldReference;
-	public fun getValueType ()I
-	public final fun setValue (Lcom/android/tools/smali/dexlib2/iface/reference/FieldReference;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFieldEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/FieldEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFieldEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFloatEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseFloatEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFloatEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/FloatEncodedValue;)V
-	public fun getValue ()F
-	public final fun setValue (F)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFloatEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/FloatEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFloatEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableIntEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseIntEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableIntEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/IntEncodedValue;)V
-	public fun getValue ()I
-	public final fun setValue (I)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableIntEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/IntEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableIntEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableLongEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseLongEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableLongEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/LongEncodedValue;)V
-	public fun getValue ()J
-	public final fun setValue (J)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableLongEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/LongEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableLongEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseMethodEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/MethodEncodedValue;)V
-	public fun getValue ()Lcom/android/tools/smali/dexlib2/iface/reference/MethodReference;
-	public final fun setValue (Lcom/android/tools/smali/dexlib2/iface/reference/MethodReference;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/MethodEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodHandleEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseMethodHandleEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodHandleEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/MethodHandleEncodedValue;)V
-	public fun getValue ()Lcom/android/tools/smali/dexlib2/iface/reference/MethodHandleReference;
-	public final fun setValue (Lcom/android/tools/smali/dexlib2/iface/reference/MethodHandleReference;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodHandleEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/MethodHandleEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodHandleEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodTypeEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseMethodTypeEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodTypeEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/MethodTypeEncodedValue;)V
-	public fun getValue ()Lcom/android/tools/smali/dexlib2/iface/reference/MethodProtoReference;
-	public final fun setValue (Lcom/android/tools/smali/dexlib2/iface/reference/MethodProtoReference;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodTypeEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/MethodTypeEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodTypeEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableNullEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseNullEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableNullEncodedValue$Companion;
-	public fun <init> ()V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableNullEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/ByteEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableByteEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableShortEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseShortEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableShortEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/ShortEncodedValue;)V
-	public fun getValue ()S
-	public final fun setValue (S)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableShortEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/ShortEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableShortEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableStringEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseStringEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableStringEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/StringEncodedValue;)V
-	public fun getValue ()Ljava/lang/String;
-	public final fun setValue (Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableStringEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/ByteEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableByteEncodedValue;
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableTypeEncodedValue : com/android/tools/smali/dexlib2/base/value/BaseTypeEncodedValue, app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue {
-	public static final field Companion Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableTypeEncodedValue$Companion;
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/value/TypeEncodedValue;)V
-	public fun getValue ()Ljava/lang/String;
-	public final fun setValue (Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableTypeEncodedValue$Companion {
-	public final fun toMutable (Lcom/android/tools/smali/dexlib2/iface/value/TypeEncodedValue;)Lapp/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableTypeEncodedValue;
-}
-
-public final class app/revanced/patcher/util/smali/ExternalLabel {
-	public fun <init> (Ljava/lang/String;Lcom/android/tools/smali/dexlib2/iface/instruction/Instruction;)V
-	public final fun copy (Ljava/lang/String;Lcom/android/tools/smali/dexlib2/iface/instruction/Instruction;)Lapp/revanced/patcher/util/smali/ExternalLabel;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/util/smali/ExternalLabel;Ljava/lang/String;Lcom/android/tools/smali/dexlib2/iface/instruction/Instruction;ILjava/lang/Object;)Lapp/revanced/patcher/util/smali/ExternalLabel;
-	public fun equals (Ljava/lang/Object;)Z
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class app/revanced/patcher/util/smali/InlineSmaliCompiler {
-	public static final field Companion Lapp/revanced/patcher/util/smali/InlineSmaliCompiler$Companion;
-	public fun <init> ()V
-}
-
-public final class app/revanced/patcher/util/smali/InlineSmaliCompiler$Companion {
-	public final fun compile (Ljava/lang/String;Ljava/lang/String;IZ)Ljava/util/List;
-}
-
-public final class app/revanced/patcher/util/smali/InlineSmaliCompilerKt {
-	public static final fun toInstruction (Ljava/lang/String;Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;)Lcom/android/tools/smali/dexlib2/builder/BuilderInstruction;
-	public static synthetic fun toInstruction$default (Ljava/lang/String;Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILjava/lang/Object;)Lcom/android/tools/smali/dexlib2/builder/BuilderInstruction;
-	public static final fun toInstructions (Ljava/lang/String;Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;)Ljava/util/List;
-	public static synthetic fun toInstructions$default (Ljava/lang/String;Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ILjava/lang/Object;)Ljava/util/List;
-}
-
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,107 +1,5 @@
 plugins {
-    alias(libs.plugins.kotlin)
-    alias(libs.plugins.binary.compatibility.validator)
-    `maven-publish`
-    signing
-}
-
-group = "app.revanced"
-
-tasks {
-    processResources {
-        expand("projectVersion" to project.version)
-    }
-
-    test {
-        useJUnitPlatform()
-        testLogging {
-            events("PASSED", "SKIPPED", "FAILED")
-        }
-    }
-}
-
-repositories {
-    mavenCentral()
-    mavenLocal()
-    google()
-    maven {
-        // A repository must be speficied for some reason. "registry" is a dummy.
-        url = uri("https://maven.pkg.github.com/revanced/registry")
-        credentials {
-            username = project.findProperty("gpr.user") as String? ?: System.getenv("GITHUB_ACTOR")
-            password = project.findProperty("gpr.key") as String? ?: System.getenv("GITHUB_TOKEN")
-        }
-    }
-}
-
-dependencies {
-    implementation(libs.kotlinx.coroutines.core)
-    implementation(libs.xpp3)
-    implementation(libs.smali)
-    implementation(libs.multidexlib2)
-    implementation(libs.apktool.lib)
-    implementation(libs.kotlin.reflect)
-
-    // TODO: Convert project to KMP.
-    compileOnly(libs.android) {
-        // Exclude, otherwise the org.w3c.dom API breaks.
-        exclude(group = "xerces", module = "xmlParserAPIs")
-    }
-
-    testImplementation(libs.kotlin.test)
-}
-
-kotlin {
-    jvmToolchain(11)
-}
-
-publishing {
-    repositories {
-        maven {
-            name = "GitHubPackages"
-            url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
-            credentials {
-                username = System.getenv("GITHUB_ACTOR")
-                password = System.getenv("GITHUB_TOKEN")
-            }
-        }
-    }
-
-    publications {
-        create<MavenPublication>("revanced-patcher-publication") {
-            from(components["java"])
-
-            version = project.version.toString()
-
-            pom {
-                name = "ReVanced Patcher"
-                description = "Patcher used by ReVanced."
-                url = "https://revanced.app"
-
-                licenses {
-                    license {
-                        name = "GNU General Public License v3.0"
-                        url = "https://www.gnu.org/licenses/gpl-3.0.en.html"
-                    }
-                }
-                developers {
-                    developer {
-                        id = "ReVanced"
-                        name = "ReVanced"
-                        email = "contact@revanced.app"
-                    }
-                }
-                scm {
-                    connection = "scm:git:git://github.com/revanced/revanced-patcher.git"
-                    developerConnection = "scm:git:git@github.com:revanced/revanced-patcher.git"
-                    url = "https://github.com/revanced/revanced-patcher"
-                }
-            }
-        }
-    }
-}
-
-signing {
-    useGpgCmd()
-    sign(publishing.publications["revanced-patcher-publication"])
-}
+    alias(libs.plugins.android.kotlin.multiplatform.library) apply false
+    alias(libs.plugins.kotlinMultiplatform) apply false
+    alias(libs.plugins.vanniktech.mavenPublish) apply false
+}
--- a/docs/1_patcher_intro.md
+++ b/docs/1_patcher_intro.md
@@ -60,40 +60,43 @@

 # 💉 Introduction to ReVanced Patcher

-In order to create patches for Android applications, you first need to understand the fundamentals of ReVanced Patcher.
+To create patches for Android apps, it is recommended to know the basic concept of ReVanced Patcher.

 ## 📙 How it works

-ReVanced Patcher is a library that allows you to modify Android applications by applying patches to their APKs. It is built on top of [Smali](https://github.com/google/smali) for bytecode manipulation and [Androlib (Apktool)](https://github.com/iBotPeaches/Apktool) for resource decoding and encoding.
-ReVanced Patcher accepts a list of patches and integrations, and applies them to a given APK file. It then returns the modified components of the APK file, such as modified dex files and resources, that can be repackaged into a new APK file.
+ReVanced Patcher is a library that allows modifying Android apps by applying patches.
+It is built on top of [Smali](https://github.com/google/smali) for bytecode manipulation and [Androlib (Apktool)](https://github.com/iBotPeaches/Apktool)
+for resource decoding and encoding.

-ReVanced Patcher has a simple API that allows you to load patches and integrations from JAR files and apply them to an APK file.
-Later on, you will learn how to create patches.
+ReVanced Patcher receives a list of patches and applies them to a given APK file.
+It then returns the modified components of the APK file, such as modified dex files and resources,
+that can be repackaged into a new APK file.
+
+ReVanced Patcher has a simple API that allows you to load patches from RVP (JAR or DEX container) files
+and apply them to an APK file. Later on, you will learn how to create patches.

 ```kt
- // Executed patches do not necessarily reset their state.
- // For that reason it is important to create a new instance of the PatchBundleLoader
- // once the patches are executed instead of reusing the same instance of patches loaded by PatchBundleLoader.
-val patches: PatchSet /* = Set<Patch<*>> */ = PatchBundleLoader.Jar(File("revanced-patches.jar"))
-val integrations = setOf(File("integrations.apk"))
+val patches = loadPatchesFromJar(setOf(File("revanced-patches.rvp")))

-// Instantiating the patcher will decode the manifest of the APK file to read the package and version name.
-val patcherConfig = PatcherConfig(apkFile = File("some.apk"))
-val patcherResult = Patcher(patcherConfig).use { patcher ->
-    patcher.apply {
-        acceptIntegrations(integrations)
-        acceptPatches(patches)
+val patcherResult = Patcher(PatcherConfig(apkFile = File("some.apk"))).use { patcher ->
+    // Here you can access metadata about the APK file through patcher.context.packageMetadata
+    // such as package name, version code, version name, etc.

-        // Execute patches.
-        runBlocking {
-            patcher.apply(returnOnError = false).collect { patchResult ->
-                if (patchResult.exception != null)
-                    println("${patchResult.patchName} failed:\n${patchResult.exception}")
-                else
-                    println("${patchResult.patchName} succeeded")
-            }
+    // Add patches.
+    patcher += patches
+
+    // Execute the patches.
+    runBlocking {
+        patcher().collect { patchResult ->
+            if (patchResult.exception != null)
+                logger.info { "\"${patchResult.patch}\" failed:\n${patchResult.exception}" }
+            else
+                logger.info { "\"${patchResult.patch}\" succeeded" }
        }
-    }.get()
+    }
+
+    // Compile and save the patched APK file components.
+    patcher.get()
 }

 // The result of the patcher contains the modified components of the APK file that can be repackaged into a new APK file.
--- a/docs/2_1_setup.md
+++ b/docs/2_1_setup.md
@@ -60,7 +60,7 @@

 # 👶 Setting up a development environment

-To get started developing patches with ReVanced Patcher, you need to prepare a development environment.
+To start developing patches with ReVanced Patcher, you must prepare a development environment.

 ## 📝 Prerequisites

@@ -72,6 +72,10 @@ To get started developing patches with ReVanced Patcher, you need to prepare a d

 Throughout the documentation, [ReVanced Patches](https://github.com/revanced/revanced-patches) will be used as an example project.

+> [!NOTE]
+> To start a fresh project, 
+> you can use the [ReVanced Patches template](https://github.com/revanced/revanced-patches-template).
+
 1. Clone the repository

   ```bash
@@ -84,21 +88,22 @@ Throughout the documentation, [ReVanced Patches](https://github.com/revanced/rev
   ./gradlew build
   ```

-   > [!NOTE]
-   > If the build fails due to authentication, you may need to authenticate to GitHub Packages.
-   > Create a PAT with the scope `read:packages` [here](https://github.com/settings/tokens/new?scopes=read:packages&description=ReVanced) and add your token to ~/.gradle/gradle.properties.
-   >
-   > Example `gradle.properties` file:
-   >
-   > ```properties
-   > gpr.user = user
-   > gpr.key = key
-   > ```
+> [!NOTE]
+> If the build fails due to authentication, you may need to authenticate to GitHub Packages.
+> Create a PAT with the scope `read:packages` [here](https://github.com/settings/tokens/new?scopes=read:packages&description=ReVanced) and add your token to ~/.gradle/gradle.properties.
+>
+> Example `gradle.properties` file:
+>
+> ```properties
+> gpr.user = user
+> gpr.key = key
+> ```

 3. Open the project in your IDE

 > [!TIP]
-> It is a good idea to set up a complete development environment for ReVanced, so that you can also test your patches by following the [ReVanced documentation](https://github.com/ReVanced/revanced-documentation).
+> It is a good idea to set up a complete development environment for ReVanced, so that you can also test your patches
+> by following the [ReVanced documentation](https://github.com/ReVanced/revanced-documentation).

 ## ⏭️ What's next

--- a/docs/2_2_1_fingerprinting.md
+++ b/docs/2_2_1_fingerprinting.md
@@ -60,29 +60,32 @@

 # 🔎 Fingerprinting

-In the context of ReVanced, fingerprinting is primarily used to resolve methods with a limited amount of known information.
+In the context of ReVanced, a fingerprint is a partial description of a method.
+It is used to uniquely match a method by its characteristics.
+Fingerprinting is used to match methods with a limited amount of known information.
 Methods with obfuscated names that change with each update are primary candidates for fingerprinting.
-The goal of fingerprinting is to uniquely identify a method by capturing various attributes, such as the return type, access flags, an opcode pattern, strings, and more.
+The goal of fingerprinting is to uniquely identify a method by capturing various attributes, such as the return type,
+access flags, an opcode pattern, strings, and more.

 ## ⛳️ Example fingerprint

-Throughout the documentation, the following example will be used to demonstrate the concepts of fingerprints:
+An example fingerprint is shown below:

 ```kt

 package app.revanced.patches.ads.fingerprints

-object ShowAdsFingerprint : MethodFingerprint(
-    returnType = "Z",
-    accessFlags = AccessFlags.PUBLIC or AccessFlags.FINAL,
-    parameters = listOf("Z"),
-    opcodes = listOf(Opcode.RETURN),
-    strings = listOf("pro"),
-    customFingerprint = { (methodDef, classDef) -> methodDef.definingClass == "Lcom/some/app/ads/AdsLoader;" }
-)
+fingerprint {
+    accessFlags(AccessFlags.PUBLIC, AccessFlags.FINAL)
+    returns("Z")
+    parameters("Z")
+    opcodes(Opcode.RETURN)
+    strings("pro")
+    custom { (method, classDef) -> classDef == "Lcom/some/app/ads/AdsLoader;" }
+}
 ```

-## 🔎 Reconstructing the original code from a fingerprint
+## 🔎 Reconstructing the original code from the example fingerprint from above

 The following code is reconstructed from the fingerprint to understand how a fingerprint is created.

@@ -91,182 +94,200 @@ The fingerprint contains the following information:
 - Method signature:

  ```kt
-  returnType = "Z",
-  access = AccessFlags.PUBLIC or AccessFlags.FINAL,
-  parameters = listOf("Z"),
+  accessFlags(AccessFlags.PUBLIC, AccessFlags.FINAL)
+  returns("Z")
+  parameters("Z")
  ```

 - Method implementation:

  ```kt
-  opcodes = listOf(Opcode.RETURN)
-  strings = listOf("pro"),
+  opcodes(Opcode.RETURN)
+  strings("pro")
  ```

 - Package and class name:

  ```kt
-  customFingerprint = { (methodDef, classDef) -> methodDef.definingClass == "Lcom/some/app/ads/AdsLoader;"}
+  custom { (method, classDef) -> classDef == "Lcom/some/app/ads/AdsLoader;" }
  ```

 With this information, the original code can be reconstructed:

 ```java
-    package com.some.app.ads;
+package com.some.app.ads;

-    <accessFlags> class AdsLoader {
-        public final boolean <methodName>(boolean <parameter>) {
-            // ...
+<accessFlags>

-            var userStatus = "pro";
+class AdsLoader {
+    public final boolean <methodName>(boolean <parameter>)

-            // ...
+    {
+        // ...

-            return <returnValue>;
-        }
+        var userStatus = "pro";
+
+        // ...
+
+        return <returnValue >;
    }
+}
 ```

+Using that fingerprint, this method can be matched uniquely from all other methods.
+
 > [!TIP]
 > A fingerprint should contain information about a method likely to remain the same across updates.
-> A method's name is not included in the fingerprint because it is likely to change with each update in an obfuscated app. In contrast, the return type, access flags, parameters, patterns of opcodes, and strings are likely to remain the same.
+> A method's name is not included in the fingerprint because it will likely change with each update in an obfuscated
+> app.
+> In contrast, the return type, access flags, parameters, patterns of opcodes, and strings are likely to remain the
+> same.

 ## 🔨 How to use fingerprints

-After creating a fingerprint, add it to the constructor of a `BytecodePatch`:
+After declaring a fingerprint, it can be used in a patch to find the method it matches to:

 ```kt
-object DisableAdsPatch : BytecodePatch(
-    setOf(ShowAdsFingerprint)
-) {
+val fingerprint = fingerprint {
    // ...
- }
+}
+
+val patch = bytecodePatch {
+    execute {
+        fingerprint.method
+    }
+}
 ```

-> [!NOTE]
-> Fingerprints passed to the constructor of `BytecodePatch` are resolved by ReVanced Patcher before the patch is executed.
+The fingerprint won't be matched again, if it has already been matched once, for performance reasons.
+This makes it useful, to share fingerprints between multiple patches,
+and let the first executing patch match the fingerprint:

-> [!TIP]
-> Multiple patches can share fingerprints. If a fingerprint is resolved once, it will not be resolved again.
+```kt
+// Either of these two patches will match the fingerprint first and the other patch can reuse the match:
+val mainActivityPatch1 = bytecodePatch {
+    execute {
+        mainActivityOnCreateFingerprint.method
+    }
+}

-> [!TIP]
-> If a fingerprint has an opcode pattern, you can use the `FuzzyPatternScanMethod` annotation to fuzzy match the pattern.
-> Opcode pattern arrays can contain `null` values to indicate that the opcode at the index is unknown.
-> Any opcode will match to a `null` value.
+val mainActivityPatch2 = bytecodePatch {
+    execute {
+        mainActivityOnCreateFingerprint.method
+    }
+}
+```

 > [!WARNING]
-> If the fingerprint can not be resolved because it does not match any method, the result of a fingerprint is `null`.
+> If the fingerprint can not be matched to any method,
+> accessing certain properties of the fingerprint will raise an exception.
+> Instead, the `orNull` properties can be used to return `null` if no match is found.

-Once the fingerprint is resolved, the result can be used in the patch:
+> [!TIP]
+> If a fingerprint has an opcode pattern, you can use the `fuzzyPatternScanThreshhold` parameter of the `opcode`
+> function to fuzzy match the pattern.  
+> `null` can be used as a wildcard to match any opcode:
+>
+> ```kt
+> fingerprint(fuzzyPatternScanThreshhold = 2) {
+>   opcodes(
+>     Opcode.ICONST_0,
+>     null,
+>     Opcode.ICONST_1,
+>     Opcode.IRETURN,
+>    )
+>}
+> ```

-```kt
-object DisableAdsPatch : BytecodePatch(
-  setOf(ShowAdsFingerprint)
-) {
-    override fun execute(context: BytecodeContext) {
-        val result = ShowAdsFingerprint.result
-            ?: throw PatchException("ShowAdsFingerprint not found")
+The following properties can be accessed in a fingerprint:

-        // ...
-    }
-}
-```
+- `originalClassDef`: The original class definition the fingerprint matches to.
+- `originalClassDefOrNull`: The original class definition the fingerprint matches to.
+- `originalMethod`: The original method the fingerprint matches to.
+- `originalMethodOrNull`: The original method the fingerprint matches to.
+- `classDef`: The class the fingerprint matches to.
+- `classDefOrNull`: The class the fingerprint matches to.
+- `method`: The method the fingerprint matches to. If no match is found, an exception is raised.
+- `methodOrNull`: The method the fingerprint matches to.

-The result of a fingerprint that resolved successfully contains mutable and immutable references to the method and the class it is defined in.
+The difference between the `original` and non-`original` properties is that the `original` properties return the
+original class or method definition, while the non-`original` properties return a mutable copy of the class or method.
+The mutable copies can be modified. They are lazy properties, so they are only computed
+and only then will effectively replace the `original` method or class definition when accessed.

-```kt
-class MethodFingerprintResult(
-    val method: Method,
-    val classDef: ClassDef,
-    val scanResult: MethodFingerprintScanResult,
-    // ...
-) {
-    val mutableClass by lazy { /* ... */ }
-    val mutableMethod by lazy { /* ... */ }
+> [!TIP]
+> If only read-only access to the class or method is needed,
+> the `originalClassDef` and `originalMethod` properties should be used,
+> to avoid making a mutable copy of the class or method.

-    // ...
-}
+## 🏹 Manually matching fingerprints

-class MethodFingerprintScanResult(
-    val patternScanResult: PatternScanResult?,
-    val stringsScanResult: StringsScanResult?,
-) {
-    class StringsScanResult(val matches: List<StringMatch>) {
-        class StringMatch(val string: String, val index: Int)
-    }
+By default, a fingerprint is matched automatically against all classes
+when one of the fingerprint's properties is accessed.

-    class PatternScanResult(
-        val startIndex: Int,
-        val endIndex: Int,
-        // ...
-    ) {
-        // ...
-    }
-}
-```
+Instead, the fingerprint can be matched manually using various overloads of a fingerprint's `match` function:

-## 🏹 Manual resolution of fingerprints
+- In a **list of classes**, if the fingerprint can match in a known subset of classes

-Unless a fingerprint is added to the constructor of `BytecodePatch`, the fingerprint will not be resolved automatically by ReVanced Patcher before the patch is executed.
-Instead, the fingerprint can be resolved manually using various overloads of the `resolve` function of a fingerprint.
-
-You can resolve a fingerprint in the following ways:
-
- On a **list of classes**, if the fingerprint can resolve on a known subset of classes
-
-  If you have a known list of classes you know the fingerprint can resolve on, you can resolve the fingerprint on the list of classes:
+  If you have a known list of classes you know the fingerprint can match in,
+  you can match the fingerprint on the list of classes:

  ```kt
-  override fun execute(context: BytecodeContext) {
-      val result = ShowAdsFingerprint.also { it.resolve(context, context.classes) }.result
-          ?: throw PatchException("ShowAdsFingerprint not found")
-
-          // ...
+  execute {
+    val match = showAdsFingerprint(classes)
  }
  ```

- On a **single class**, if the fingerprint can resolve on a single known class
+- In a **single class**, if the fingerprint can match in a single known class

-  If you know the fingerprint can resolve to a method in a specific class, you can resolve the fingerprint on the class:
+  If you know the fingerprint can match a method in a specific class, you can match the fingerprint in the class:

  ```kt
-  override fun execute(context: BytecodeContext) {
-      val adsLoaderClass = context.classes.single { it.name == "Lcom/some/app/ads/Loader;" }
+  execute {
+    val adsLoaderClass = classes.single { it.name == "Lcom/some/app/ads/Loader;" }

-      val result = ShowAdsFingerprint.also { it.resolve(context, adsLoaderClass) }.result
-          ?: throw PatchException("ShowAdsFingerprint not found")
-
-      // ...
+    val match = showAdsFingerprint.match(adsLoaderClass)
  }
  ```

- On a **single method**, to extract certain information about a method
+  Another common usecase is to use a fingerprint to reduce the search space of a method to a single class.

-  The result of a fingerprint contains useful information about the method, such as the start and end index of an opcode pattern or the indices of the instructions with certain string references.
+  ```kt
+  execute {
+    // Match showAdsFingerprint in the class of the ads loader found by adsLoaderClassFingerprint.
+    val match = showAdsFingerprint.match(adsLoaderClassFingerprint.classDef)
+  }
+  ```
+
+- Match a **single method**, to extract certain information about it
+
+  The match of a fingerprint contains useful information about the method,
+  such as the start and end index of an opcode pattern or the indices of the instructions with certain string
+  references.
  A fingerprint can be leveraged to extract such information from a method instead of manually figuring it out:

  ```kt
-  override fun execute(context: BytecodeContext) {
-      val adsFingerprintResult = ShowAdsFingerprint.result
-          ?: throw PatchException("ShowAdsFingerprint not found")
+  execute {
+    val currentPlanFingerprint = fingerprint {
+      strings("free", "trial")
+    }

-      val proStringsFingerprint = object : MethodFingerprint(
-          strings = listOf("free", "trial")
-      ) {}
-
-      proStringsFingerprint.also {
-          it.resolve(context, adsFingerprintResult.method)
-      }.result?.let { result ->
-          result.scanResult.stringsScanResult!!.matches.forEach { match ->
-              println("The index of the string '${match.string}' is ${match.index}")
-          }
-
-      } ?: throw PatchException("pro strings fingerprint not found")
+    currentPlanFingerprint.match(adsFingerprint.method).let { match ->
+      match.stringMatches.forEach { match ->
+        println("The index of the string '${match.string}' is ${match.index}")
+      }
+    }
  }
  ```

+> [!WARNING]
+> If the fingerprint can not be matched to any method, calling `match` will raise an
+> exception.
+> Instead, the `orNull` overloads can be used to return `null` if no match is found.
+
 > [!TIP]
-> To see real-world examples of fingerprints, check out the [ReVanced Patches](https://github.com/revanced/revanced-patches) repository.
+> To see real-world examples of fingerprints,
+> check out the repository for [ReVanced Patches](https://github.com/revanced/revanced-patches).

 ## ⏭️ What's next

--- a/docs/2_2_patch_anatomy.md
+++ b/docs/2_2_patch_anatomy.md
@@ -64,145 +64,196 @@ Learn the API to create patches using ReVanced Patcher.

 ## ⛳️ Example patch

-Throughout the documentation, the following example will be used to demonstrate the concepts of patches:
+The following example patch disables ads in an app.  
+In the following sections, each part of the patch will be explained in detail.

 ```kt
 package app.revanced.patches.ads

-@Patch(
+val disableAdsPatch = bytecodePatch(
    name = "Disable ads",
    description = "Disable ads in the app.",
-    dependencies = [DisableAdsResourcePatch::class],
-    compatiblePackages = [CompatiblePackage("com.some.app", ["1.3.0"])]
-)
-object DisableAdsPatch : BytecodePatch(
-    setOf(ShowAdsFingerprint)
 ) {
-    override fun execute(context: BytecodeContext) {
-        ShowAdsFingerprint.result?.let { result ->
-            result.mutableMethod.addInstructions(
-                0,
-                """
-                    # Return false.
-                    const/4 v0, 0x0
-                    return v0
-                """
-            )
-        } ?: throw PatchException("ShowAdsFingerprint not found")
+    compatibleWith("com.some.app"("1.0.0"))
+
+    // Patches can depend on other patches, executing them first.
+    dependsOn(disableAdsResourcePatch)
+
+    // Merge precompiled DEX files into the patched app, before the patch is executed.
+    extendWith("disable-ads.rve")
+
+    // Business logic of the patch to disable ads in the app.
+    execute {
+        // Fingerprint to find the method to patch.
+        val showAdsFingerprint = fingerprint {
+            // More about fingerprints on the next page of the documentation.
+        }
+
+        // In the method that shows ads,
+        // call DisableAdsPatch.shouldDisableAds() from the extension (precompiled DEX file)
+        // to enable or disable ads.
+        showAdsFingerprint.method.addInstructions(
+            0,
+            """
+                invoke-static {}, LDisableAdsPatch;->shouldDisableAds()Z
+                move-result v0
+                return v0
+            """
+        )
    }
 }
 ```

-## 🔎 Breakdown
+> [!TIP]
+> To see real-world examples of patches,
+> check out the repository for [ReVanced Patches](https://github.com/revanced/revanced-patches).

-The example patch consists of the following parts:
+## 🧩 Patch API

-### 📝 Patch annotation
+### ⚙️ Patch options
+
+Patches can have options to get and set before a patch is executed.
+Options are useful for making patches configurable.
+After loading the patches using `PatchLoader`, options can be set for a patch.
+Multiple types are already built into ReVanced Patcher and are supported by any application that uses ReVanced Patcher.
+
+To define an option, use the available `option` functions:

 ```kt
-@Patch(
-    name = "Disable ads",
-    description = "Disable ads in the app.",
-    dependencies = [DisableAdsResourcePatch::class],
-    compatiblePackages = [CompatiblePackage("com.some.app", ["1.3.0"])]
-)
-```
+val patch = bytecodePatch(name = "Patch") {
+    // Add an inbuilt option and delegate it to a property.
+    val value by stringOption(name = "Inbuilt option")

-The `@Patch` annotation is used to provide metadata about the patch.
+    // Add an option with a custom type and delegate it to a property.
+    val string by option<String>(name = "String option")

-Notable annotation parameters are:
-
- `name`: The name of the patch. This is used as an identifier for the patch.
-  If this parameter is not set, `PatchBundleLoader` will not load the patch.
-  Other patches can still use this patch as a dependency
- `description`: A description of the patch. Can be unset if the name is descriptive enough
- `dependencies`: A set of patches which the patch depends on. The patches in this set will be executed before this patch. If a dependency patch raises an exception, this patch will not be executed; subsquently, other patches that depend on this patch will not be executed.
- `compatiblePackages`: A set of `CompatiblePackage` objects. Each `CompatiblePackage` object contains the package name and a set of compatible version names. This parameter can specify the packages and versions the patch is compatible with. Patches can still execute on incompatible packages, but it is recommended to use this parameter to list known compatible packages
-  - If unset, it is implied that the patch is compatible with all packages
-  - If the set of versions is unset, it is implied that the patch is compatible with all versions of the package
-  - If the set of versions is empty, it is implied that the patch is not compatible with any version of the package. This can be useful, for example, to prevent a patch from executing on specific packages that are known to be incompatible
-
-> [!WARNING]
-> Circular dependencies are not allowed. If a patch depends on another patch, the other patch cannot depend on the first patch.
-
-> [!NOTE]
-> The `@Patch` annotation is optional. If the patch does not require any metadata, it can be omitted.
-> If the patch is only used as a dependency, the metadata, such as the `compatiblePackages` parameter, has no effect, as every dependency patch inherits the compatible packages of the patches that depend on it.
-
-> [!TIP]
-> An abstract patch class can be annotated with `@Patch`.
-> Patches extending off the abstract patch class will inherit the metadata of the abstract patch class.
-
-> [!TIP]
-> Instead of the `@Patch` annotation, the superclass's constructor can be used. This is useful in the example scenario where you want to create an abstract patch class.
->
-> Example:
->
-> ```kt
-> abstract class AbstractDisableAdsPatch(
->     fingerprints: Set<Fingerprint>
-> ) : BytecodePatch(
->     name = "Disable ads",
->     description = "Disable ads in the app.",
->     fingerprints
-> ) {
->   // ...
-> }
-> ```
->
-> Remember that this constructor has precedence over the `@Patch` annotation.
-
-### 🏗️ Patch class
-
-```kt
-object DisableAdsPatch : BytecodePatch( /* Parameters */ ) {
-  // ...
+    execute {
+        println(value)
+        println(string)
+    }
 }
 ```

-Each patch class extends off a base class that implements the `Patch` interface.
-The interface requires the `execute` method to be implemented.
-Depending on which base class is extended, the patch can modify different parts of the APK as described in [🧩 Introduction to ReVanced Patches](2_introduction_to_patches.md).
-
-> [!TIP]
-> A patch is usually a singleton object, meaning only one patch instance exists in the JVM.
-> Because dependencies are executed before the patch itself, a patch can rely on the state of the dependency patch.
-> This is useful in the example scenario, where the `DisableAdsPatch` depends on the `DisableAdsResourcePatch`.
-> The `DisableAdsResourcePatch` can, for example, be used to read the decoded resources of the app and provide the `DisableAdsPatch` with the necessary information to disable ads because the `DisableAdsResourcePatch` is executed before the `DisableAdsPatch` and is a singleton object.
-
-### 🏁 The `execute` function
-
-The `execute` function is declared in the `Patch` interface and needs to be implemented.
-The `execute` function receives an instance of a context object that provides access to the APK. The patch can use this context to modify the APK as described in [🧩 Introduction to ReVanced Patches](2_introduction_to_patches.md).
-
-In the current example, the patch adds instructions at the beginning of a method implementation in the Dalvik VM bytecode. The added instructions return `false` to disable ads in the current example:
+Options of a patch can be set after loading the patches with `PatchLoader` by obtaining the instance for the patch:

 ```kt
-val result = LoadAdsFingerprint.result
-  ?: throw PatchException("LoadAdsFingerprint not found")
-
-result.mutableMethod.addInstructions(
-    0,
-    """
-        # Return false.
-        const/4 v0, 0x0
-        return v0
-    """
-)
+loadPatchesJar(patches).apply {
+    // Type is checked at runtime.
+    first { it.name == "Patch" }.options["Option"] = "Value"
+}
 ```

+The type of an option can be obtained from the `type` property of the option:
+
+```kt
+option.type // The KType of the option. Captures the full type information of the option.
+```
+
+Options can be declared outside a patch and added to a patch manually:
+
+```kt
+val option = stringOption(name = "Option")
+
+bytecodePatch(name = "Patch") {
+    val value by option()
+}
+```
+
+This is useful when the same option is referenced in multiple patches.
+
+### 🧩 Extensions
+
+An extension is a precompiled DEX file merged into the patched app before a patch is executed.
+While patches are compile-time constructs, extensions are runtime constructs
+that extend the patched app with additional classes.
+
+Assume you want to add a complex feature to an app that would need multiple classes and methods:
+
+```java
+public class ComplexPatch {
+    public static void doSomething() {
+        // ...
+    }
+}
+```
+
+After compiling the above code as a DEX file, you can add the DEX file as a resource in the patches file
+and use it in a patch:
+
+```kt
+val patch = bytecodePatch(name = "Complex patch") {
+    extendWith("complex-patch.rve")
+
+    execute {
+        fingerprint.method.addInstructions(0, "invoke-static { }, LComplexPatch;->doSomething()V")
+    }
+}
+```
+
+ReVanced Patcher merges the classes from the extension into `context.classes` before executing the patch.
+When the patch is executed, it can reference the classes and methods from the extension.
+
 > [!NOTE]
-> This patch uses a fingerprint to find the method and replaces the method's instructions with new instructions.
-> The fingerprint is resolved on the classes present in `BytecodeContext`.
-> Fingerprints will be explained in more detail on the next page.
+>
+> The [ReVanced Patches template](https://github.com/ReVanced/revanced-patches-template) repository
+> is a template project to create patches and extensions.

 > [!TIP]
-> The patch can also raise any `Exception` or `Throwable` at any time to indicate that the patch failed to execute. A `PatchException` is recommended to be raised if the patch fails to execute.
-> If any patch depends on this patch, the dependent patch will not be executed, whereas other patches that do not depend on this patch can still be executed.
-> ReVanced Patcher will handle any exception raised by a patch.
+> To see real-world examples of extensions,
+> check out the repository for [ReVanced Patches](https://github.com/revanced/revanced-patches).

-> [!TIP]
-> To see real-world examples of patches, check out the [ReVanced Patches](https://github.com/revanced/revanced-patches) repository.
+### ♻️ Finalization
+
+Patches can have a finalization block called after all patches have been executed, in reverse order of patch execution.
+The finalization block is called after all patches that depend on the patch have been executed.
+This is useful for doing post-processing tasks.
+A simple real-world example would be a patch that opens a resource file of the app for writing.
+Other patches that depend on this patch can write to the file, and the finalization block can close the file.
+
+```kt
+val patch = bytecodePatch(name = "Patch") {
+    dependsOn(
+        bytecodePatch(name = "Dependency") {
+            execute {
+                print("1")
+            }
+
+            finalize {
+                print("4")
+            }
+        }
+    )
+
+    execute {
+        print("2")
+    }
+
+    finalize {
+        print("3")
+    }
+}
+```
+
+Because `Patch` depends on `Dependency`, first `Dependency` is executed, then `Patch`.
+Finalization blocks are called in reverse order of patch execution, which means,
+first, the finalization block of `Patch`, then the finalization block of `Dependency` is called.
+The output after executing the patch above would be `1234`.
+The same order is followed for multiple patches depending on the patch.
+
+## 💡 Additional tips
+
+- When using `PatchLoader` to load patches, only patches with a name are loaded.
+  Refer to the inline documentation of `PatchLoader` for detailed information.
+- Patches can depend on others. Dependencies are executed first.
+  The dependent patch will not be executed if a dependency raises an exception while executing.
+- A patch can declare compatibility with specific packages and versions,
+  but patches can still be executed on any package or version.
+  It is recommended that compatibility is specified to present known compatible packages and versions.
+    - If `compatibleWith` is not used, the patch is treated as compatible with any package
+- If a package is specified with no versions, the patch is compatible with any version of the package
+- If an empty array of versions is specified, the patch is not compatible with any version of the package.
+  This is useful for declaring incompatibility with a specific package.
+- A patch can raise a `PatchException` at any time of execution to indicate that the patch failed to execute.

 ## ⏭️ What's next

--- a/docs/2_patches_intro.md
+++ b/docs/2_patches_intro.md
@@ -65,61 +65,62 @@ Learn the basic concepts of ReVanced Patcher and how to create patches.
 ## 📙 Fundamentals

 A patch is a piece of code that modifies an Android application.  
-There are multiple types of patches. Each type can modify a different part of the APK, such as the Dalvik VM bytecode, the APK resources, or arbitrary files in the APK:
+There are multiple types of patches. Each type can modify a different part of the APK, such as the Dalvik VM bytecode, 
+the APK resources, or arbitrary files in the APK:

 - A `BytecodePatch` modifies the Dalvik VM bytecode
 - A `ResourcePatch` modifies (decoded) resources
 - A `RawResourcePatch` modifies arbitrary files

-Each patch can declare a set of dependencies on other patches. ReVanced Patcher will first execute dependencies before executing the patch itself. This way, multiple patches can work together for abstract purposes in a modular way.
+Each patch can declare a set of dependencies on other patches. ReVanced Patcher will first execute dependencies
+before executing the patch itself. This way, multiple patches can work together for abstract purposes in a modular way.

-A patch class can be annotated with `@Patch` to provide metadata about and dependencies of the patch.
-Alternatively, a constructor of the superclass can be used. This is useful in the example scenario where you want to create an abstract patch class.
+The `execute` function is the entry point for a patch. It is called by ReVanced Patcher when the patch is executed.
+The `execute` function receives an instance of a context object that provides access to the APK.
+The patch can use this context to modify the APK.

-The entry point of a patch is the `execute` function. This function is called by ReVanced Patcher when the patch is executed. The `execute` function receives an instance of the context object that provides access to the APK. The patch can use this context to modify the APK.
+Each type of context provides different APIs to modify the APK. For example, the `BytecodePatchContext` provides APIs
+to modify the Dalvik VM bytecode, while the `ResourcePatchContext` provides APIs to modify resources.

-Each type of context provides different APIs to modify the APK. For example, the `BytecodeContext` provides APIs to modify the Dalvik VM bytecode, while the `ResourceContext` provides APIs to modify resources.
+The difference between `ResourcePatch` and `RawResourcePatch` is that ReVanced Patcher will decode the resources
+if it is supplied a `ResourcePatch` for execution or if any patch depends on a `ResourcePatch`
+and will not decode the resources before executing `RawResourcePatch`.
+Both, `ResourcePatch` and `RawResourcePatch` can modify arbitrary files in the APK,
+whereas only `ResourcePatch` can modify decoded resources. The choice of which type to use depends on the use case.
+Decoding and building resources is a time- and resource-consuming,
+so if the patch does not need to modify decoded resources, it is better to use `RawResourcePatch` or `BytecodePatch`.

-The difference between `ResourcePatch` and `RawResourcePatch` is that ReVanced Patcher will decode the resources if it is supplied a `ResourcePatch` for execution or if any kind of patch depends on a `ResourcePatch` and will not decode the resources before executing `RawResourcePatch`. Both, `ResourcePatch` and `RawResourcePatch` can modify arbitrary files in the APK, whereas only `ResourcePatch` can modify decoded resources. The choice of which type to use depends on the use case. Decoding and building resources is a time- and resource-consuming process, so if the patch does not need to modify decoded resources, it is better to use `RawResourcePatch` or `BytecodePatch`.
-
-Example of a `BytecodePatch`:
+Example of patches:

 ```kt
@Surpress("unused")
-object MyPatch : BytecodePatch() {
-	override fun execute(context: BytecodeContext) {
-		// Your patch code here
-	}
+val bytecodePatch = bytecodePatch {
+    execute { 
+        // More about this on the next page of the documentation.
+    }
 }
-```

-Example of a `ResourcePatch`:
-
-```kt
@Surpress("unused")
-object MyPatch : ResourcePatch() {
-	override fun execute(context: ResourceContext) {
-		// Your patch code here
-	}
+val rawResourcePatch = rawResourcePatch {
+    execute {
+        // More about this on the next page of the documentation.
+    }
 }
-```

-Example of a `RawResourcePatch`:
-
-```kt
@Surpress("unused")
-object MyPatch : RawResourcePatch() {
-	override fun execute(context: ResourceContext) {
-		// Your patch code here
-	}
+val resourcePatch = resourcePatch {
+    execute {
+        // More about this on the next page of the documentation.
+    }
 }
 ```

 > [!TIP]
-> To see real-world examples of patches, check out the [ReVanced Patches](https://github.com/revanced/revanced-patches) repository.
+> To see real-world examples of patches,
+> check out the repository for [ReVanced Patches](https://github.com/revanced/revanced-patches).

 ## ⏭️ Whats next

-The next page will guide you through setting up a development environment for creating patches.
+The next page will guide you through creating a development environment for creating patches.

 Continue: [👶 Setting up a development environment](2_1_setup.md)
--- a/docs/3_structure_and_conventions.md
+++ b/docs/3_structure_and_conventions.md
@@ -64,31 +64,39 @@ Over time, a specific project structure and conventions have been established.

 ## 📁 File structure

-Patches are organized in a specific file structure. The file structure is as follows:
+Patches are organized in a specific way. The file structure looks as follows:

 ```text
 📦your.patches.app.category
- ├ 📂fingerprints
- ├ ├ 🔍SomeFingerprintA.kt
- ├ └ 🔍SomeFingerprintB.kt
+ ├ 🔍Fingerprints.kt
 └ 🧩SomePatch.kt
 ```

+> [!NOTE]
+> Moving fingerprints to a separate file isn't strictly necessary, but it helps the organization when a patch uses multiple fingerprints.
+
 ## 📙 Conventions

- 🔥 Name a patch after what it does. For example, if a patch removes ads, name it `RemoveAdsPatch`.
-  If a patch changes the color of a button, name it `ChangeButtonColorPatch`
+- 🔥 Name a patch after what it does. For example, if a patch removes ads, name it `Remove ads`.
+  If a patch changes the color of a button, name it `Change button color`
 - 🔥 Write the patch description in the third person, present tense, and end it with a period.
-  If a patch removes ads, the description can be omitted because of redundancy, but if a patch changes the color of a button, the description can be _Changes the color of the resume button to red._
- 🔥 Write patches with modularity and reusability in mind. Patches can depend on each other, so it is important to write patches in a way that can be used in different contexts.
+  If a patch removes ads, the description can be omitted because of redundancy,
+  but if a patch changes the color of a button, the description can be _Changes the color of the resume button to red._
+- 🔥 Write patches with modularity and reusability in mind. Patches can depend on each other,
+  so it is important to write patches in a way that can be used in different contexts.
 - 🔥🔥 Keep patches as minimal as possible. This reduces the risk of failing patches.
  Instead of involving many abstract changes in one patch or writing entire methods or classes in a patch,
-  you can write code in integrations. Integrations are compiled classes that are merged into the app before patches are executed as described in [💉 Introduction to ReVanced Patcher](1_patcher_intro).
-  Patches can then reference methods and classes from integrations.
-  A real-world example of integrations can be found in the [ReVanced Integrations](https://github.com/ReVanced/revanced-integrations) repository
+  you can write code in extensions. An extension is a precompiled DEX file that is merged into the patched app 
+  before this patch is executed.
+  Patches can then reference methods and classes from extensions.
+  A real-world example of extensions can be found in the [ReVanced Patches](https://github.com/ReVanced/revanced-patches) repository
 - 🔥🔥🔥 Do not overload a fingerprint with information about a method that's likely to change.
-  In the example of an obfuscated method, it's better to fingerprint the method by its return type and parameters rather than its name because the name is likely to change. An intelligent selection of an opcode pattern or strings in a method can result in a strong fingerprint dynamic to app updates.
- 🔥🔥🔥 Document your patches. Patches are abstract by nature, so it is important to document parts of the code that are not self-explanatory. For example, explain why and how a certain method is patched or large blocks of instructions that are modified or added to a method
+  In the example of an obfuscated method, it's better to fingerprint the method by its return type
+  and parameters rather than its name because the name is likely to change. An intelligent selection
+  of an opcode pattern or strings in a method can result in a strong fingerprint dynamic to app updates.
+- 🔥🔥🔥 Document your patches. Patches are abstract, so it is important to document parts of the code
+  that are not self-explanatory. For example, explain why and how a certain method is patched or large blocks
+  of instructions that are modified or added to a method

 ## ⏭️ What's next

--- a/docs/4_apis.md
+++ b/docs/4_apis.md
@@ -4,20 +4,114 @@ A handful of APIs are available to make patch development easier and more effici

 ## 📙 Overview

-1. 👹 Create new mutable classes with `context.proxy(ClassDef)`
-2. 🔍 Find and proxy existing classes with `BytecodeContext.findClass(Predicate)`
-3. 🏃‍ Easily access referenced methods recursively by index with `BytecodeContext.toMethodWalker(Method)`
-4. 🔨 Make use of extension functions from `BytecodeUtils` and `ResourceUtils` with certain applications (Available in ReVanced Patches)
-5. 💾 Read and write (decoded) resources with `ResourceContext.get(Path, Boolean) `
-6. 📃 Read and write DOM files using `ResourceContext.document`
-7. 🔧 Equip patches with configurable options using `Patch.options`
+1. 👹 Create mutable replacements of classes with `proxy(ClassDef)`
+2. 🔍 Find and create mutable replaces with `classBy(Predicate)`
+3. 🏃‍ Navigate method calls recursively by index with `navigate(Method)`
+4. 💾 Read and write resource files with `get(String, Boolean)` and `delete(String)`
+5. 📃 Read and write DOM files using `document(String)` and  `document(InputStream)`

 ### 🧰 APIs

-> [!WARNING]
-> This section is still under construction and may be incomplete.
+#### 👹 `proxy(ClassDef)`
+
+By default, the classes are immutable, meaning they cannot be modified.
+To make a class mutable, use the `proxy(ClassDef)` function.
+This function creates a lazy mutable copy of the class definition.
+Accessing the property will replace the original class definition with the mutable copy,
+thus allowing you to make changes to the class. Subsequent accesses will return the same mutable copy.
+
+```kt
+execute {
+    val mutableClass = proxy(classDef)
+    mutableClass.methods.add(Method())
+}
+```
+
+#### 🔍 `classBy(Predicate)`
+
+The `classBy(Predicate)` function is an alternative to finding and creating mutable classes by a predicate.
+It automatically proxies the class definition, making it mutable.
+
+```kt
+execute {
+    // Alternative to proxy(classes.find { it.name == "Lcom/example/MyClass;" })?.classDef
+    val classDef = classBy { it.name == "Lcom/example/MyClass;" }?.classDef
+}
+```
+
+#### 🏃‍ `navigate(Method).at(index)`
+
+The `navigate(Method)` function allows you to navigate method calls recursively by index.
+
+```kt
+execute {
+    // Sequentially navigate to the instructions at index 1 within 'someMethod'.
+    val method = navigate(someMethod).to(1).original() // original() returns the original immutable method.
+    
+    // Further navigate to the second occurrence where the instruction's opcode is 'INVOKEVIRTUAL'.
+    // stop() returns the mutable copy of the method.
+    val method = navigate(someMethod).to(2) { instruction -> instruction.opcode == Opcode.INVOKEVIRTUAL }.stop()
+    
+    // Alternatively, to stop(), you can delegate the method to a variable.
+    val method by navigate(someMethod).to(1)
+    
+    // You can chain multiple calls to at() to navigate deeper into the method.
+    val method by navigate(someMethod).to(1).to(2, 3, 4).to(5)
+}
+```
+
+#### 💾 `get(String, Boolean)` and `delete(String)`
+
+The `get(String, Boolean)` function returns a `File` object that can be used to read and write resource files.
+
+```kt
+execute {
+    val file = get("res/values/strings.xml")
+    val content = file.readText()
+    file.writeText(content)
+}
+```
+
+The `delete` function can mark files for deletion when the APK is rebuilt.
+
+```kt
+execute {
+    delete("res/values/strings.xml")
+}
+```
+
+#### 📃 `document(String)`  and  `document(InputStream)`
+
+The `document` function is used to read and write DOM files.
+
+```kt
+execute {
+    document("res/values/strings.xml").use { document ->
+        val element = doc.createElement("string").apply {
+            textContent = "Hello, World!"
+        }
+        document.documentElement.appendChild(element)
+    }
+}
+```
+
+You can also read documents from an `InputStream`:
+
+```kt
+execute {
+    val inputStream = classLoader.getResourceAsStream("some.xml")
+    document(inputStream).use { document ->
+        // ...
+    }
+}
+```

 ## 🎉 Afterword

-ReVanced Patcher is a powerful library to patch Android applications, offering a rich set of APIs to develop patches that outlive app updates. Patches make up ReVanced; without you, the community of patch developers, ReVanced would not be what it is today. We hope that this documentation has been helpful to you and are excited to see what you will create with ReVanced Patcher. If you have any questions or need help, talk to us on one of our platforms linked on [revanced.app](https://revanced.app) or open an issue in case of a bug or feature request,  
+ReVanced Patcher is a powerful library to patch Android applications, offering a rich set of APIs to develop patches
+that outlive app updates. Patches make up ReVanced; without you, the community of patch developers,
+ReVanced would not be what it is today. We hope that this documentation has been helpful to you
+and are excited to see what you will create with ReVanced Patcher. If you have any questions or need help,
+talk to us on one of our platforms linked on [revanced.app](https://revanced.app) or open an issue in case of a bug or
+feature request,  
 ReVanced
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,3 +1,11 @@
-org.gradle.parallel = true
-org.gradle.caching = true
-version = 19.3.1
+version = 22.0.0-local
+#Kotlin
+kotlin.code.style=official
+kotlin.daemon.jvmargs=-Xmx3072M
+#Gradle
+org.gradle.jvmargs=-Xmx2048M -Dfile.encoding=UTF-8 -Dkotlin.daemon.jvm.options\="-Xmx2048M"
+org.gradle.caching=true
+org.gradle.configuration-cache=true
+#Android
+android.nonTransitiveRClass=true
+android.useAndroidX=true
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,23 +1,28 @@
+
 [versions]
-android = "4.1.1.4"
-apktool-lib = "2.9.3"
-kotlin = "1.9.22"
-kotlinx-coroutines-core = "1.7.3"
+agp = "8.12.3"
+android-compileSdk = "36"
+android-minSdk = "26"
+kotlin = "2.3.0"
+apktool-lib = "2.10.1.1"
+mockk = "1.14.7"
 multidexlib2 = "3.0.3.r3"
-smali = "3.0.4"
-binary-compatibility-validator = "0.14.0"
+# Tracking https://github.com/google/smali/issues/64.
+#noinspection GradleDependency
+smali = "3.0.9"
 xpp3 = "1.1.4c"
+vanniktechMavenPublish = "0.35.0"

 [libraries]
-android = { module = "com.google.android:android", version.ref = "android" }
-kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
 apktool-lib = { module = "app.revanced:apktool-lib", version.ref = "apktool-lib" }
+kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
-kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines-core" }
+mockk = { module = "io.mockk:mockk", version.ref = "mockk" }
 multidexlib2 = { module = "app.revanced:multidexlib2", version.ref = "multidexlib2" }
 smali = { module = "com.android.tools.smali:smali", version.ref = "smali" }
 xpp3 = { module = "xpp3:xpp3", version.ref = "xpp3" }

 [plugins]
-binary-compatibility-validator = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version.ref = "binary-compatibility-validator" }
-kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+android-kotlin-multiplatform-library = { id = "com.android.kotlin.multiplatform.library", version.ref = "agp" }
+kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+vanniktech-mavenPublish = { id = "com.vanniktech.maven.publish", version.ref = "vanniktechMavenPublish" }
--- a/gradle/wrapper/gradle-wrapper.jar
+++ b/gradle/wrapper/gradle-wrapper.jar
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
-distributionSha256Sum=9631d53cf3e74bfa726893aee1f8994fee4e060c401335946dba2156f440f24c
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dist
+zipStorePath=wrapper/dists
--- a/28
+++ b/28
@@ -1,7 +1,7 @@
 #!/bin/sh

 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#

 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -83,7 +85,8 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit

 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -111,7 +114,6 @@ case "$( uname )" in                #(
  NONSTOP* )        nonstop=true ;;
 esac

-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar


 # Determine the Java command to use to start the JVM.
@@ -144,7 +146,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
    case $MAX_FD in #(
      max*)
        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
        MAX_FD=$( ulimit -H -n ) ||
            warn "Could not query maximum file descriptor limit"
    esac
@@ -152,7 +154,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
      '' | soft) :;; #(
      *)
        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
        ulimit -n "$MAX_FD" ||
            warn "Could not set maximum file descriptor limit to $MAX_FD"
    esac
@@ -169,7 +171,6 @@ fi
 # For Cygwin or MSYS, switch paths to Windows format before running java
 if "$cygwin" || "$msys" ; then
    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )

    JAVACMD=$( cygpath --unix "$JAVACMD" )

@@ -201,16 +202,15 @@ fi
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'

-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.

 set -- \
        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
        "$@"

 # Stop when "xargs" is not available.
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -13,6 +13,8 @@
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem

@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
@@ -43,11 +45,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute

-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2

 goto fail

@@ -57,22 +59,21 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe

 if exist "%JAVA_EXE%" goto execute

-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2

 goto fail

 :execute
@rem Setup the command line

-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar


@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*

 :end
@rem End local scope for the variables with windows NT shell
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
    "@saithodev/semantic-release-backmerge": "^4.0.1",
    "@semantic-release/changelog": "^6.0.3",
    "@semantic-release/git": "^10.0.1",
-    "gradle-semantic-release-plugin": "^1.9.1",
-    "semantic-release": "^23.0.0"
+    "gradle-semantic-release-plugin": "^1.10.1",
+    "semantic-release": "^24.2.9"
  }
 }
--- a/patcher/api/android/core.api
+++ b/patcher/api/android/core.api
--- a/patcher/api/android/patcher.api
+++ b/patcher/api/android/patcher.api
--- a/patcher/api/jvm/core.api
+++ b/patcher/api/jvm/core.api
--- a/patcher/api/jvm/patcher.api
+++ b/patcher/api/jvm/patcher.api
--- a/patcher/build.gradle.kts
+++ b/patcher/build.gradle.kts
@@ -0,0 +1,110 @@
+import com.android.build.api.dsl.androidLibrary
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.abi.ExperimentalAbiValidation
+
+plugins {
+    alias(libs.plugins.kotlinMultiplatform)
+    alias(libs.plugins.android.kotlin.multiplatform.library)
+    alias(libs.plugins.vanniktech.mavenPublish)
+}
+
+group = "app.revanced"
+
+kotlin {
+    @OptIn(ExperimentalAbiValidation::class)
+    abiValidation {
+        enabled = true
+    }
+
+    jvm()
+
+    androidLibrary {
+        namespace = "app.revanced.patcher"
+        compileSdk = libs.versions.android.compileSdk.get().toInt()
+        minSdk = libs.versions.android.minSdk.get().toInt()
+
+        withHostTestBuilder {}.configure {}
+        withDeviceTestBuilder {
+            sourceSetTreeName = "test"
+        }
+
+        compilations.configureEach {
+            compilerOptions.configure {
+                jvmTarget.set(
+                    JvmTarget.JVM_11
+                )
+            }
+        }
+    }
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(libs.apktool.lib)
+            implementation(libs.kotlin.reflect)
+            implementation(libs.multidexlib2)
+            implementation(libs.smali)
+            implementation(libs.xpp3)
+        }
+
+        jvmTest.dependencies {
+            implementation(libs.mockk)
+            implementation(libs.kotlin.test)
+        }
+    }
+
+    compilerOptions {
+        freeCompilerArgs.addAll(
+            "-Xexplicit-backing-fields",
+            "-Xcontext-parameters"
+        )
+    }
+}
+
+tasks {
+    named<Test>("jvmTest") {
+        useJUnitPlatform()
+    }
+}
+
+mavenPublishing {
+    publishing {
+        repositories {
+            maven {
+                name = "githubPackages"
+                url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
+                credentials(PasswordCredentials::class)
+            }
+        }
+    }
+
+    signAllPublications()
+    extensions.getByType<SigningExtension>().useGpgCmd()
+
+    coordinates(group.toString(), project.name, version.toString())
+
+    pom {
+        name = "ReVanced Patcher"
+        description = "Patcher used by ReVanced."
+        inceptionYear = "2022"
+        url = "https://revanced.app"
+        licenses {
+            license {
+                name = "GNU General Public License v3.0"
+                url = "https://www.gnu.org/licenses/gpl-3.0.en.html"
+            }
+        }
+        developers {
+            developer {
+                id = "ReVanced"
+                name = "ReVanced"
+                email = "contact@revanced.app"
+            }
+        }
+        scm {
+            connection = "scm:git:git://github.com/revanced/revanced-patcher.git"
+            developerConnection = "scm:git:git@github.com:revanced/revanced-patcher.git"
+            url = "https://github.com/revanced/revanced-patcher"
+        }
+    }
+}
+
--- a/patcher/src/androidMain/kotlin/app/revanced/patcher/patch/Patch.android.kt
+++ b/patcher/src/androidMain/kotlin/app/revanced/patcher/patch/Patch.android.kt
@@ -0,0 +1,39 @@
+package app.revanced.patcher.patch
+
+import dalvik.system.DexClassLoader
+import lanchon.multidexlib2.BasicDexFileNamer
+import lanchon.multidexlib2.MultiDexIO
+import java.io.File
+
+actual val Class<*>.isPatch get() = Patch::class.java.isAssignableFrom(this)
+
+/**
+ * Loads patches from DEX files declared as public static fields
+ * or returned by public static and non-parametrized methods.
+ * Patches with no name are not loaded. If a patches file fails to load,
+ * the [onFailedToLoad] callback is invoked with the file and the throwable
+ * and the loading continues for the other files.
+ *
+ * @param patchesFiles The DEX files to load the patches from.
+ * @param onFailedToLoad A callback invoked when a patches file fails to load.
+ *
+ * @return The loaded patches.
+ */
+actual fun loadPatches(
+    vararg patchesFiles: File,
+    onFailedToLoad: (patchesFile: File, throwable: Throwable) -> Unit,
+) = loadPatches(
+    patchesFiles = patchesFiles,
+    { patchBundle ->
+        MultiDexIO.readDexFile(true, patchBundle, BasicDexFileNamer(), null, null).classes
+            .map { classDef ->
+                classDef.type.substring(1, classDef.length - 1)
+            }
+    },
+    DexClassLoader(
+        patchesFiles.joinToString(File.pathSeparator) { it.absolutePath },
+        null,
+        null, null
+    ),
+    onFailedToLoad
+)
--- a/patcher/src/androidMain/kotlin/collections/MutableMap.android.kt
+++ b/patcher/src/androidMain/kotlin/collections/MutableMap.android.kt
@@ -0,0 +1,7 @@
+package collections
+
+actual fun <K, V> MutableMap<K, V>.kmpMerge(
+    key: K,
+    value: V,
+    remappingFunction: (oldValue: V, newValue: V) -> V
+) = merge(key, value, remappingFunction)
--- a/patcher/src/androidMain/kotlin/java/io/File.android.kt
+++ b/patcher/src/androidMain/kotlin/java/io/File.android.kt
@@ -0,0 +1,8 @@
+package java.io
+
+import java.nio.charset.Charset
+
+internal actual fun File.kmpResolve(child: String) = resolve(child)
+internal actual fun File.kmpDeleteRecursively() = deleteRecursively()
+internal actual fun File.kmpInputStream() = inputStream()
+internal actual fun File.kmpBufferedWriter(charset: Charset) = bufferedWriter(charset)
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/Fingerprint.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/Fingerprint.kt
@@ -0,0 +1,363 @@
+@file:Suppress("unused", "MemberVisibilityCanBePrivate")
+
+package app.revanced.patcher
+
+import app.revanced.patcher.extensions.instructionsOrNull
+import app.revanced.patcher.patch.BytecodePatchContext
+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.ReferenceInstruction
+import com.android.tools.smali.dexlib2.iface.reference.StringReference
+import com.android.tools.smali.dexlib2.util.MethodUtil
+
+@Deprecated("Use the matcher API instead.")
+class Fingerprint internal constructor(
+    internal val accessFlags: Int?,
+    internal val returnType: String?,
+    internal val parameters: List<String>?,
+    internal val opcodes: List<Opcode?>?,
+    internal val strings: List<String>?,
+    internal val custom: ((method: Method, classDef: ClassDef) -> Boolean)?,
+    private val fuzzyPatternScanThreshold: Int,
+) {
+    @Suppress("ktlint:standard:backing-property-naming")
+    // Backing field needed for lazy initialization.
+    private var _matchOrNull: FingerprintMatch? = null
+
+    context(_: BytecodePatchContext)
+    private val matchOrNull: FingerprintMatch?
+        get() = matchOrNull()
+
+    context(context: BytecodePatchContext)
+    internal fun matchOrNull(): FingerprintMatch? {
+        if (_matchOrNull != null) return _matchOrNull
+
+        var match = strings?.mapNotNull {
+            context.classDefs.methodsByString[it]
+        }?.minByOrNull { it.size }?.let { methodClasses ->
+            methodClasses.forEach { method ->
+                val match = matchOrNull(method, context.classDefs[method.definingClass]!!)
+                if (match != null) return@let match
+            }
+
+            null
+        }
+        if (match != null) return match
+        context.classDefs.forEach { classDef ->
+            match = matchOrNull(classDef)
+            if (match != null) return match
+        }
+
+        return null
+    }
+
+    context(_: BytecodePatchContext)
+    fun matchOrNull(
+        classDef: ClassDef,
+    ): FingerprintMatch? {
+        if (_matchOrNull != null) return _matchOrNull
+
+        for (method in classDef.methods) {
+            val match = matchOrNull(method, classDef)
+            if (match != null) return match
+        }
+
+        return null
+    }
+
+    context(context: BytecodePatchContext)
+    fun matchOrNull(
+        method: Method,
+    ) = matchOrNull(method, context.classDefs[method.definingClass]!!)
+
+    context(context: BytecodePatchContext)
+    fun matchOrNull(
+        method: Method,
+        classDef: ClassDef,
+    ): FingerprintMatch? {
+        if (_matchOrNull != null) return _matchOrNull
+
+        if (returnType != null && !method.returnType.startsWith(returnType)) {
+            return null
+        }
+
+        if (accessFlags != null && accessFlags != method.accessFlags) {
+            return null
+        }
+
+        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
+        }
+
+        // TODO: parseParameters()
+        if (parameters != null && !parametersEqual(parameters, method.parameterTypes)) {
+            return null
+        }
+
+        if (custom != null && !custom.invoke(method, classDef)) {
+            return null
+        }
+
+        val stringMatches: List<FingerprintMatch.StringMatch>? =
+            if (strings != null) {
+                buildList {
+                    val instructions = method.instructionsOrNull ?: return null
+
+                    val stringsList = strings.toMutableList()
+
+                    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(FingerprintMatch.StringMatch(string, instructionIndex))
+                        stringsList.removeAt(index)
+                    }
+
+                    if (stringsList.isNotEmpty()) return null
+                }
+            } else {
+                null
+            }
+
+        val patternMatch = if (opcodes != null) {
+            val instructions = method.instructionsOrNull ?: return null
+
+            fun patternScan(): FingerprintMatch.PatternMatch? {
+                val fingerprintFuzzyPatternScanThreshold = fuzzyPatternScanThreshold
+
+                val instructionLength = instructions.count()
+                val patternLength = opcodes.size
+
+                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 = opcodes.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 entire pattern has been scanned.
+                        return FingerprintMatch.PatternMatch(
+                            index,
+                            index + patternIndex,
+                        )
+                    }
+                }
+
+                return null
+            }
+
+            patternScan() ?: return null
+        } else {
+            null
+        }
+
+        _matchOrNull = FingerprintMatch(
+            context,
+            classDef,
+            method,
+            patternMatch,
+            stringMatches,
+        )
+
+        return _matchOrNull
+    }
+
+    private val exception get() = PatchException("Failed to match the fingerprint: $this")
+
+    context(_: BytecodePatchContext)
+    private val match
+        get() = matchOrNull ?: throw exception
+
+    context(_: BytecodePatchContext)
+    fun match(
+        classDef: ClassDef,
+    ) = matchOrNull(classDef) ?: throw exception
+
+    context(_: BytecodePatchContext)
+    fun match(
+        method: Method,
+    ) = matchOrNull(method) ?: throw exception
+
+    context(_: BytecodePatchContext)
+    fun match(
+        method: Method,
+        classDef: ClassDef,
+    ) = matchOrNull(method, classDef) ?: throw exception
+
+    context(_: BytecodePatchContext)
+    val originalClassDefOrNull
+        get() = matchOrNull?.originalClassDef
+
+    context(_: BytecodePatchContext)
+    val originalMethodOrNull
+        get() = matchOrNull?.originalMethod
+
+    context(_: BytecodePatchContext)
+    val classDefOrNull
+        get() = matchOrNull?.classDef
+
+    context(_: BytecodePatchContext)
+    val methodOrNull
+        get() = matchOrNull?.method
+
+    context(_: BytecodePatchContext)
+    val patternMatchOrNull
+        get() = matchOrNull?.patternMatch
+
+    context(_: BytecodePatchContext)
+    val stringMatchesOrNull
+        get() = matchOrNull?.stringMatches
+
+    context(_: BytecodePatchContext)
+    val originalClassDef
+        get() = match.originalClassDef
+
+    context(_: BytecodePatchContext)
+    val originalMethod
+        get() = match.originalMethod
+
+    context(_: BytecodePatchContext)
+    val classDef
+        get() = match.classDef
+
+    context(_: BytecodePatchContext)
+    val method
+        get() = match.method
+
+    context(_: BytecodePatchContext)
+    val patternMatch
+        get() = match.patternMatch
+
+    context(_: BytecodePatchContext)
+    val stringMatches
+        get() = match.stringMatches
+}
+
+@Deprecated("Use the matcher API instead.")
+class FingerprintMatch internal constructor(
+    val context: BytecodePatchContext,
+    val originalClassDef: ClassDef,
+    val originalMethod: Method,
+    val patternMatch: PatternMatch?,
+    val stringMatches: List<StringMatch>?,
+) {
+
+    val classDef by lazy {
+        val classDef = context.classDefs[originalClassDef.type]!!
+
+        context.classDefs.getOrReplaceMutable(classDef)
+    }
+
+    val method by lazy { classDef.methods.first { MethodUtil.methodSignaturesMatch(it, originalMethod) } }
+
+    class PatternMatch internal constructor(
+        val startIndex: Int,
+        val endIndex: Int,
+    )
+
+    class StringMatch internal constructor(val string: String, val index: Int)
+}
+
+@Deprecated("Use the matcher API instead.")
+class FingerprintBuilder internal constructor(
+    private val fuzzyPatternScanThreshold: Int = 0,
+) {
+    private var accessFlags: Int? = null
+    private var returnType: String? = null
+    private var parameters: List<String>? = null
+    private var opcodes: List<Opcode?>? = null
+    private var strings: List<String>? = null
+    private var customBlock: ((method: Method, classDef: ClassDef) -> Boolean)? = null
+
+    fun accessFlags(accessFlags: Int) {
+        this.accessFlags = accessFlags
+    }
+
+    fun accessFlags(vararg accessFlags: AccessFlags) {
+        this.accessFlags = accessFlags.fold(0) { acc, it -> acc or it.value }
+    }
+
+    fun returns(returnType: String) {
+        this.returnType = returnType
+    }
+
+    fun parameters(vararg parameters: String) {
+        this.parameters = parameters.toList()
+    }
+
+    fun opcodes(vararg opcodes: Opcode?) {
+        this.opcodes = opcodes.toList()
+    }
+
+    fun opcodes(instructions: String) {
+        this.opcodes = instructions.trimIndent().split("\n").filter {
+            it.isNotBlank()
+        }.map {
+            // Remove any operands.
+            val name = it.split(" ", limit = 1).first().trim()
+            if (name == "null") return@map null
+
+            opcodesByName[name] ?: throw Exception("Unknown opcode: $name")
+        }
+    }
+
+    fun strings(vararg strings: String) {
+        this.strings = strings.toList()
+    }
+
+    fun custom(customBlock: (method: Method, classDef: ClassDef) -> Boolean) {
+        this.customBlock = customBlock
+    }
+
+    internal fun build() = Fingerprint(
+        accessFlags,
+        returnType,
+        parameters,
+        opcodes,
+        strings,
+        customBlock,
+        fuzzyPatternScanThreshold,
+    )
+
+    private companion object {
+        val opcodesByName = Opcode.entries.associateBy { it.name }
+    }
+}
+
+@Deprecated("Use the matcher API instead.")
+fun fingerprint(
+    fuzzyPatternScanThreshold: Int = 0,
+    block: FingerprintBuilder.() -> Unit,
+) = FingerprintBuilder(fuzzyPatternScanThreshold).apply(block).build()
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/Matching.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/Matching.kt
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/Patching.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/Patching.kt
@@ -0,0 +1,152 @@
+package app.revanced.patcher
+
+import app.revanced.patcher.patch.*
+import java.io.File
+import java.io.InputStream
+import java.io.deleteRecursively
+import java.io.resolve
+import java.util.logging.Logger
+
+fun patcher(
+    apkFile: File,
+    temporaryFilesPath: File = File("revanced-patcher-temporary-files"),
+    aaptBinaryPath: File? = null,
+    frameworkFileDirectory: String? = null,
+    getPatches: (packageName: String, versionName: String) -> Set<Patch>,
+): (emit: (PatchResult) -> Unit) -> PatchesResult {
+    val logger = Logger.getLogger("Patcher")
+
+    if (temporaryFilesPath.exists()) {
+        logger.info("Deleting existing temporary files directory")
+
+        if (!temporaryFilesPath.deleteRecursively())
+            logger.severe("Failed to delete existing temporary files directory")
+    }
+
+    val apkFilesPath = temporaryFilesPath.resolve("apk").also { it.mkdirs() }
+    val patchedFilesPath = temporaryFilesPath.resolve("patched").also { it.mkdirs() }
+
+    val resourcePatchContext = ResourcePatchContext(
+        apkFile,
+        apkFilesPath,
+        patchedFilesPath,
+        aaptBinaryPath,
+        frameworkFileDirectory
+    )
+
+    val (packageName, versionName) = resourcePatchContext.decodeManifest()
+    val patches = getPatches(packageName, versionName)
+
+    return { emit: (PatchResult) -> Unit ->
+        if (patches.any { patch -> patch.patchesResources }) resourcePatchContext.decodeResources()
+
+        // After initializing the resource context, to keep memory usage time low.
+        val bytecodePatchContext = BytecodePatchContext(
+            apkFile,
+            patchedFilesPath
+        )
+
+        logger.info("Warming up the cache")
+
+        bytecodePatchContext.classDefs.initializeCache()
+
+        logger.info("Applying patches")
+
+        patches.apply(bytecodePatchContext, resourcePatchContext, emit)
+    }
+}
+
+// Public for testing.
+fun Set<Patch>.apply(
+    bytecodePatchContext: BytecodePatchContext,
+    resourcePatchContext: ResourcePatchContext,
+    emit: (PatchResult) -> Unit
+): PatchesResult {
+    val appliedPatches = LinkedHashMap<Patch, PatchResult>()
+
+    sortedBy { it.name }.forEach { patch ->
+        fun Patch.apply(): PatchResult {
+            val result = appliedPatches[this]
+
+            return if (result == null) {
+                val failedDependency = dependencies.asSequence().map { it.apply() }.firstOrNull { it.exception != null }
+                if (failedDependency != null) return patchResult(
+                    "The dependant patch \"$failedDependency\" of the patch \"$this\" raised an exception:\n" +
+                            failedDependency.exception!!.stackTraceToString(),
+                )
+
+                val exception = runCatching { apply(bytecodePatchContext, resourcePatchContext) }
+                    .exceptionOrNull() as? Exception
+
+                patchResult(exception).also { result -> appliedPatches[this] = result }
+            } else if (result.exception == null) result
+            else patchResult("The patch '$this' has failed previously")
+        }
+
+        val patchResult = patch.apply()
+
+        // If an exception occurred or the patch has no finalize block, emit the result.
+        if (patchResult.exception != null || patch.afterDependents == null) {
+            emit(patchResult)
+        }
+    }
+
+    val succeededPatchesWithFinalizeBlock = appliedPatches.values.filter {
+        it.exception == null && it.patch.afterDependents != null
+    }
+
+    succeededPatchesWithFinalizeBlock.asReversed().forEach { result ->
+        val patch = result.patch
+        runCatching { patch.afterDependents!!.invoke(bytecodePatchContext, resourcePatchContext) }.fold(
+            { emit(result) },
+            {
+                emit(
+                    PatchResult(
+                        patch,
+                        PatchException(
+                            "The patch \"$patch\" raised an exception:\n" + it.stackTraceToString(),
+                            it,
+                        ),
+                    )
+                )
+            }
+        )
+    }
+
+    return PatchesResult(bytecodePatchContext.get(), resourcePatchContext.get())
+}
+
+/**
+ * The result of applying patches.
+ *
+ * @param dexFiles The patched dex files.
+ * @param resources The patched resources.
+ */
+class PatchesResult internal constructor(
+    val dexFiles: Set<PatchedDexFile>,
+    val resources: PatchedResources?,
+) {
+
+    /**
+     * A dex file.
+     *
+     * @param name The original name of the dex file.
+     * @param stream The dex file as [InputStream].
+     */
+    class PatchedDexFile internal constructor(val name: String, val stream: InputStream)
+
+    /**
+     * The resources of a patched apk.
+     *
+     * @param resourcesApk The compiled resources.apk file.
+     * @param otherResources The directory containing other resources files.
+     * @param doNotCompress List of files that should not be compressed.
+     * @param deleteResources List of resources that should be deleted.
+     */
+    class PatchedResources internal constructor(
+        val resourcesApk: File?,
+        val otherResources: File?,
+        val doNotCompress: Set<String>,
+        val deleteResources: Set<String>,
+    )
+}
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/extensions/Instruction.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/extensions/Instruction.kt
@@ -0,0 +1,115 @@
+package app.revanced.patcher.extensions
+
+import com.android.tools.smali.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.Opcodes
+import com.android.tools.smali.dexlib2.builder.BuilderInstruction
+import com.android.tools.smali.dexlib2.iface.instruction.Instruction
+import com.android.tools.smali.dexlib2.iface.instruction.NarrowLiteralInstruction
+import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
+import com.android.tools.smali.dexlib2.iface.reference.*
+import com.android.tools.smali.dexlib2.writer.builder.DexBuilder
+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.StringReader
+
+
+private inline fun <reified T : Reference> Instruction.reference(): T? =
+    (this as? ReferenceInstruction)?.reference as? T
+
+val Instruction.reference: Reference?
+    get() = reference()
+
+val Instruction.methodReference
+    get() = reference<MethodReference>()
+
+val Instruction.fieldReference
+    get() = reference<FieldReference>()
+
+val Instruction.typeReference
+    get() = reference<TypeReference>()
+
+val Instruction.stringReference
+    get() = reference<StringReference>()
+
+/** TODO: This is technically missing for consistency:
+
+private inline fun <reified T : Reference> Instruction.reference2(): T? =
+(this as? DualReferenceInstruction)?.reference2 as? T
+
+val Instruction.reference2: Reference?
+get() = reference2()
+
+val Instruction.methodReference2
+get() = reference2<MethodReference>()
+
+val Instruction.fieldReference2
+get() = reference2<FieldReference>()
+
+val Instruction.typeReference2
+get() = reference2<TypeReference>()
+
+val Instruction.stringReference2
+get() = reference2<StringReference>()
+ **/
+
+val Instruction.type
+    get() = typeReference?.type
+
+val Instruction.string
+    get() = stringReference?.string
+val Instruction.wideLiteral
+    get() = (this as? NarrowLiteralInstruction)?.wideLiteral
+
+
+private const val CLASS_HEADER = ".class LInlineCompiler;\n.super Ljava/lang/Object;\n"
+private const val STATIC_HEADER = "$CLASS_HEADER.method public static dummyMethod("
+private const val HEADER = "$CLASS_HEADER.method public dummyMethod("
+private val sb by lazy { StringBuilder(512) }
+
+/**
+ * Compile lines of Smali code to a list of instructions.
+ *
+ * Note: Adding compiled instructions to an existing method with
+ * offset instructions WITHOUT specifying a parent method will not work.
+ * @param templateMethod The method to compile the instructions against.
+ * @returns A list of instructions.
+ */
+fun String.toInstructions(templateMethod: com.android.tools.smali.dexlib2.mutable.MutableMethod? = null): List<BuilderInstruction> {
+    val parameters = templateMethod?.parameterTypes?.joinToString("") { it } ?: ""
+    val registers = templateMethod?.implementation?.registerCount ?: 1 // TODO: Should this be 0?
+    val isStatic = templateMethod?.let { AccessFlags.STATIC.isSet(it.accessFlags) } ?: true
+
+    sb.setLength(0) // reset
+
+    if (isStatic) sb.append(STATIC_HEADER) else sb.append(HEADER)
+    sb.append(parameters).append(")V\n")
+    sb.append("    .registers ").append(registers).append("\n")
+    sb.append(trimIndent()).append("\n")
+    sb.append(".end method")
+
+    val reader = StringReader(sb.toString())
+    val lexer = smaliFlexLexer(reader, 15)
+    val tokens = CommonTokenStream(lexer as TokenSource)
+    val parser = smaliParser(tokens)
+    val fileTree = parser.smali_file()
+
+    if (lexer.numberOfSyntaxErrors > 0 || parser.numberOfSyntaxErrors > 0) {
+        throw IllegalStateException(
+            "Lexer errors: ${lexer.numberOfSyntaxErrors}, Parser errors: ${parser.numberOfSyntaxErrors}"
+        )
+    }
+
+    val treeStream = CommonTreeNodeStream(fileTree.tree).apply {
+        tokenStream = tokens
+    }
+
+    val walker = smaliTreeWalker(treeStream)
+    walker.setDexBuilder(DexBuilder(Opcodes.getDefault()))
+
+    val classDef = walker.smali_file()
+    return classDef.methods.first().instructions.map { it as BuilderInstruction }
+}
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/extensions/Method.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/extensions/Method.kt
@@ -0,0 +1,446 @@
+package app.revanced.patcher.extensions
+
+import com.android.tools.smali.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.builder.BuilderInstruction
+import com.android.tools.smali.dexlib2.builder.BuilderOffsetInstruction
+import com.android.tools.smali.dexlib2.builder.Label
+import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
+import com.android.tools.smali.dexlib2.builder.instruction.*
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.iface.MethodImplementation
+import com.android.tools.smali.dexlib2.iface.instruction.Instruction
+import com.android.tools.smali.dexlib2.mutable.MutableMethod
+
+fun Method.accessFlags(vararg flags: AccessFlags) =
+    accessFlags.and(flags.map { it.ordinal }.reduce { acc, i -> acc or i }) != 0
+
+/**
+ * Add instructions to a method at the given index.
+ *
+ * @param index The index to add the instructions at.
+ * @param instructions The instructions to add.
+ */
+fun MutableMethodImplementation.addInstructions(
+    index: Int,
+    instructions: List<BuilderInstruction>,
+) = instructions.asReversed().forEach { addInstruction(index, it) }
+
+/**
+ * Add instructions to a method.
+ * The instructions will be added at the end of the method.
+ *
+ * @param instructions The instructions to add.
+ */
+fun MutableMethodImplementation.addInstructions(instructions: List<BuilderInstruction>) =
+    instructions.forEach { addInstruction(it) }
+
+/**
+ * Remove instructions from a method at the given index.
+ *
+ * @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) {
+    removeInstruction(index)
+}
+
+/**
+ * Remove the first instructions from a method.
+ *
+ * @param count The amount of instructions to remove.
+ */
+fun MutableMethodImplementation.removeInstructions(count: Int) = removeInstructions(0, count)
+
+/**
+ * Replace instructions at the given index with the given instructions.
+ * The amount of instructions to replace is the amount of instructions in the given list.
+ *
+ * @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>,
+) = instructions.forEachIndexed { i, instruction -> replaceInstruction(index + i, instruction) }
+
+/**
+ * Add an instruction to a method at the given index.
+ *
+ * @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)
+
+/**
+ * Add an instruction to a method.
+ *
+ * @param instruction The instructions to add.
+ */
+fun MutableMethod.addInstruction(instruction: BuilderInstruction) = implementation!!.addInstruction(instruction)
+
+/**
+ * Add an instruction to a method at the given index.
+ *
+ * @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.toInstructions(this).first())
+
+/**
+ * Add an instruction to a method.
+ *
+ * @param smaliInstructions The instruction to add.
+ */
+fun MutableMethod.addInstruction(smaliInstructions: String) =
+    implementation!!.addInstruction(smaliInstructions.toInstructions(this).first())
+
+/**
+ * Add instructions to a method at the given index.
+ *
+ * @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)
+
+/**
+ * Add instructions to a method.
+ *
+ * @param instructions The instructions to add.
+ */
+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))
+
+/**
+ * Add instructions to a method.
+ *
+ * @param smaliInstructions The instructions to add.
+ */
+fun MutableMethod.addInstructions(smaliInstructions: String) =
+    implementation!!.addInstructions(smaliInstructions.toInstructions(this))
+
+/**
+ * Add instructions to a method at the given index.
+ *
+ * @param index The index to add the instructions at.
+ * @param smaliInstructions The instructions to add.
+ * @param externalLabels A list of [ExternalLabel] for instructions outside of [smaliInstructions].
+ */
+// Special function for adding instructions with external labels.
+fun MutableMethod.addInstructionsWithLabels(
+    index: Int,
+    smaliInstructions: String,
+    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()
+
+    // Compile the instructions with the dummy labels
+    val compiledInstructions = nopSmali.toInstructions(this)
+
+    // Add the compiled list of instructions to the method.
+    addInstructions(
+        index,
+        compiledInstructions.subList(0, compiledInstructions.size - externalLabels.size),
+    )
+
+    implementation!!.apply {
+        this@apply.instructions.subList(index, index + compiledInstructions.size - externalLabels.size)
+            .forEachIndexed { compiledInstructionIndex, compiledInstruction ->
+                // If the compiled instruction is not an offset instruction, skip it.
+                if (compiledInstruction !is BuilderOffsetInstruction) return@forEachIndexed
+
+                /**
+                 * Create a new label for the instruction
+                 * and replace it with the label of the [compiledInstruction] at [compiledInstructionIndex].
+                 */
+                fun Instruction.makeNewLabel() {
+                    fun replaceOffset(
+                        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 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!",
+                            )
+                        }
+                    }
+
+                    // Create the final label.
+                    val label = newLabelForIndex(this@apply.instructions.indexOf(this))
+
+                    // Create the final instruction with the new label.
+                    val newInstruction =
+                        replaceOffset(
+                            compiledInstruction,
+                            label,
+                        )
+
+                    // Replace the instruction pointing to the dummy label
+                    // with the new instruction pointing to the real instruction.
+                    replaceInstruction(index + compiledInstructionIndex, newInstruction)
+                }
+
+                // If the compiled instruction targets its own instruction,
+                // which means it points to some of its own, simply an offset has to be applied.
+                val labelIndex = compiledInstruction.target.location.index
+                if (labelIndex < compiledInstructions.size - externalLabels.size) {
+                    // Get the targets index (insertion index + the index of the dummy instruction).
+                    this.instructions[index + labelIndex].makeNewLabel()
+                    return@forEachIndexed
+                }
+
+                // Since the compiled instruction points to a dummy instruction,
+                // we can find the real instruction which it was created for by calculation.
+
+                // Get the index of the instruction in the externalLabels list
+                // which the dummy instruction was created for.
+                // This works because we created the dummy instructions in the same order as the externalLabels list.
+                val (_, instruction) = externalLabels[(compiledInstructions.size - 1) - labelIndex]
+                instruction.makeNewLabel()
+            }
+    }
+}
+
+/**
+ * Remove an instruction at the given index.
+ *
+ * @param index The index to remove the instruction at.
+ */
+fun MutableMethod.removeInstruction(index: Int) = implementation!!.removeInstruction(index)
+
+/**
+ * Remove instructions at the given index.
+ *
+ * @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)
+
+/**
+ * Remove instructions at the given index.
+ *
+ * @param count The amount of instructions to remove.
+ */
+fun MutableMethod.removeInstructions(count: Int) = implementation!!.removeInstructions(count)
+
+/**
+ * Replace an instruction at the given index.
+ *
+ * @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)
+
+/**
+ * Replace an instruction at the given index.
+ *
+ * @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.toInstructions(this).first())
+
+/**
+ * Replace instructions at the given index.
+ *
+ * @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)
+
+/**
+ * Replace instructions at the given index.
+ *
+ * @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))
+
+/**
+ * Get an instruction at the given index.
+ *
+ * @param index The index to get the instruction at.
+ * @return The instruction.
+ */
+fun MethodImplementation.getInstruction(index: Int) = instructions.elementAt(index)
+
+/**
+ * Get an instruction at the given index.
+ *
+ * @param index The index to get the instruction at.
+ * @param T The type of instruction to return.
+ * @return The instruction.
+ */
+@Suppress("UNCHECKED_CAST")
+fun <T> MethodImplementation.getInstruction(index: Int): T = getInstruction(index) as T
+
+/**
+ * Get an instruction at the given index.
+ *
+ * @param index The index to get the instruction at.
+ * @return The instruction.
+ */
+fun MutableMethodImplementation.getInstruction(index: Int): BuilderInstruction = instructions[index]
+
+/**
+ * Get an instruction at the given index.
+ *
+ * @param index The index to get the instruction at.
+ * @param T The type of instruction to return.
+ * @return The instruction.
+ */
+@Suppress("UNCHECKED_CAST")
+fun <T> MutableMethodImplementation.getInstruction(index: Int): T = getInstruction(index) as T
+
+/**
+ * Get an instruction at the given index.
+ * @param index The index to get the instruction at.
+ * @return The instruction or null if the method has no implementation.
+ */
+fun Method.getInstructionOrNull(index: Int): Instruction? = implementation?.getInstruction(index)
+
+/**
+ * Get an instruction at the given index.
+ * @param index The index to get the instruction at.
+ * @return The instruction.
+ */
+fun Method.getInstruction(index: Int): Instruction = getInstructionOrNull(index)!!
+
+/**
+ * Get an instruction at the given index.
+ * @param index The index to get the instruction at.
+ * @param T The type of instruction to return.
+ * @return The instruction or null if the method has no implementation.
+ */
+fun <T> Method.getInstructionOrNull(index: Int): T? = implementation?.getInstruction<T>(index)
+
+/**
+ * Get an instruction at the given index.
+ * @param index The index to get the instruction at.
+ * @param T The type of instruction to return.
+ * @return The instruction.
+ */
+fun <T> Method.getInstruction(index: Int): T = getInstructionOrNull<T>(index)!!
+
+/**
+ * Get an instruction at the given index.
+ * @param index The index to get the instruction at.
+ * @return The instruction or null if the method has no implementation.
+ */
+fun MutableMethod.getInstructionOrNull(index: Int): BuilderInstruction? = implementation?.getInstruction(index)
+
+/**
+ * Get an instruction at the given index.
+ * @param index The index to get the instruction at.
+ * @return The instruction.
+ */
+fun MutableMethod.getInstruction(index: Int): BuilderInstruction = getInstructionOrNull(index)!!
+
+/**
+ * Get an instruction at the given index.
+ * @param index The index to get the instruction at.
+ * @param T The type of instruction to return.
+ * @return The instruction or null if the method has no implementation.
+ */
+fun <T> MutableMethod.getInstructionOrNull(index: Int): T? = implementation?.getInstruction<T>(index)
+
+/**
+ * Get an instruction at the given index.
+ * @param index The index to get the instruction at.
+ * @param T The type of instruction to return.
+ * @return The instruction.
+ */
+fun <T> MutableMethod.getInstruction(index: Int): T = getInstructionOrNull<T>(index)!!
+
+/**
+ * The instructions of a method.
+ * @return The instructions or null if the method has no implementation.
+ */
+val Method.instructionsOrNull: Iterable<Instruction>? get() = implementation?.instructions
+
+/**
+ * The instructions of a method.
+ * @return The instructions.
+ */
+val Method.instructions: Iterable<Instruction> get() = instructionsOrNull!!
+
+/**
+ * The instructions of a method.
+ * @return The instructions or null if the method has no implementation.
+ */
+val MutableMethod.instructionsOrNull: MutableList<BuilderInstruction>? get() = implementation?.instructions
+
+/**
+ * The instructions of a method.
+ * @return The instructions.
+ */
+val MutableMethod.instructions: MutableList<BuilderInstruction> get() = instructionsOrNull!!
+
+/**
+ * Create a label for the instruction at given index.
+ *
+ * @param index The index to create the label for the instruction at.
+ * @return The label.
+ */
+fun MutableMethod.newLabel(index: Int) = implementation!!.newLabelForIndex(index)
+
+/**
+ * A class that represents a label for an instruction.
+ * @param name The label name.
+ * @param instruction The instruction that this label is for.
+ */
+data class ExternalLabel(internal val name: String, internal val instruction: Instruction)
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/patch/BytecodePatchContext.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/patch/BytecodePatchContext.kt
@@ -0,0 +1,264 @@
+package app.revanced.patcher.patch
+
+import app.revanced.patcher.PatchesResult
+import app.revanced.patcher.extensions.instructionsOrNull
+import app.revanced.patcher.extensions.string
+import app.revanced.patcher.util.ClassMerger.merge
+import app.revanced.patcher.util.MethodNavigator
+import com.android.tools.smali.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.DexFile
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.iface.reference.MethodReference
+import com.android.tools.smali.dexlib2.mutable.MutableClassDef
+import com.android.tools.smali.dexlib2.mutable.MutableClassDef.Companion.toMutable
+import lanchon.multidexlib2.BasicDexFileNamer
+import lanchon.multidexlib2.DexIO
+import lanchon.multidexlib2.MultiDexIO
+import lanchon.multidexlib2.RawDexIO
+import java.io.*
+import java.util.logging.Logger
+import kotlin.reflect.jvm.jvmName
+
+/**
+ * A context for patches containing the current state of the bytecode.
+ *
+ * @param apkFile The apk [File] to patch.
+ * @param patchedFilesPath The path to the temporary apk files directory.
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+class BytecodePatchContext internal constructor(
+    internal val apkFile: File,
+    internal val patchedFilesPath: File,
+) : PatchContext<Set<PatchesResult.PatchedDexFile>> {
+    private val logger = Logger.getLogger(this::class.jvmName)
+
+    inner class ClassDefs private constructor(
+        dexFile: DexFile,
+        private val classDefs: MutableSet<ClassDef> = dexFile.classes.toMutableSet()
+    ) :
+        MutableSet<ClassDef> by classDefs {
+        private val byType = mutableMapOf<String, ClassDef>()
+
+        operator fun get(name: String): ClassDef? = byType[name]
+
+        // Better performance according to
+        // https://github.com/LisoUseInAIKyrios/revanced-patcher/commit/9b6d95d4f414a35ed68da37b0ecd8549df1ef63a
+        private val _methodsByStrings =
+            LinkedHashMap<String, MutableSet<Method>>(2 * size, 0.5f)
+
+        val methodsByString: Map<String, Set<Method>> = _methodsByStrings
+
+        // Can have a use-case in the future:
+        // private val _methodsWithString = methodsByString.values.flatten().toMutableSet()
+        // val methodsWithString: Set<Method> = _methodsWithString
+
+        constructor() : this(
+            MultiDexIO.readDexFile(
+                true,
+                apkFile,
+                BasicDexFileNamer(),
+                null,
+                null
+            )
+        )
+
+        internal val opcodes = dexFile.opcodes
+
+        override fun add(element: ClassDef): Boolean {
+            val added = classDefs.add(element)
+            if (added) addCache(element)
+
+            return added
+        }
+
+        override fun addAll(elements: Collection<ClassDef>): Boolean {
+            var anyAdded = false
+            elements.forEach { element ->
+                val added = classDefs.add(element)
+                if (added) {
+                    addCache(element)
+                    anyAdded = true
+                }
+            }
+
+            return anyAdded
+        }
+
+        // TODO: There is one default method "removeIf" in MutableSet, which we cannot override in the common module.
+        //  The method must be overloaded with a NotImplementedException to avoid cache desynchronization.
+
+        override fun clear() {
+            classDefs.clear()
+            byType.clear()
+            _methodsByStrings.clear()
+        }
+
+        override fun remove(element: ClassDef): Boolean {
+            val removed = classDefs.remove(element)
+            if (removed) removeCache(element)
+
+            return removed
+        }
+
+        override fun removeAll(elements: Collection<ClassDef>): Boolean {
+            var anyRemoved = false
+            elements.forEach { element ->
+                val removed = classDefs.remove(element)
+                if (removed) {
+                    removeCache(element)
+                    anyRemoved = true
+                }
+            }
+
+            return anyRemoved
+        }
+
+        override fun retainAll(elements: Collection<ClassDef>) =
+            removeAll(classDefs.asSequence().filter { it !in elements })
+
+        private fun addCache(classDef: ClassDef) {
+            byType[classDef.type] = classDef
+
+            classDef.forEachString { method, string ->
+                _methodsByStrings.getOrPut(string) {
+                    // Maybe adjusting load factor/ initial size can improve performance.
+                    mutableSetOf()
+                } += method
+            }
+        }
+
+        private fun removeCache(classDef: ClassDef) {
+            byType -= classDef.type
+
+            classDef.forEachString { method, string ->
+                if (_methodsByStrings[string]?.also { it -= method }?.isEmpty() == true)
+                    _methodsByStrings -= string
+            }
+        }
+
+
+        private fun ClassDef.forEachString(action: (Method, String) -> Unit) {
+            methods.asSequence().forEach { method ->
+                method.instructionsOrNull?.asSequence()
+                    ?.mapNotNull { it.string }
+                    ?.forEach { string -> action(method, string) }
+            }
+        }
+
+        /**
+         * Get a mutable version of the given [classDef], replacing it in the set if necessary.
+         *
+         * @param classDef The [ClassDef] to get or replace.
+         * @return The mutable version of the [classDef].
+         * @see MutableClassDef
+         * @see toMutable
+         */
+        fun getOrReplaceMutable(classDef: ClassDef): MutableClassDef {
+            if (classDef !is MutableClassDef) {
+                val mutableClassDef = classDef.toMutable()
+                this -= classDef
+                this += mutableClassDef
+
+                return mutableClassDef
+            }
+
+            return classDef
+        }
+
+        internal fun initializeCache() = classDefs.forEach(::addCache)
+
+        internal fun clearCache() {
+            byType.clear()
+            _methodsByStrings.clear()
+        }
+    }
+
+    /**
+     * The list of classes.
+     */
+    val classDefs = ClassDefs()
+
+    /**
+     * Extend this [BytecodePatchContext] with [extensionInputStream].
+     *
+     * @param extensionInputStream The input stream for an extension dex file.
+     */
+    internal fun extendWith(extensionInputStream: InputStream) {
+        RawDexIO.readRawDexFile(
+            extensionInputStream, 0, null
+        ).classes.forEach { classDef ->
+            val existingClass = classDefs[classDef.type] ?: run {
+                logger.fine { "Adding class \"$classDef\"" }
+
+                classDefs += classDef
+
+                return@forEach
+            }
+
+            logger.fine { "Class \"$classDef\" exists already. Adding missing methods and fields." }
+
+            existingClass.merge(classDef, this@BytecodePatchContext).let { mergedClass ->
+                // If the class was merged, replace the original class with the merged class.
+                if (mergedClass === existingClass) {
+                    return@let
+                }
+
+                classDefs -= existingClass
+                classDefs += mergedClass
+            }
+        }
+
+        extensionInputStream.close()
+    }
+
+    /**
+     * Navigate a method.
+     *
+     * @param method The method to navigate.
+     *
+     * @return A [MethodNavigator] for the method.
+     */
+    fun navigate(method: MethodReference) = MethodNavigator(method)
+
+    /**
+     * Compile bytecode from the [BytecodePatchContext].
+     *
+     * @return The compiled bytecode.
+     */
+    override fun get(): Set<PatchesResult.PatchedDexFile> {
+        logger.info("Compiling patched dex files")
+
+        classDefs.clearCache()
+        System.gc()
+
+        val patchedDexFileResults =
+            patchedFilesPath.resolve("dex").also {
+                it.deleteRecursively() // Make sure the directory is empty.
+                it.mkdirs()
+            }.apply {
+                MultiDexIO.writeDexFile(
+                    true,
+                    -1,
+                    this,
+                    BasicDexFileNamer(),
+                    object : DexFile {
+                        override fun getClasses() = classDefs.let {
+                            // More performant according to
+                            // https://github.com/LisoUseInAIKyrios/revanced-patcher/
+                            // commit/8c26ad08457fb1565ea5794b7930da42a1c81cf1
+                            // #diff-be698366d9868784ecf7da3fd4ac9d2b335b0bb637f9f618fbe067dbd6830b8fR197
+                            // TODO: Benchmark, if actually faster.
+                            HashSet<ClassDef>(it.size * 3 / 2).apply { addAll(it) }
+                        }
+
+                        override fun getOpcodes() = classDefs.opcodes
+                    },
+                    DexIO.DEFAULT_MAX_DEX_POOL_SIZE,
+                ) { _, entryName, _ -> logger.info { "Compiled $entryName" } }
+            }.listFiles { it.isFile }!!.map {
+                PatchesResult.PatchedDexFile(it.name, it.inputStream())
+            }.toSet()
+
+        return patchedDexFileResults
+    }
+}
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/patch/Option.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/patch/Option.kt
@@ -0,0 +1,816 @@
+@file:Suppress("unused")
+
+package app.revanced.patcher.patch
+
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.jvm.jvmName
+import kotlin.reflect.typeOf
+
+/**
+ * An option.
+ *
+ * @param T The value type of the option.
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param type The type of the option value (to handle type erasure).
+ * @param validator The function to validate the option value.
+ *
+ * @constructor Create a new [Option].
+ */
+@Suppress("MemberVisibilityCanBePrivate", "unused")
+class Option<T>
+@PublishedApi
+internal constructor(
+    val name: String,
+    val default: T? = null,
+    val values: Map<String, T?>? = null,
+    val description: String? = null,
+    val required: Boolean = false,
+    val type: KType,
+    val validator: Option<T>.(T?) -> Boolean = { true },
+) {
+    /**
+     * The value of the [Option].
+     */
+    var value: T?
+        /**
+         * Set the value of the [Option].
+         *
+         * @param value The value to set.
+         *
+         * @throws OptionException.ValueRequiredException If the value is required but null.
+         * @throws OptionException.ValueValidationException If the value is invalid.
+         */
+        set(value) {
+            assertRequiredButNotNull(value)
+            assertValid(value)
+
+            uncheckedValue = value
+        }
+        /**
+         * Get the value of the [Option].
+         *
+         * @return The value.
+         *
+         * @throws OptionException.ValueRequiredException If the value is required but null.
+         * @throws OptionException.ValueValidationException If the value is invalid.
+         */
+        get() {
+            assertRequiredButNotNull(uncheckedValue)
+            assertValid(uncheckedValue)
+
+            return uncheckedValue
+        }
+
+    // The unchecked value is used to allow setting the value without validation.
+    private var uncheckedValue = default
+
+    /**
+     * Reset the [Option] to its default value.
+     * Override this method if you need to mutate the value instead of replacing it.
+     */
+    fun reset() {
+        uncheckedValue = default
+    }
+
+    private fun assertRequiredButNotNull(value: T?) {
+        if (required && value == null) throw OptionException.ValueRequiredException(this)
+    }
+
+    private fun assertValid(value: T?) {
+        if (!validator(value)) throw OptionException.ValueValidationException(value, this)
+    }
+
+    override fun toString() = value.toString()
+
+    operator fun getValue(
+        thisRef: Any?,
+        property: KProperty<*>,
+    ) = value
+
+    operator fun setValue(
+        thisRef: Any?,
+        property: KProperty<*>,
+        value: T?,
+    ) {
+        this.value = value
+    }
+}
+
+/**
+ * A collection of [Option]s where options can be set and retrieved by their key.
+ *
+ * @param options The options.
+ *
+ * @constructor Create a new [Options].
+ */
+class Options internal constructor(
+    private val options: Map<String, Option<*>>,
+) : Map<String, Option<*>> by options {
+    internal constructor(options: Set<Option<*>>) : this(options.associateBy { it.name })
+
+    /**
+     * Set an option's value.
+     *
+     * @param name The name.
+     * @param value The value.
+     *
+     * @throws OptionException.OptionNotFoundException If the option does not exist.
+     */
+    operator fun <T : Any> set(name: String, value: T?) {
+        val option = this[name]
+
+        try {
+            @Suppress("UNCHECKED_CAST")
+            (option as Option<T>).value = value
+        } catch (e: ClassCastException) {
+            throw OptionException.InvalidValueTypeException(
+                value?.let { it::class.jvmName } ?: "null",
+                option.value?.let { it::class.jvmName } ?: "null",
+            )
+        }
+    }
+
+    /**
+     * Get an option.
+     *
+     * @param key The name.
+     *
+     * @return The option.
+     */
+    override fun get(key: String) = options[key] ?: throw OptionException.OptionNotFoundException(key)
+}
+
+/**
+ * Create a new [Option] with a string value.
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun stringOption(
+    name: String,
+    default: String? = null,
+    values: Map<String, String?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<String>.(String?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a string value and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun PatchBuilder<*>.stringOption(
+    name: String,
+    default: String? = null,
+    values: Map<String, String?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<String>.(String?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with an integer value.
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun intOption(
+    name: String,
+    default: Int? = null,
+    values: Map<String, Int?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<Int>.(Int?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with an integer value and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun PatchBuilder<*>.intOption(
+    name: String,
+    default: Int? = null,
+    values: Map<String, Int?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<Int>.(Int?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a boolean value.
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun booleanOption(
+    name: String,
+    default: Boolean? = null,
+    values: Map<String, Boolean?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<Boolean>.(Boolean?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a boolean value and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun PatchBuilder<*>.booleanOption(
+    name: String,
+    default: Boolean? = null,
+    values: Map<String, Boolean?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<Boolean>.(Boolean?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a float value.
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun floatOption(
+    name: String,
+    default: Float? = null,
+    values: Map<String, Float?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<Float>.(Float?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a float value and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun PatchBuilder<*>.floatOption(
+    name: String,
+    default: Float? = null,
+    values: Map<String, Float?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<Float>.(Float?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a long value.
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun longOption(
+    name: String,
+    default: Long? = null,
+    values: Map<String, Long?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<Long>.(Long?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a long value and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun PatchBuilder<*>.longOption(
+    name: String,
+    default: Long? = null,
+    values: Map<String, Long?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<Long>.(Long?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a string list value.
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun stringsOption(
+    name: String,
+    default: List<String>? = null,
+    values: Map<String, List<String>?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<List<String>>.(List<String>?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a string list value and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun PatchBuilder<*>.stringsOption(
+    name: String,
+    default: List<String>? = null,
+    values: Map<String, List<String>?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<List<String>>.(List<String>?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with an integer list value.
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun intsOption(
+    name: String,
+    default: List<Int>? = null,
+    values: Map<String, List<Int>?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<List<Int>>.(List<Int>?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with an integer list value and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun PatchBuilder<*>.intsOption(
+    name: String,
+    default: List<Int>? = null,
+    values: Map<String, List<Int>?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<List<Int>>.(List<Int>?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a boolean list value.
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun booleansOption(
+    name: String,
+    default: List<Boolean>? = null,
+    values: Map<String, List<Boolean>?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<List<Boolean>>.(List<Boolean>?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a boolean list value and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun PatchBuilder<*>.booleansOption(
+    name: String,
+    default: List<Boolean>? = null,
+    values: Map<String, List<Boolean>?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<List<Boolean>>.(List<Boolean>?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a float list value and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun PatchBuilder<*>.floatsOption(
+    name: String,
+    default: List<Float>? = null,
+    values: Map<String, List<Float>?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<List<Float>>.(List<Float>?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a long list value.
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun longsOption(
+    name: String,
+    default: List<Long>? = null,
+    values: Map<String, List<Long>?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<List<Long>>.(List<Long>?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option] with a long list value and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+fun PatchBuilder<*>.longsOption(
+    name: String,
+    default: List<Long>? = null,
+    values: Map<String, List<Long>?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    validator: Option<List<Long>>.(List<Long>?) -> Boolean = { true },
+) = option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+)
+
+/**
+ * Create a new [Option].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+inline fun <reified T> option(
+    name: String,
+    default: T? = null,
+    values: Map<String, T?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    noinline validator: Option<T>.(T?) -> Boolean = { true },
+) = Option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    typeOf<T>(),
+    validator,
+)
+
+/**
+ * Create a new [Option] and add it to the current [PatchBuilder].
+ *
+ * @param name The name.
+ * @param default The default value.
+ * @param values Eligible option values mapped to a human-readable name.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ *
+ * @return The created [Option].
+ *
+ * @see Option
+ */
+inline fun <reified T> PatchBuilder<*>.option(
+    name: String,
+    default: T? = null,
+    values: Map<String, T?>? = null,
+    description: String? = null,
+    required: Boolean = false,
+    noinline validator: Option<T>.(T?) -> Boolean = { true },
+) = app.revanced.patcher.patch.option(
+    name,
+    default,
+    values,
+    description,
+    required,
+    validator,
+).also { it() }
+
+/**
+ * An exception thrown when using [Option]s.
+ *
+ * @param errorMessage The exception message.
+ */
+sealed class OptionException(errorMessage: String) : Exception(errorMessage, null) {
+    /**
+     * An exception thrown when a [Option] is set to an invalid value.
+     *
+     * @param invalidType The type of the value that was passed.
+     * @param expectedType The type of the value that was expected.
+     */
+    class InvalidValueTypeException(invalidType: String, expectedType: String) :
+        OptionException("Type $expectedType was expected but received type $invalidType")
+
+    /**
+     * An exception thrown when a value did not satisfy the value conditions specified by the [Option].
+     *
+     * @param value The value that failed validation.
+     */
+    class ValueValidationException(value: Any?, option: Option<*>) :
+        OptionException("The option value \"$value\" failed validation for ${option.name}")
+
+    /**
+     * An exception thrown when a value is required but null was passed.
+     *
+     * @param option The [Option] that requires a value.
+     */
+    class ValueRequiredException(option: Option<*>) :
+        OptionException("The option ${option.name} requires a value, but the value was null")
+
+    /**
+     * An exception thrown when a [Option] is not found.
+     *
+     * @param name The name of the [Option].
+     */
+    class OptionNotFoundException(name: String) : OptionException("No option with name $name")
+}
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/patch/Patch.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/patch/Patch.kt
@@ -0,0 +1,273 @@
+@file:Suppress("MemberVisibilityCanBePrivate", "unused")
+
+package app.revanced.patcher.patch
+
+import java.io.File
+import java.io.InputStream
+import java.lang.reflect.Member
+import java.lang.reflect.Method
+import java.lang.reflect.Modifier
+import java.util.function.Supplier
+import kotlin.properties.ReadOnlyProperty
+
+typealias PackageName = String
+typealias VersionName = String
+typealias Package = Pair<PackageName, Set<VersionName>?>
+
+enum class PatchType(internal val prefix: String) {
+    BYTECODE("Bytecode"),
+    RAW_RESOURCE("RawResource"),
+    RESOURCE("Resource")
+}
+
+internal val Patch.patchesResources: Boolean get() = type == PatchType.RESOURCE || dependencies.any { it.patchesResources }
+
+open class Patch internal constructor(
+    val name: String?,
+    val description: String?,
+    val use: Boolean,
+    val dependencies: Set<Patch>,
+    val compatiblePackages: Set<Package>?,
+    options: Set<Option<*>>,
+    internal val apply: context(BytecodePatchContext, ResourcePatchContext) () -> Unit,
+    // Must be nullable, so that Patcher.invoke can check,
+    // if a patch has an "afterDependents" in order to not emit it twice.
+    internal var afterDependents: (context(BytecodePatchContext, ResourcePatchContext) () -> Unit)?,
+    internal val type: PatchType,
+) {
+    val options = Options(options)
+
+    override fun toString() = name ?: "${type.prefix}Patch@${System.identityHashCode(this)}"
+}
+
+sealed class PatchBuilder<C : PatchContext<*>>(
+    private val type: PatchType,
+    private val getPatchContext: context(BytecodePatchContext, ResourcePatchContext) () -> C
+) {
+    private var compatiblePackages: MutableSet<Package>? = null
+    private val dependencies = mutableSetOf<Patch>()
+    private val options = mutableSetOf<Option<*>>()
+
+    internal var apply: context(BytecodePatchContext, ResourcePatchContext) () -> Unit = { }
+    internal var afterDependents: (context(BytecodePatchContext, ResourcePatchContext)  () -> Unit)? = null
+
+    context(_: BytecodePatchContext, _: ResourcePatchContext)
+    private val patchContext get() = getPatchContext()
+
+    fun apply(block: C.() -> Unit) {
+        apply = { block(patchContext) }
+    }
+
+    fun afterDependents(block: C.() -> Unit) {
+        afterDependents = { block(patchContext) }
+    }
+
+    operator fun <T> Option<T>.invoke() = apply {
+        options += this
+    }
+
+    operator fun String.invoke(vararg versions: VersionName) = invoke(versions.toSet())
+
+    private operator fun String.invoke(versions: Set<VersionName>? = null): Package = this to versions
+
+    fun compatibleWith(vararg packages: Package) {
+        if (compatiblePackages == null) {
+            compatiblePackages = mutableSetOf()
+        }
+
+        compatiblePackages!! += packages
+    }
+
+    fun compatibleWith(vararg packages: String) = compatibleWith(*packages.map { it() }.toTypedArray())
+
+    fun dependsOn(vararg patches: Patch) {
+        dependencies += patches
+    }
+
+
+    fun build(name: String?, description: String?, use: Boolean) = Patch(
+        name,
+        description,
+        use,
+        dependencies,
+        compatiblePackages,
+        options,
+        apply,
+        afterDependents,
+        type,
+    )
+}
+
+class BytecodePatchBuilder private constructor(
+    private var extensionInputStream: InputStream? = null
+) : PatchBuilder<BytecodePatchContext>(
+    PatchType.BYTECODE,
+    {
+        // Extend the context with the extension, before returning it to the patch before applying it.
+        contextOf<BytecodePatchContext>().apply {
+            if (extensionInputStream != null) extendWith(extensionInputStream)
+        }
+    }
+) {
+    internal constructor() : this(null)
+
+    fun extendWith(extension: String) {
+        // Should be the classloader which loaded the patch class.
+        val classLoader = Class.forName(Thread.currentThread().stackTrace[2].className).classLoader!!
+
+        extensionInputStream = classLoader.getResourceAsStream(extension)
+            ?: throw PatchException("Extension \"$extension\" not found")
+    }
+}
+
+open class ResourcePatchBuilder internal constructor(type: PatchType) : PatchBuilder<ResourcePatchContext>(
+    type,
+    { contextOf<ResourcePatchContext>() }
+) {
+    internal constructor() : this(PatchType.RESOURCE)
+}
+
+class RawResourcePatchBuilder internal constructor() : ResourcePatchBuilder()
+
+fun bytecodePatch(
+    name: String? = null,
+    description: String? = null,
+    use: Boolean = true,
+    block: BytecodePatchBuilder.() -> Unit
+) = BytecodePatchBuilder().apply(block).build(name, description, use)
+
+fun resourcePatch(
+    name: String? = null,
+    description: String? = null,
+    use: Boolean = true,
+    block: ResourcePatchBuilder.() -> Unit
+) = ResourcePatchBuilder().apply(block).build(name, description, use)
+
+fun rawResourcePatch(
+    name: String? = null,
+    description: String? = null,
+    use: Boolean = true,
+    block: RawResourcePatchBuilder.() -> Unit
+) = RawResourcePatchBuilder().apply(block).build(name, description, use)
+
+private fun <B : PatchBuilder<*>> creatingPatch(
+    description: String? = null,
+    use: Boolean = true,
+    block: B.() -> Unit,
+    patchSupplier: (String?, String?, Boolean, B.() -> Unit) -> Patch
+) = ReadOnlyProperty<Any?, Patch> { _, property -> patchSupplier(property.name, description, use, block) }
+
+fun creatingBytecodePatch(
+    description: String? = null,
+    use: Boolean = true,
+    block: BytecodePatchBuilder.() -> Unit,
+) = creatingPatch(description, use, block) { name, description, use, block ->
+    bytecodePatch(name, description, use, block)
+}
+
+fun creatingResourcePatch(
+    description: String? = null,
+    use: Boolean = true,
+    block: ResourcePatchBuilder.() -> Unit,
+) = creatingPatch(description, use, block) { name, description, use, block ->
+    resourcePatch(name, description, use, block)
+}
+
+fun creatingRawResourcePatch(
+    description: String? = null,
+    use: Boolean = true,
+    block: RawResourcePatchBuilder.() -> Unit,
+) = creatingPatch(description, use, block) { name, description, use, block ->
+    rawResourcePatch(name, description, use, block)
+}
+
+
+/**
+ * A common interface for contexts such as [ResourcePatchContext] and [BytecodePatchContext].
+ */
+
+sealed interface PatchContext<T> : Supplier<T>
+
+/**
+ * An exception thrown when patching.
+ *
+ * @param errorMessage The exception message.
+ * @param cause The corresponding [Throwable].
+ */
+class PatchException(errorMessage: String?, cause: Throwable?) : Exception(errorMessage, cause) {
+    constructor(errorMessage: String) : this(errorMessage, null)
+    constructor(cause: Throwable) : this(cause.message, cause)
+}
+
+/**
+ * A result of applying a [Patch].
+ *
+ * @param patch The [Patch] that ran.
+ * @param exception The [PatchException] thrown, if any.
+ */
+class PatchResult internal constructor(val patch: Patch, val exception: PatchException? = null)
+
+/**
+ * Creates a [PatchResult] for this [Patch].
+ *
+ * @param exception The [PatchException] thrown, if any.
+ * @return The created [PatchResult].
+ */
+internal fun Patch.patchResult(exception: Exception? = null) = PatchResult(this, exception?.toPatchException())
+
+/**
+ * Creates a [PatchResult] for this [Patch] with the given error message.
+ *
+ * @param errorMessage The error message.
+ * @return The created [PatchResult].
+ */
+internal fun Patch.patchResult(errorMessage: String) = PatchResult(this, PatchException(errorMessage))
+private fun Exception.toPatchException() = this as? PatchException ?: PatchException(this)
+
+/**
+ * A collection of patches loaded from patches files.
+ *
+ * @property patchesByFile The patches mapped by their patches file.
+ */
+class Patches internal constructor(val patchesByFile: Map<File, Set<Patch>>) : Set<Patch>
+by patchesByFile.values.flatten().toSet()
+
+// Must be internal and a separate function for testing.
+@Suppress("MISSING_DEPENDENCY_IN_INFERRED_TYPE_ANNOTATION_WARNING")
+internal fun getPatches(classNames: List<String>, classLoader: ClassLoader): Set<Patch> {
+    fun Member.isUsable() =
+        Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && (this !is Method || parameterCount == 0)
+
+    fun Class<*>.getPatchFields() = fields
+        .filter { it.type.isPatch && it.isUsable() }
+        .map { it.get(null) as Patch }
+
+    fun Class<*>.getPatchMethods() = methods
+        .filter { it.returnType.isPatch && it.parameterCount == 0 && it.isUsable() }
+        .map { it.invoke(null) as Patch }
+
+    return classNames
+        .map { classLoader.loadClass(it) }
+        .flatMap { it.getPatchMethods() + it.getPatchFields() }
+        .filter { it.name != null }
+        .toSet()
+}
+
+internal fun loadPatches(
+    vararg patchesFiles: File,
+    getBinaryClassNames: (patchesFile: File) -> List<String>,
+    classLoader: ClassLoader,
+    onFailedToLoad: (File, Throwable) -> Unit
+) = Patches(patchesFiles.map { file ->
+    file to getBinaryClassNames(file)
+}.mapNotNull { (file, classNames) ->
+    runCatching { file to getPatches(classNames, classLoader) }
+        .onFailure { onFailedToLoad(file, it) }.getOrNull()
+}.toMap())
+
+expect fun loadPatches(
+    vararg patchesFiles: File,
+    onFailedToLoad: (patchesFile: File, throwable: Throwable) -> Unit = { _, _ -> },
+): Patches
+
+internal expect val Class<*>.isPatch: Boolean
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/patch/ResourcePatchContext.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/patch/ResourcePatchContext.kt
@@ -0,0 +1,229 @@
+package app.revanced.patcher.patch
+
+import app.revanced.patcher.PatchesResult
+import app.revanced.patcher.util.Document
+import brut.androlib.AaptInvoker
+import brut.androlib.ApkDecoder
+import brut.androlib.Config
+import brut.androlib.apk.ApkInfo
+import brut.androlib.apk.UsesFramework
+import brut.androlib.res.Framework
+import brut.androlib.res.ResourcesDecoder
+import brut.androlib.res.decoder.AndroidManifestPullStreamDecoder
+import brut.androlib.res.decoder.AndroidManifestResourceParser
+import brut.androlib.res.xml.ResXmlUtils
+import brut.directory.ExtFile
+import java.io.File
+import java.io.InputStream
+import java.io.OutputStream
+import java.io.resolve
+import java.nio.file.Files
+import java.util.logging.Logger
+import kotlin.reflect.jvm.jvmName
+
+/**
+ * A context for patches containing the current state of resources.
+ *
+ * @param apkFile The apk file to patch.
+ * @param apkFilesPath The path to the temporary apk files directory.
+ * @param patchedFilesPath The path to the temporary patched files directory.
+ * @param aaptBinaryPath The path to a custom aapt binary.
+ * @param frameworkFileDirectory The path to the directory to cache the framework file in.
+ */
+class ResourcePatchContext internal constructor(
+    private val apkFile: File,
+    private val apkFilesPath: File,
+    private val patchedFilesPath: File,
+    aaptBinaryPath: File? = null,
+    frameworkFileDirectory: String? = null,
+) : PatchContext<PatchesResult.PatchedResources?> {
+    private val apkInfo = ApkInfo(ExtFile(apkFile))
+
+    private val logger = Logger.getLogger(ResourcePatchContext::class.jvmName)
+
+    private val resourceConfig = Config.getDefaultConfig().apply {
+        aaptBinary = aaptBinaryPath
+        frameworkDirectory = frameworkFileDirectory
+    }
+
+    internal var decodingMode = ResourceDecodingMode.MANIFEST
+
+    /**
+     * Read a document from an [InputStream].
+     */
+    fun document(inputStream: InputStream) = Document(inputStream)
+
+    /**
+     * Read and write documents in the [apkFile].
+     */
+    fun document(path: String) = Document(get(path))
+
+    /**
+     * Set of resources from [apkFile] to delete.
+     */
+    private val deleteResources = mutableSetOf<String>()
+
+    internal fun decodeManifest(): Pair<PackageName, VersionName> {
+        logger.info("Decoding manifest")
+
+        val resourcesDecoder = ResourcesDecoder(resourceConfig, apkInfo)
+
+        // Decode manually instead of using resourceDecoder.decodeManifest
+        // because it does not support decoding to an OutputStream.
+        AndroidManifestPullStreamDecoder(
+            AndroidManifestResourceParser(resourcesDecoder.resTable),
+            resourcesDecoder.newXmlSerializer(),
+        ).decode(
+            apkInfo.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.
+        // The call to AndroidManifestPullStreamDecoder.decode() above sets apkInfo.
+        val packageName = resourcesDecoder.resTable.packageRenamed
+        val packageVersion =
+            apkInfo.versionInfo.versionName ?: apkInfo.versionInfo.versionCode
+
+        /*
+         When the main resource package is not loaded, the ResTable is flagged as sparse.
+         Because ResourcesDecoder.decodeResources loads the main package and is not called here,
+         set sparseResources to false again to prevent the ResTable from being flagged as sparse falsely,
+         in case ResourcesDecoder.decodeResources is not later used in the patching process
+          to set sparseResources correctly.
+
+         See ARSCDecoder.readTableType for more info.
+         */
+        apkInfo.sparseResources = false
+
+        return packageName to packageVersion
+    }
+
+    internal fun decodeResources() {
+        logger.info("Decoding resources")
+
+        val resourcesDecoder = ResourcesDecoder(resourceConfig, apkInfo).also {
+            it.decodeResources(apkFilesPath)
+            it.decodeManifest(apkFilesPath)
+        }
+
+        // Record uncompressed files to preserve their state when recompiling.
+        ApkDecoder(apkInfo, resourceConfig).recordUncompressedFiles(resourcesDecoder.resFileMapping)
+
+        // Get the ids of the used framework packages to include them for reference when recompiling.
+        apkInfo.usesFramework = UsesFramework().apply {
+            ids = resourcesDecoder.resTable.listFramePackages().map { it.id }
+        }
+    }
+
+    /**
+     * Compile resources in [apkFilesPath].
+     *
+     * @return The [PatchesResult.PatchedResources].
+     */
+    override fun get(): PatchesResult.PatchedResources {
+        logger.info("Compiling patched resources")
+
+        val resourcesPath = patchedFilesPath.resolve("resources").also { it.mkdirs() }
+
+        val resourcesApkFile = if (decodingMode == ResourceDecodingMode.ALL) {
+            val resourcesApkFile = resourcesPath.resolve("resources.apk").also { it.createNewFile() }
+
+            val manifestFile = apkFilesPath.resolve("AndroidManifest.xml").also {
+                ResXmlUtils.fixingPublicAttrsInProviderAttributes(it)
+            }
+            val resPath = apkFilesPath.resolve("res")
+            val frameworkApkFiles = with(Framework(resourceConfig)) {
+                apkInfo.usesFramework.ids.map { id -> getFrameworkApk(id, null) }
+            }.toTypedArray()
+
+            AaptInvoker(
+                resourceConfig,
+                apkInfo
+            ).invoke(resourcesApkFile, manifestFile, resPath, null, null, frameworkApkFiles)
+
+            resourcesApkFile
+        } else null
+
+
+        val otherFiles = apkFilesPath.listFiles()!!.filter {
+            // Excluded because present in resources.other.
+            // TODO: We are reusing apkFiles as a temporarily directory for extracting resources.
+            //  This is not ideal as it could conflict with files such as the ones that are filtered here.
+            //  The problem is that ResourcePatchContext#get returns a File relative to apkFiles,
+            //  and we need to extract files to that directory.
+            //  A solution would be to use apkFiles as the working directory for the patching process.
+            //  Once all patches have been executed, we can move the decoded resources to a new directory.
+            //  The filters wouldn't be needed anymore.
+            //  For now, we assume that the files we filter here are not needed for the patching process.
+            it.name != "AndroidManifest.xml" &&
+                    it.name != "res" &&
+                    // Generated by Androlib.
+                    it.name != "build"
+        }
+        val otherResourceFiles = if (otherFiles.isNotEmpty()) {
+            // Move the other resources files.
+            resourcesPath.resolve("other").also { it.mkdirs() }.apply {
+                otherFiles.forEach { file ->
+                    Files.move(file.toPath(), resolve(file.name).toPath())
+                }
+            }
+        } else null
+
+        return PatchesResult.PatchedResources(
+            resourcesApkFile,
+            otherResourceFiles,
+            apkInfo.doNotCompress?.toSet() ?: emptySet(),
+            deleteResources,
+        )
+    }
+
+    /**
+     * Get a file from [apkFilesPath].
+     *
+     * @param path The path of the file.
+     * @param copy Whether to copy the file from [apkFile] if it does not exist yet in [apkFilesPath].
+     */
+    operator fun get(
+        path: String,
+        copy: Boolean = true,
+    ) = apkFilesPath.resolve(path).apply {
+        if (copy && !exists()) {
+            with(ExtFile(apkFile).directory) {
+                if (containsFile(path) || containsDir(path)) {
+                    copyToDir(apkFilesPath, path)
+                }
+            }
+        }
+    }
+
+    /**
+     * Mark a file for deletion when the APK is rebuilt.
+     *
+     * @param name The name of the file to delete.
+     */
+    fun delete(name: String) = deleteResources.add(name)
+
+    /**
+     * How to handle resources decoding and compiling.
+     */
+    internal enum class ResourceDecodingMode {
+        /**
+         * Decode and compile all resources.
+         */
+        ALL,
+
+        /**
+         * Do not decode or compile any resources.
+         */
+        NONE,
+
+        /**
+         * Do not decode or compile any resources.
+         */
+        MANIFEST,
+    }
+}
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/util/ClassMerger.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/util/ClassMerger.kt
@@ -1,31 +1,31 @@
 package app.revanced.patcher.util

-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.extensions.or
+import com.android.tools.smali.dexlib2.mutable.MutableClassDef
+import com.android.tools.smali.dexlib2.mutable.MutableClassDef.Companion.toMutable
+import com.android.tools.smali.dexlib2.mutable.MutableField
+import com.android.tools.smali.dexlib2.mutable.MutableField.Companion.toMutable
+import com.android.tools.smali.dexlib2.mutable.MutableMethod
+import com.android.tools.smali.dexlib2.mutable.MutableMethod.Companion.toMutable
+import app.revanced.patcher.patch.BytecodePatchContext
 import app.revanced.patcher.util.ClassMerger.Utils.asMutableClass
 import app.revanced.patcher.util.ClassMerger.Utils.filterAny
 import app.revanced.patcher.util.ClassMerger.Utils.filterNotAny
 import app.revanced.patcher.util.ClassMerger.Utils.isPublic
 import app.revanced.patcher.util.ClassMerger.Utils.toPublic
 import app.revanced.patcher.util.ClassMerger.Utils.traverseClassHierarchy
-import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
-import app.revanced.patcher.util.proxy.mutableTypes.MutableClass.Companion.toMutable
-import app.revanced.patcher.util.proxy.mutableTypes.MutableField
-import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
 import com.android.tools.smali.dexlib2.AccessFlags
 import com.android.tools.smali.dexlib2.iface.ClassDef
 import com.android.tools.smali.dexlib2.util.MethodUtil
 import java.util.logging.Logger
 import kotlin.reflect.KFunction2
+import kotlin.reflect.jvm.jvmName

 /**
 * Experimental class to merge a [ClassDef] with another.
 * Note: This will not consider method implementations or if the class is missing a superclass or interfaces.
 */
 internal object ClassMerger {
-    private val logger = Logger.getLogger(ClassMerger::class.java.name)
+    private val logger = Logger.getLogger(ClassMerger::class.jvmName)

    /**
     * Merge a class with [otherClass].
@@ -36,7 +36,7 @@ internal object ClassMerger {
     */
    fun ClassDef.merge(
        otherClass: ClassDef,
-        context: BytecodeContext,
+        context: BytecodePatchContext,
    ) = this
        // .fixFieldAccess(otherClass)
        // .fixMethodAccess(otherClass)
@@ -61,7 +61,7 @@ internal object ClassMerger {

        if (missingMethods.isEmpty()) return this

-        logger.fine("Found ${missingMethods.size} missing methods")
+        logger.fine { "Found ${missingMethods.size} missing methods" }

        return asMutableClass().apply {
            methods.addAll(missingMethods.map { it.toMutable() })
@@ -81,7 +81,7 @@ internal object ClassMerger {

        if (missingFields.isEmpty()) return this

-        logger.fine("Found ${missingFields.size} missing fields")
+        logger.fine { "Found ${missingFields.size} missing fields" }

        return asMutableClass().apply {
            fields.addAll(missingFields.map { it.toMutable() })
@@ -95,13 +95,13 @@ internal object ClassMerger {
     */
    private fun ClassDef.publicize(
        reference: ClassDef,
-        context: BytecodeContext,
+        context: BytecodePatchContext,
    ) = 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()
            }
@@ -125,7 +125,7 @@ internal object ClassMerger {

        if (brokenFields.isEmpty()) return this

-        logger.fine("Found ${brokenFields.size} broken fields")
+        logger.fine { "Found ${brokenFields.size} broken fields" }

        /**
         * Make a field public.
@@ -154,7 +154,7 @@ internal object ClassMerger {

        if (brokenMethods.isEmpty()) return this

-        logger.fine("Found ${brokenMethods.size} methods")
+        logger.fine { "Found ${brokenMethods.size} methods" }

        /**
         * Make a method public.
@@ -175,17 +175,18 @@ 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 BytecodePatchContext.traverseClassHierarchy(
+            targetClass: MutableClassDef,
+            callback: MutableClassDef.() -> Unit,
        ) {
            callback(targetClass)
-            this.findClass(targetClass.superclass ?: return)?.mutableClass?.let {
-                traverseClassHierarchy(it, callback)
+
+            classDefs[targetClass.superclass ?: return]?.let { classDef ->
+                traverseClassHierarchy(classDefs.getOrReplaceMutable(classDef), callback)
            }
        }

-        fun ClassDef.asMutableClass() = if (this is MutableClass) this else this.toMutable()
+        fun ClassDef.asMutableClass() = this as? MutableClassDef ?: this.toMutable()

        /**
         * Check if the [AccessFlags.PUBLIC] flag is set.
@@ -199,7 +200,7 @@ internal object ClassMerger {
         *
         * @return The new [AccessFlags].
         */
-        fun Int.toPublic() = this.or(AccessFlags.PUBLIC).and(AccessFlags.PRIVATE.value.inv())
+        fun Int.toPublic() = or(AccessFlags.PUBLIC.value).and(AccessFlags.PRIVATE.value.inv())

        /**
         * Filter [this] on [needles] matching the given [predicate].
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/util/Document.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/util/Document.kt
@@ -1,13 +1,19 @@
 package app.revanced.patcher.util

+import collections.merge
+import com.google.common.base.Charsets
 import org.w3c.dom.Document
 import java.io.Closeable
 import java.io.File
 import java.io.InputStream
+import java.io.bufferedWriter
+import java.io.inputStream
 import javax.xml.parsers.DocumentBuilderFactory
+import javax.xml.transform.OutputKeys
 import javax.xml.transform.TransformerFactory
 import javax.xml.transform.dom.DOMSource
 import javax.xml.transform.stream.StreamResult
+import kotlin.use

 class Document internal constructor(
    inputStream: InputStream,
@@ -28,21 +34,28 @@ class Document internal constructor(
            if (readerCount[it]!! > 1) {
                throw IllegalStateException(
                    "Two or more instances are currently reading $it." +
-                        "To be able to close this instance, no other instances may be reading $it at the same time.",
+                            "To be able to close this instance, no other instances may be reading $it at the same time.",
                )
            } else {
                readerCount.remove(it)
            }

-            it.outputStream().use { stream ->
-                TransformerFactory.newInstance()
-                    .newTransformer()
-                    .transform(DOMSource(this), StreamResult(stream))
+            val transformer = TransformerFactory.newInstance().newTransformer()
+            // Set to UTF-16 to prevent surrogate pairs from being escaped to invalid numeric character references, but save as UTF-8.
+            if (isAndroid) {
+                transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-16")
+                transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes")
+                val writer = it.bufferedWriter(charset = Charsets.UTF_8)
+                transformer.transform(DOMSource(this), StreamResult(writer))
+                writer.close()
+            } else {
+                transformer.transform(DOMSource(this), StreamResult(it))
            }
        }
    }

    private companion object {
        private val readerCount = mutableMapOf<File, Int>()
+        private val isAndroid = System.getProperty("java.runtime.name") == "Android Runtime"
    }
 }
--- a/patcher/src/commonMain/kotlin/app/revanced/patcher/util/MethodNavigator.kt
+++ b/patcher/src/commonMain/kotlin/app/revanced/patcher/util/MethodNavigator.kt
@@ -0,0 +1,119 @@
+@file:Suppress("unused")
+
+package app.revanced.patcher.util
+
+import com.android.tools.smali.dexlib2.mutable.MutableMethod
+import app.revanced.patcher.extensions.instructionsOrNull
+import app.revanced.patcher.patch.BytecodePatchContext
+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.MethodReference
+import com.android.tools.smali.dexlib2.util.MethodUtil
+import kotlin.reflect.KProperty
+
+/**
+ * A navigator for methods.
+ *
+ * @param startMethod The [Method] to start navigating from.
+ *
+ * @constructor Creates a new [MethodNavigator].
+ *
+ * @throws NavigateException If the method does not have an implementation.
+ * @throws NavigateException If the instruction at the specified index is not a method reference.
+ */
+class MethodNavigator internal constructor(
+    private var startMethod: MethodReference,
+) {
+    private var lastNavigatedMethodReference = startMethod
+
+    context(_: BytecodePatchContext)
+    private val lastNavigatedMethodInstructions
+        get() = with(original()) {
+            instructionsOrNull ?: throw NavigateException("Method $this does not have an implementation.")
+        }
+
+    /**
+     * Navigate to the method at the specified index.
+     *
+     * @param index The index of the method to navigate to.
+     *
+     * @return This [MethodNavigator].
+     */
+    context(_: BytecodePatchContext)
+    fun to(vararg index: Int): MethodNavigator {
+        index.forEach {
+            lastNavigatedMethodReference = lastNavigatedMethodInstructions.getMethodReferenceAt(it)
+        }
+
+        return this
+    }
+
+    /**
+     * Navigate to the method at the specified index that matches the specified predicate.
+     *
+     * @param index The index of the method to navigate to.
+     * @param predicate The predicate to match.
+     */
+    context(_: BytecodePatchContext)
+    fun to(index: Int = 0, predicate: (Instruction) -> Boolean): MethodNavigator {
+        lastNavigatedMethodReference = lastNavigatedMethodInstructions.asSequence()
+            .filter(predicate).asIterable().getMethodReferenceAt(index)
+
+        return this
+    }
+
+    /**
+     * Get the method reference at the specified index.
+     *
+     * @param index The index of the method reference to get.
+     */
+    private fun Iterable<Instruction>.getMethodReferenceAt(index: Int): MethodReference {
+        val instruction = elementAt(index) as? ReferenceInstruction
+            ?: throw NavigateException("Instruction at index $index is not a method reference.")
+
+        return instruction.reference as MethodReference
+    }
+
+    /**
+     * Get the last navigated method mutably.
+     *
+     * @return The last navigated method mutably.
+     */
+    context(context: BytecodePatchContext)
+    fun stop() = context.classDefs[lastNavigatedMethodReference.definingClass]!!
+        .firstMethodBySignature as MutableMethod
+
+
+    /**
+     * Get the last navigated method mutably.
+     *
+     * @return The last navigated method mutably.
+     */
+    operator fun getValue(context: BytecodePatchContext?, property: KProperty<*>) =
+        context(requireNotNull(context)) { stop() }
+
+    /**
+     * Get the last navigated method immutably.
+     *
+     * @return The last navigated method immutably.
+     */
+    context(context: BytecodePatchContext)
+    fun original(): Method = context.classDefs[lastNavigatedMethodReference.definingClass]!!.firstMethodBySignature
+
+    /**
+     * Find the first [lastNavigatedMethodReference] in the class.
+     */
+    private val ClassDef.firstMethodBySignature
+        get() = methods.first {
+            MethodUtil.methodSignaturesMatch(it, lastNavigatedMethodReference)
+        }
+
+    /**
+     * An exception thrown when navigating fails.
+     *
+     * @param message The message of the exception.
+     */
+    internal class NavigateException internal constructor(message: String) : Exception(message)
+}
--- a/patcher/src/commonMain/kotlin/collections/MutableMap.kt
+++ b/patcher/src/commonMain/kotlin/collections/MutableMap.kt
@@ -0,0 +1,13 @@
+package collections
+
+internal expect fun <K, V> MutableMap<K, V>.kmpMerge(
+    key: K,
+    value: V,
+    remappingFunction: (oldValue: V, newValue: V) -> V,
+)
+
+internal fun <K, V> MutableMap<K, V>.merge(
+    key: K,
+    value: V,
+    remappingFunction: (oldValue: V, newValue: V) -> V,
+) = kmpMerge(key, value, remappingFunction)
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableAnnotationEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableAnnotationEncodedValue.kt
@@ -0,0 +1,26 @@
+package com.android.tools.smali.dexlib2.iface.value
+
+import com.android.tools.smali.dexlib2.base.value.BaseAnnotationEncodedValue
+import com.android.tools.smali.dexlib2.mutable.MutableAnnotationElement.Companion.toMutable
+
+class MutableAnnotationEncodedValue(annotationEncodedValue: AnnotationEncodedValue) :
+    BaseAnnotationEncodedValue(),
+    MutableEncodedValue {
+    private var type = annotationEncodedValue.type
+
+    private val _elements by lazy {
+        annotationEncodedValue.elements.map { annotationElement -> annotationElement.toMutable() }.toMutableSet()
+    }
+
+    fun setType(type: String) {
+        this.type = type
+    }
+
+    override fun getType() = this.type
+
+    override fun getElements() = _elements
+
+    companion object {
+        fun AnnotationEncodedValue.toMutable() = MutableAnnotationEncodedValue(this)
+    }
+}
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableArrayEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableArrayEncodedValue.kt
@@ -0,0 +1,16 @@
+package com.android.tools.smali.dexlib2.iface.value
+
+import com.android.tools.smali.dexlib2.base.value.BaseArrayEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.MutableEncodedValue.Companion.toMutable
+
+class MutableArrayEncodedValue(arrayEncodedValue: ArrayEncodedValue) : BaseArrayEncodedValue(), MutableEncodedValue {
+    private val _value by lazy {
+        arrayEncodedValue.value.map { encodedValue -> encodedValue.toMutable() }.toMutableList()
+    }
+
+    override fun getValue() = _value
+
+    companion object {
+        fun ArrayEncodedValue.toMutable(): MutableArrayEncodedValue = MutableArrayEncodedValue(this)
+    }
+}
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableBooleanEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableBooleanEncodedValue.kt
@@ -1,24 +1,19 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseBooleanEncodedValue
-import com.android.tools.smali.dexlib2.iface.value.BooleanEncodedValue

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

-    override fun getValue(): Boolean {
-        return this.value
-    }
-
    fun setValue(value: Boolean) {
        this.value = value
    }

+    override fun getValue(): Boolean = this.value
+
    companion object {
-        fun BooleanEncodedValue.toMutable(): MutableBooleanEncodedValue {
-            return MutableBooleanEncodedValue(this)
-        }
+        fun BooleanEncodedValue.toMutable(): MutableBooleanEncodedValue = MutableBooleanEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableByteEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableByteEncodedValue.kt
@@ -1,22 +1,17 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseByteEncodedValue
-import com.android.tools.smali.dexlib2.iface.value.ByteEncodedValue

 class MutableByteEncodedValue(byteEncodedValue: ByteEncodedValue) : BaseByteEncodedValue(), MutableEncodedValue {
    private var value = byteEncodedValue.value

-    override fun getValue(): Byte {
-        return this.value
-    }
-
    fun setValue(value: Byte) {
        this.value = value
    }

+    override fun getValue(): Byte = this.value
+
    companion object {
-        fun ByteEncodedValue.toMutable(): MutableByteEncodedValue {
-            return MutableByteEncodedValue(this)
-        }
+        fun ByteEncodedValue.toMutable(): MutableByteEncodedValue = MutableByteEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableCharEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableCharEncodedValue.kt
@@ -1,22 +1,17 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseCharEncodedValue
-import com.android.tools.smali.dexlib2.iface.value.CharEncodedValue

 class MutableCharEncodedValue(charEncodedValue: CharEncodedValue) : BaseCharEncodedValue(), MutableEncodedValue {
    private var value = charEncodedValue.value

-    override fun getValue(): Char {
-        return this.value
-    }
-
    fun setValue(value: Char) {
        this.value = value
    }

+    override fun getValue(): Char = this.value
+
    companion object {
-        fun CharEncodedValue.toMutable(): MutableCharEncodedValue {
-            return MutableCharEncodedValue(this)
-        }
+        fun CharEncodedValue.toMutable(): MutableCharEncodedValue = MutableCharEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableDoubleEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableDoubleEncodedValue.kt
@@ -1,24 +1,19 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseDoubleEncodedValue
-import com.android.tools.smali.dexlib2.iface.value.DoubleEncodedValue

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

-    override fun getValue(): Double {
-        return this.value
-    }
-
    fun setValue(value: Double) {
        this.value = value
    }

+    override fun getValue(): Double = this.value
+
    companion object {
-        fun DoubleEncodedValue.toMutable(): MutableDoubleEncodedValue {
-            return MutableDoubleEncodedValue(this)
-        }
+        fun DoubleEncodedValue.toMutable(): MutableDoubleEncodedValue = MutableDoubleEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableEncodedValue.kt
@@ -1,7 +1,6 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.ValueType
-import com.android.tools.smali.dexlib2.iface.value.*

 interface MutableEncodedValue : EncodedValue {
    companion object {
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableEnumEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableEnumEncodedValue.kt
@@ -1,23 +1,18 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseEnumEncodedValue
 import com.android.tools.smali.dexlib2.iface.reference.FieldReference
-import com.android.tools.smali.dexlib2.iface.value.EnumEncodedValue

 class MutableEnumEncodedValue(enumEncodedValue: EnumEncodedValue) : BaseEnumEncodedValue(), MutableEncodedValue {
    private var value = enumEncodedValue.value

-    override fun getValue(): FieldReference {
-        return this.value
-    }
-
    fun setValue(value: FieldReference) {
        this.value = value
    }

+    override fun getValue(): FieldReference = this.value
+
    companion object {
-        fun EnumEncodedValue.toMutable(): MutableEnumEncodedValue {
-            return MutableEnumEncodedValue(this)
-        }
+        fun EnumEncodedValue.toMutable(): MutableEnumEncodedValue = MutableEnumEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableFieldEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableFieldEncodedValue.kt
@@ -1,28 +1,21 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.ValueType
 import com.android.tools.smali.dexlib2.base.value.BaseFieldEncodedValue
 import com.android.tools.smali.dexlib2.iface.reference.FieldReference
-import com.android.tools.smali.dexlib2.iface.value.FieldEncodedValue

 class MutableFieldEncodedValue(fieldEncodedValue: FieldEncodedValue) : BaseFieldEncodedValue(), MutableEncodedValue {
    private var value = fieldEncodedValue.value

-    override fun getValueType(): Int {
-        return ValueType.FIELD
-    }
-
-    override fun getValue(): FieldReference {
-        return this.value
-    }
-
    fun setValue(value: FieldReference) {
        this.value = value
    }

+    override fun getValueType(): Int = ValueType.FIELD
+
+    override fun getValue(): FieldReference = this.value
+
    companion object {
-        fun FieldEncodedValue.toMutable(): MutableFieldEncodedValue {
-            return MutableFieldEncodedValue(this)
-        }
+        fun FieldEncodedValue.toMutable(): MutableFieldEncodedValue = MutableFieldEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableFloatEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableFloatEncodedValue.kt
@@ -1,22 +1,17 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseFloatEncodedValue
-import com.android.tools.smali.dexlib2.iface.value.FloatEncodedValue

 class MutableFloatEncodedValue(floatEncodedValue: FloatEncodedValue) : BaseFloatEncodedValue(), MutableEncodedValue {
    private var value = floatEncodedValue.value

-    override fun getValue(): Float {
-        return this.value
-    }
-
    fun setValue(value: Float) {
        this.value = value
    }

+    override fun getValue(): Float = this.value
+
    companion object {
-        fun FloatEncodedValue.toMutable(): MutableFloatEncodedValue {
-            return MutableFloatEncodedValue(this)
-        }
+        fun FloatEncodedValue.toMutable(): MutableFloatEncodedValue = MutableFloatEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableIntEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableIntEncodedValue.kt
@@ -1,22 +1,17 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseIntEncodedValue
-import com.android.tools.smali.dexlib2.iface.value.IntEncodedValue

 class MutableIntEncodedValue(intEncodedValue: IntEncodedValue) : BaseIntEncodedValue(), MutableEncodedValue {
    private var value = intEncodedValue.value

-    override fun getValue(): Int {
-        return this.value
-    }
-
    fun setValue(value: Int) {
        this.value = value
    }

+    override fun getValue(): Int = this.value
+
    companion object {
-        fun IntEncodedValue.toMutable(): MutableIntEncodedValue {
-            return MutableIntEncodedValue(this)
-        }
+        fun IntEncodedValue.toMutable(): MutableIntEncodedValue = MutableIntEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableLongEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableLongEncodedValue.kt
@@ -1,22 +1,17 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseLongEncodedValue
-import com.android.tools.smali.dexlib2.iface.value.LongEncodedValue

 class MutableLongEncodedValue(longEncodedValue: LongEncodedValue) : BaseLongEncodedValue(), MutableEncodedValue {
    private var value = longEncodedValue.value

-    override fun getValue(): Long {
-        return this.value
-    }
-
    fun setValue(value: Long) {
        this.value = value
    }

+    override fun getValue(): Long = this.value
+
    companion object {
-        fun LongEncodedValue.toMutable(): MutableLongEncodedValue {
-            return MutableLongEncodedValue(this)
-        }
+        fun LongEncodedValue.toMutable(): MutableLongEncodedValue = MutableLongEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableMethodEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableMethodEncodedValue.kt
@@ -1,25 +1,20 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 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(),
    MutableEncodedValue {
    private var value = methodEncodedValue.value

-    override fun getValue(): MethodReference {
-        return this.value
-    }
-
    fun setValue(value: MethodReference) {
        this.value = value
    }

+    override fun getValue(): MethodReference = this.value
+
    companion object {
-        fun MethodEncodedValue.toMutable(): MutableMethodEncodedValue {
-            return MutableMethodEncodedValue(this)
-        }
+        fun MethodEncodedValue.toMutable(): MutableMethodEncodedValue = MutableMethodEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableMethodHandleEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableMethodHandleEncodedValue.kt
@@ -1,25 +1,20 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseMethodHandleEncodedValue
 import com.android.tools.smali.dexlib2.iface.reference.MethodHandleReference
-import com.android.tools.smali.dexlib2.iface.value.MethodHandleEncodedValue

 class MutableMethodHandleEncodedValue(methodHandleEncodedValue: MethodHandleEncodedValue) :
    BaseMethodHandleEncodedValue(),
    MutableEncodedValue {
    private var value = methodHandleEncodedValue.value

-    override fun getValue(): MethodHandleReference {
-        return this.value
-    }
-
    fun setValue(value: MethodHandleReference) {
        this.value = value
    }

+    override fun getValue(): MethodHandleReference = this.value
+
    companion object {
-        fun MethodHandleEncodedValue.toMutable(): MutableMethodHandleEncodedValue {
-            return MutableMethodHandleEncodedValue(this)
-        }
+        fun MethodHandleEncodedValue.toMutable(): MutableMethodHandleEncodedValue = MutableMethodHandleEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableMethodTypeEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableMethodTypeEncodedValue.kt
@@ -1,25 +1,18 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 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(),
-    MutableEncodedValue {
+class MutableMethodTypeEncodedValue(methodTypeEncodedValue: MethodTypeEncodedValue) : BaseMethodTypeEncodedValue(), MutableEncodedValue {
    private var value = methodTypeEncodedValue.value

-    override fun getValue(): MethodProtoReference {
-        return this.value
-    }
-
    fun setValue(value: MethodProtoReference) {
        this.value = value
    }

+    override fun getValue(): MethodProtoReference = this.value
+
    companion object {
-        fun MethodTypeEncodedValue.toMutable(): MutableMethodTypeEncodedValue {
-            return MutableMethodTypeEncodedValue(this)
-        }
+        fun MethodTypeEncodedValue.toMutable(): MutableMethodTypeEncodedValue = MutableMethodTypeEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableNullEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableNullEncodedValue.kt
@@ -1,12 +1,9 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseNullEncodedValue
-import com.android.tools.smali.dexlib2.iface.value.ByteEncodedValue

 class MutableNullEncodedValue : BaseNullEncodedValue(), MutableEncodedValue {
    companion object {
-        fun ByteEncodedValue.toMutable(): MutableByteEncodedValue {
-            return MutableByteEncodedValue(this)
-        }
+        fun ByteEncodedValue.toMutable(): MutableByteEncodedValue = MutableByteEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableShortEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableShortEncodedValue.kt
@@ -1,22 +1,19 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseShortEncodedValue
-import com.android.tools.smali.dexlib2.iface.value.ShortEncodedValue

-class MutableShortEncodedValue(shortEncodedValue: ShortEncodedValue) : BaseShortEncodedValue(), MutableEncodedValue {
+class MutableShortEncodedValue(shortEncodedValue: ShortEncodedValue) :
+    BaseShortEncodedValue(),
+    MutableEncodedValue {
    private var value = shortEncodedValue.value

-    override fun getValue(): Short {
-        return this.value
-    }
-
    fun setValue(value: Short) {
        this.value = value
    }

+    override fun getValue(): Short = this.value
+
    companion object {
-        fun ShortEncodedValue.toMutable(): MutableShortEncodedValue {
-            return MutableShortEncodedValue(this)
-        }
+        fun ShortEncodedValue.toMutable(): MutableShortEncodedValue = MutableShortEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableStringEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableStringEncodedValue.kt
@@ -1,25 +1,19 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 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(),
    MutableEncodedValue {
    private var value = stringEncodedValue.value

-    override fun getValue(): String {
-        return this.value
-    }
-
    fun setValue(value: String) {
        this.value = value
    }

+    override fun getValue(): String = this.value
+
    companion object {
-        fun ByteEncodedValue.toMutable(): MutableByteEncodedValue {
-            return MutableByteEncodedValue(this)
-        }
+        fun ByteEncodedValue.toMutable(): MutableByteEncodedValue = MutableByteEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableTypeEncodedValue.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/iface/value/MutableTypeEncodedValue.kt
@@ -1,22 +1,17 @@
-package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
+package com.android.tools.smali.dexlib2.iface.value

 import com.android.tools.smali.dexlib2.base.value.BaseTypeEncodedValue
-import com.android.tools.smali.dexlib2.iface.value.TypeEncodedValue

 class MutableTypeEncodedValue(typeEncodedValue: TypeEncodedValue) : BaseTypeEncodedValue(), MutableEncodedValue {
    private var value = typeEncodedValue.value

-    override fun getValue(): String {
-        return this.value
-    }
-
    fun setValue(value: String) {
        this.value = value
    }

+    override fun getValue() = this.value
+
    companion object {
-        fun TypeEncodedValue.toMutable(): MutableTypeEncodedValue {
-            return MutableTypeEncodedValue(this)
-        }
+        fun TypeEncodedValue.toMutable(): MutableTypeEncodedValue = MutableTypeEncodedValue(this)
    }
 }
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableAnnotation.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableAnnotation.kt
@@ -0,0 +1,21 @@
+package com.android.tools.smali.dexlib2.mutable
+
+import com.android.tools.smali.dexlib2.base.BaseAnnotation
+import com.android.tools.smali.dexlib2.iface.Annotation
+import com.android.tools.smali.dexlib2.mutable.MutableAnnotationElement.Companion.toMutable
+
+class MutableAnnotation(annotation: Annotation) : BaseAnnotation() {
+    private val visibility = annotation.visibility
+    private val type = annotation.type
+    private val _elements by lazy { annotation.elements.map { element -> element.toMutable() }.toMutableSet() }
+
+    override fun getType() = type
+
+    override fun getElements() = _elements
+
+    override fun getVisibility() = visibility
+
+    companion object {
+        fun Annotation.toMutable() = MutableAnnotation(this)
+    }
+}
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableAnnotationElement.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableAnnotationElement.kt
@@ -0,0 +1,27 @@
+package com.android.tools.smali.dexlib2.mutable
+
+import com.android.tools.smali.dexlib2.base.BaseAnnotationElement
+import com.android.tools.smali.dexlib2.iface.AnnotationElement
+import com.android.tools.smali.dexlib2.iface.value.MutableEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.MutableEncodedValue.Companion.toMutable
+
+class MutableAnnotationElement(annotationElement: AnnotationElement) : BaseAnnotationElement() {
+    private var name = annotationElement.name
+    private var value = annotationElement.value.toMutable()
+
+    fun setName(name: String) {
+        this.name = name
+    }
+
+    fun setValue(value: MutableEncodedValue) {
+        this.value = value
+    }
+
+    override fun getName() = name
+
+    override fun getValue() = value
+
+    companion object {
+        fun AnnotationElement.toMutable() = MutableAnnotationElement(this)
+    }
+}
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableClassDef.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableClassDef.kt
@@ -0,0 +1,76 @@
+package com.android.tools.smali.dexlib2.mutable
+
+import com.android.tools.smali.dexlib2.base.reference.BaseTypeReference
+import com.android.tools.smali.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.mutable.MutableAnnotation.Companion.toMutable
+import com.android.tools.smali.dexlib2.mutable.MutableField.Companion.toMutable
+import com.android.tools.smali.dexlib2.mutable.MutableMethod.Companion.toMutable
+import com.android.tools.smali.dexlib2.util.FieldUtil
+import com.android.tools.smali.dexlib2.util.MethodUtil
+
+class MutableClassDef(classDef: ClassDef) : BaseTypeReference(), ClassDef {
+    // Class
+    private var type = classDef.type
+    private var sourceFile = classDef.sourceFile
+    private var accessFlags = classDef.accessFlags
+    private var superclass = classDef.superclass
+
+    private val _interfaces by lazy { classDef.interfaces.toMutableList() }
+    private val _annotations by lazy {
+        classDef.annotations.map { annotation -> annotation.toMutable() }.toMutableSet()
+    }
+
+    // Methods
+    private val _methods by lazy { classDef.methods.map { method -> method.toMutable() }.toMutableSet() }
+    private val _directMethods by lazy { methods.filter { method -> MethodUtil.isDirect(method) }.toMutableSet() }
+    private val _virtualMethods by lazy { methods.filter { method -> !MethodUtil.isDirect(method) }.toMutableSet() }
+
+    // Fields
+    private val _fields by lazy { classDef.fields.map { field -> field.toMutable() }.toMutableSet() }
+    private val _staticFields by lazy { _fields.filter { field -> FieldUtil.isStatic(field) }.toMutableSet() }
+    private val _instanceFields by lazy { _fields.filter { field -> !FieldUtil.isStatic(field) }.toMutableSet() }
+
+    fun setType(type: String) {
+        this.type = type
+    }
+
+    fun setSourceFile(sourceFile: String?) {
+        this.sourceFile = sourceFile
+    }
+
+    fun setAccessFlags(accessFlags: Int) {
+        this.accessFlags = accessFlags
+    }
+
+    fun setSuperClass(superclass: String?) {
+        this.superclass = superclass
+    }
+
+    override fun getType() = type
+
+    override fun getAccessFlags() = accessFlags
+
+    override fun getSourceFile() = sourceFile
+
+    override fun getSuperclass() = superclass
+
+    override fun getInterfaces() = _interfaces
+
+    override fun getAnnotations() = _annotations
+
+    override fun getStaticFields() = _staticFields
+
+    override fun getInstanceFields() = _instanceFields
+
+    override fun getFields() = _fields
+
+    override fun getDirectMethods() = _directMethods
+
+    override fun getVirtualMethods() = _virtualMethods
+
+    override fun getMethods() = _methods
+
+    companion object {
+        fun ClassDef.toMutable(): MutableClassDef = MutableClassDef(this)
+    }
+}
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableField.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableField.kt
@@ -0,0 +1,56 @@
+package com.android.tools.smali.dexlib2.mutable
+
+import com.android.tools.smali.dexlib2.base.reference.BaseFieldReference
+import com.android.tools.smali.dexlib2.iface.Field
+import com.android.tools.smali.dexlib2.iface.value.MutableEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.MutableEncodedValue.Companion.toMutable
+import com.android.tools.smali.dexlib2.mutable.MutableAnnotation.Companion.toMutable
+
+class MutableField(field: Field) : BaseFieldReference(), Field {
+    private var definingClass = field.definingClass
+    private var name = field.name
+    private var type = field.type
+    private var accessFlags = field.accessFlags
+
+    private var initialValue = field.initialValue?.toMutable()
+    private val _annotations by lazy { field.annotations.map { annotation -> annotation.toMutable() }.toMutableSet() }
+    private val _hiddenApiRestrictions by lazy { field.hiddenApiRestrictions }
+
+    fun setDefiningClass(definingClass: String) {
+        this.definingClass = definingClass
+    }
+
+    fun setName(name: String) {
+        this.name = name
+    }
+
+    fun setType(type: String) {
+        this.type = type
+    }
+
+    fun setAccessFlags(accessFlags: Int) {
+        this.accessFlags = accessFlags
+    }
+
+    fun setInitialValue(initialValue: MutableEncodedValue?) {
+        this.initialValue = initialValue
+    }
+
+    override fun getDefiningClass() = this.definingClass
+
+    override fun getName() = this.name
+
+    override fun getType() = this.type
+
+    override fun getAnnotations() = this._annotations
+
+    override fun getAccessFlags() = this.accessFlags
+
+    override fun getHiddenApiRestrictions() = this._hiddenApiRestrictions
+
+    override fun getInitialValue() = this.initialValue
+
+    companion object {
+        fun Field.toMutable() = MutableField(this)
+    }
+}
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableMethod.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableMethod.kt
@@ -0,0 +1,63 @@
+package com.android.tools.smali.dexlib2.mutable
+
+import com.android.tools.smali.dexlib2.base.reference.BaseMethodReference
+import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.mutable.MutableAnnotation.Companion.toMutable
+import com.android.tools.smali.dexlib2.mutable.MutableMethodParameter.Companion.toMutable
+
+class MutableMethod(method: Method) : BaseMethodReference(), Method {
+    private var definingClass = method.definingClass
+    private var name = method.name
+    private var accessFlags = method.accessFlags
+    private var returnType = method.returnType
+
+    // TODO: Create own mutable MethodImplementation (due to not being able to change members like register count).
+    private var implementation = method.implementation?.let(::MutableMethodImplementation)
+    private val _annotations by lazy { method.annotations.map { annotation -> annotation.toMutable() }.toMutableSet() }
+    private val _parameters by lazy { method.parameters.map { parameter -> parameter.toMutable() }.toMutableList() }
+    private val _parameterTypes by lazy { method.parameterTypes.toMutableList() }
+    private val _hiddenApiRestrictions by lazy { method.hiddenApiRestrictions }
+
+    fun setDefiningClass(definingClass: String) {
+        this.definingClass = definingClass
+    }
+
+    fun setName(name: String) {
+        this.name = name
+    }
+
+    fun setAccessFlags(accessFlags: Int) {
+        this.accessFlags = accessFlags
+    }
+
+    fun setReturnType(returnType: String) {
+        this.returnType = returnType
+    }
+
+    fun setImplementation(implementation: MutableMethodImplementation?) {
+        this.implementation = implementation
+    }
+
+    override fun getDefiningClass() = definingClass
+
+    override fun getName() = name
+
+    override fun getParameterTypes() = _parameterTypes
+
+    override fun getReturnType() = returnType
+
+    override fun getAnnotations() = _annotations
+
+    override fun getAccessFlags() = accessFlags
+
+    override fun getHiddenApiRestrictions() = _hiddenApiRestrictions
+
+    override fun getParameters() = _parameters
+
+    override fun getImplementation() = implementation
+
+    companion object {
+        fun Method.toMutable() = MutableMethod(this)
+    }
+}
--- a/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableMethodParameter.kt
+++ b/patcher/src/commonMain/kotlin/com/android/tools/smali/dexlib2/mutable/MutableMethodParameter.kt
@@ -0,0 +1,26 @@
+package com.android.tools.smali.dexlib2.mutable
+
+import com.android.tools.smali.dexlib2.base.BaseMethodParameter
+import com.android.tools.smali.dexlib2.iface.MethodParameter
+import com.android.tools.smali.dexlib2.mutable.MutableAnnotation.Companion.toMutable
+
+class MutableMethodParameter(parameter: MethodParameter) : BaseMethodParameter(), MethodParameter {
+    private var type = parameter.type
+    private var name = parameter.name
+    private var signature = parameter.signature
+    private val _annotations by lazy {
+        parameter.annotations.map { annotation -> annotation.toMutable() }.toMutableSet()
+    }
+
+    override fun getType() = type
+
+    override fun getName() = name
+
+    override fun getSignature() = signature
+
+    override fun getAnnotations() = _annotations
+
+    companion object {
+        fun MethodParameter.toMutable() = MutableMethodParameter(this)
+    }
+}
--- a/patcher/src/commonMain/kotlin/java/io/File.kt
+++ b/patcher/src/commonMain/kotlin/java/io/File.kt
@@ -0,0 +1,17 @@
+package java.io
+
+internal expect fun File.kmpResolve(child: String): File
+
+internal fun File.resolve(child: String) = kmpResolve(child)
+
+internal expect fun File.kmpDeleteRecursively(): Boolean
+
+internal fun File.deleteRecursively() = kmpDeleteRecursively()
+
+internal expect fun File.kmpInputStream(): InputStream
+
+internal fun File.inputStream() = kmpInputStream()
+
+internal expect fun File.kmpBufferedWriter(charset: java.nio.charset.Charset): BufferedWriter
+
+internal fun File.bufferedWriter(charset: java.nio.charset.Charset) = kmpBufferedWriter(charset)
--- a/patcher/src/jvmMain/kotlin/app/revanced/patcher/patch/Patch.jvm.kt
+++ b/patcher/src/jvmMain/kotlin/app/revanced/patcher/patch/Patch.jvm.kt
@@ -0,0 +1,32 @@
+package app.revanced.patcher.patch
+
+import java.io.File
+import java.net.URLClassLoader
+import java.util.jar.JarFile
+
+actual val Class<*>.isPatch get() = Patch::class.java.isAssignableFrom(this)
+
+/**
+ * Loads patches from JAR files declared as public static fields
+ * or returned by public static and non-parametrized methods.
+ * Patches with no name are not loaded. If a patches file fails to load,
+ * the [onFailedToLoad] callback is invoked with the file and the throwable
+ * and the loading continues for the other files.
+ *
+ * @param patchesFiles The JAR files to load the patches from.
+ * @param onFailedToLoad A callback invoked when a patches file fails to load.
+ *
+ * @return The loaded patches.
+ */
+actual fun loadPatches(
+    vararg patchesFiles: File,
+    onFailedToLoad: (patchesFile: File, throwable: Throwable) -> Unit,
+) = loadPatches(
+    patchesFiles = patchesFiles,
+    { file ->
+        JarFile(file).entries().toList().filter { it.name.endsWith(".class") }
+            .map { it.name.substringBeforeLast('.').replace('/', '.') }
+    },
+    URLClassLoader(patchesFiles.map { it.toURI().toURL() }.toTypedArray()),
+    onFailedToLoad = onFailedToLoad
+)
--- a/patcher/src/jvmMain/kotlin/collections/MutableMap.jvm.kt
+++ b/patcher/src/jvmMain/kotlin/collections/MutableMap.jvm.kt
@@ -0,0 +1,7 @@
+package collections
+
+internal actual fun <K, V> MutableMap<K, V>.kmpMerge(
+    key: K,
+    value: V,
+    remappingFunction: (oldValue: V, newValue: V) -> V
+) = merge(key, value, remappingFunction)
--- a/patcher/src/jvmMain/kotlin/java/io/File.jvm.kt
+++ b/patcher/src/jvmMain/kotlin/java/io/File.jvm.kt
@@ -0,0 +1,9 @@
+package java.io
+
+import java.nio.charset.Charset
+
+
+internal actual fun File.kmpResolve(child: String) = resolve(child)
+internal actual fun File.kmpDeleteRecursively() = deleteRecursively()
+internal actual fun File.kmpInputStream() = inputStream()
+internal actual fun File.kmpBufferedWriter(charset: Charset) = bufferedWriter(charset)
--- a/patcher/src/jvmTest/kotlin/app/revanced/patcher/FingerprintTest.kt
+++ b/patcher/src/jvmTest/kotlin/app/revanced/patcher/FingerprintTest.kt
@@ -0,0 +1,27 @@
+package app.revanced.patcher
+
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.TestInstance
+import kotlin.test.Test
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+internal class FingerprintTest : PatcherTestBase() {
+    @BeforeAll
+    fun setup() = setupMock()
+
+    @Test
+    fun `matches fingerprints correctly`() {
+        with(bytecodePatchContext) {
+            assertNotNull(
+                fingerprint { returns("V") }.originalMethodOrNull,
+                "Fingerprints should match correctly."
+            )
+            assertNull(
+                fingerprint { returns("does not exist") }.originalMethodOrNull,
+                "Fingerprints should match correctly."
+            )
+        }
+    }
+}
--- a/patcher/src/jvmTest/kotlin/app/revanced/patcher/MatchingTest.kt
+++ b/patcher/src/jvmTest/kotlin/app/revanced/patcher/MatchingTest.kt
@@ -0,0 +1,165 @@
+package app.revanced.patcher
+
+import app.revanced.patcher.BytecodePatchContextMethodMatching.firstMethod
+import app.revanced.patcher.BytecodePatchContextMethodMatching.firstMethodDeclarativelyOrNull
+import app.revanced.patcher.patch.bytecodePatch
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.iface.instruction.TwoRegisterInstruction
+import com.android.tools.smali.dexlib2.iface.instruction.formats.Instruction22t
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.TestInstance
+import org.junit.jupiter.api.assertDoesNotThrow
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class MatchingTest : PatcherTestBase() {
+    @BeforeAll
+    fun setup() = setupMock()
+
+    @Test
+    fun `finds via builder api`() {
+        fun firstMethodComposite(fail: Boolean = false) = firstMethodComposite {
+            name("method")
+            definingClass("class")
+
+            if (fail) returnType("doesnt exist")
+
+            instructions(
+                at(Opcode.CONST_STRING()),
+                `is`<TwoRegisterInstruction>(),
+                noneOf(registers()),
+                string("test", String::contains),
+                after(1..3, allOf(Opcode.INVOKE_VIRTUAL(), registers(1, 0))),
+                allOf(),
+                type("PrintStream;", String::endsWith)
+            )
+        }
+
+        with(bytecodePatchContext) {
+            assertNotNull(firstMethodComposite().methodOrNull) { "Expected to find a method" }
+            Assertions.assertNull(firstMethodComposite(fail = true).immutableMethodOrNull) { "Expected to not find a method" }
+            Assertions.assertNotNull(
+                firstMethodComposite().match(classDefs.first()).methodOrNull
+            ) { "Expected to find a method matching in a specific class" }
+        }
+    }
+
+    @Test
+    fun `finds via declarative api`() {
+        bytecodePatch {
+            apply {
+                val method = firstMethodDeclarativelyOrNull {
+                    anyOf {
+                        predicate { name == "method" }
+                        add { false }
+                    }
+                    allOf {
+                        predicate { returnType == "V" }
+                    }
+                    predicate { definingClass == "class" }
+                }
+                assertNotNull(method) { "Expected to find a method" }
+            }
+        }()
+    }
+
+    @Test
+    fun `predicate api works correctly`() {
+        bytecodePatch {
+            apply {
+                assertDoesNotThrow("Should find method") { firstMethod { name == "method" } }
+            }
+        }
+    }
+
+    @Test
+    fun `matcher finds indices correctly`() {
+        val iterable = (1..10).toList()
+        val matcher = indexedMatcher<Int>()
+
+        matcher.apply {
+            +at<Int> { this > 5 }
+        }
+        assertFalse(
+            matcher(iterable),
+            "Should not match at any other index than first"
+        )
+        matcher.clear()
+
+        matcher.apply { +at<Int> { this == 1 } }(iterable)
+        assertEquals(
+            listOf(0),
+            matcher.indices,
+            "Should match at first index."
+        )
+        matcher.clear()
+
+        matcher.apply { add { _, _, _ -> this > 0 } }(iterable)
+        assertEquals(1, matcher.indices.size, "Should only match once.")
+        matcher.clear()
+
+        matcher.apply { add { _, _, _ -> this == 2 } }(iterable)
+        assertEquals(
+            listOf(1),
+            matcher.indices,
+            "Should find the index correctly."
+        )
+        matcher.clear()
+
+        matcher.apply {
+            +at<Int> { this == 1 }
+            add { _, _, _ -> this == 2 }
+            add { _, _, _ -> this == 4 }
+        }(iterable)
+        assertEquals(
+            listOf(0, 1, 3),
+            matcher.indices,
+            "Should match 1, 2 and 4 at indices 0, 1 and 3."
+        )
+        matcher.clear()
+
+        matcher.apply {
+            +after<Int> { this == 1 }
+        }(iterable)
+        assertEquals(
+            listOf(0),
+            matcher.indices,
+            "Should match index 0 after nothing"
+        )
+        matcher.clear()
+
+        matcher.apply {
+            +after<Int>(2..Int.MAX_VALUE) { this == 1 }
+        }
+        assertFalse(
+            matcher(iterable),
+            "Should not match, because 1 is out of range"
+        )
+        matcher.clear()
+
+        matcher.apply {
+            +after<Int>(1..1) { this == 2 }
+        }
+        assertFalse(
+            matcher(iterable),
+            "Should not match, because 2 is at index 1"
+        )
+        matcher.clear()
+
+        matcher.apply {
+            +at<Int> { this == 1 }
+            +after<Int>(2..5) { this == 4 }
+            add { _, _, _ -> this == 8 }
+            add { _, _, _ -> this == 9 }
+        }(iterable)
+        assertEquals(
+            listOf(0, 3, 7, 8),
+            matcher.indices,
+            "Should match indices correctly."
+        )
+    }
+}
--- a/patcher/src/jvmTest/kotlin/app/revanced/patcher/PatcherTest.kt
+++ b/patcher/src/jvmTest/kotlin/app/revanced/patcher/PatcherTest.kt
@@ -0,0 +1,80 @@
+package app.revanced.patcher
+
+import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.patch.PatchException
+import app.revanced.patcher.patch.bytecodePatch
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.TestInstance
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+internal class PatcherTest : PatcherTestBase() {
+    @BeforeAll
+    fun setup() = setupMock()
+
+    @Test
+    fun `applies patches in correct order`() {
+        val applied = mutableListOf<String>()
+
+        infix fun Patch.resultsIn(equals: List<String>) = this to equals
+        infix fun Pair<Patch, List<String>>.because(reason: String) {
+            runCatching { setOf(first)() }
+
+            assertEquals(second, applied, reason)
+
+            applied.clear()
+        }
+
+        bytecodePatch {
+            dependsOn(
+                bytecodePatch {
+                    apply { applied += "1" }
+                    afterDependents { applied += "-2" }
+                },
+                bytecodePatch { apply { applied += "2" } },
+            )
+            apply { applied += "3" }
+            afterDependents { applied += "-1" }
+        } resultsIn listOf("1", "2", "3", "-1", "-2") because
+                "Patches should apply in post-order and afterDependents in pre-order."
+
+        bytecodePatch {
+            dependsOn(
+                bytecodePatch {
+                    apply { throw PatchException("1") }
+                    afterDependents { applied += "-2" }
+                },
+            )
+            apply { applied += "2" }
+            afterDependents { applied += "-1" }
+        } resultsIn emptyList() because
+                "Patches that depend on a patched that failed to apply should not be applied."
+
+        bytecodePatch {
+            dependsOn(
+                bytecodePatch {
+                    apply { applied += "1" }
+                    afterDependents { applied += "-2" }
+                },
+            )
+            apply { throw PatchException("2") }
+            afterDependents { applied += "-1" }
+        } resultsIn listOf("1", "-2") because
+                "afterDependents of a patch should not be called if it failed to apply."
+
+        bytecodePatch {
+            dependsOn(
+                bytecodePatch {
+                    apply { applied += "1" }
+                    afterDependents { applied += "-2" }
+                },
+            )
+            apply { applied += "2" }
+            afterDependents { throw PatchException("-1") }
+        } resultsIn listOf("1", "2", "-2") because
+                "afterDependents of a patch should be called " +
+                "regardless of dependant patches failing."
+    }
+}
--- a/patcher/src/jvmTest/kotlin/app/revanced/patcher/PatcherTestBase.kt
+++ b/patcher/src/jvmTest/kotlin/app/revanced/patcher/PatcherTestBase.kt
@@ -0,0 +1,105 @@
+package app.revanced.patcher
+
+import app.revanced.patcher.extensions.toInstructions
+import app.revanced.patcher.patch.BytecodePatchContext
+import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.patch.ResourcePatchContext
+import com.android.tools.smali.dexlib2.Opcodes
+import com.android.tools.smali.dexlib2.iface.DexFile
+import com.android.tools.smali.dexlib2.immutable.ImmutableClassDef
+import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
+import com.android.tools.smali.dexlib2.immutable.ImmutableMethodImplementation
+import io.mockk.every
+import io.mockk.justRun
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import lanchon.multidexlib2.MultiDexIO
+import java.io.File
+import java.io.InputStream
+
+abstract class PatcherTestBase {
+    protected lateinit var bytecodePatchContext: BytecodePatchContext
+    protected lateinit var resourcePatchContext: ResourcePatchContext
+
+    protected fun setupMock(
+        method: ImmutableMethod = ImmutableMethod(
+            "class",
+            "method",
+            emptyList(),
+            "V",
+            0,
+            null,
+            null,
+            ImmutableMethodImplementation(
+                2,
+                """
+                    const-string v0, "Hello, World!"
+                    iput-object v0, p0, Ljava/lang/System;->out:Ljava/io/PrintStream;
+                    iget-object v0, p0, Ljava/lang/System;->out:Ljava/io/PrintStream;
+                    return-void
+                    const-string v0, "This is a test."
+                    return-object v0
+                    invoke-virtual { p0, v0 }, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
+                    invoke-static { p0 }, Ljava/lang/System;->currentTimeMillis()J
+                    check-cast p0, Ljava/io/PrintStream;
+                """.toInstructions(),
+                null,
+                null
+            ),
+        ),
+    ) {
+        resourcePatchContext = mockk<ResourcePatchContext>(relaxed = true)
+        bytecodePatchContext = mockk<BytecodePatchContext> bytecodePatchContext@{
+            mockkStatic(MultiDexIO::readDexFile)
+            every {
+                MultiDexIO.readDexFile(
+                    any(),
+                    any(),
+                    any(),
+                    any(),
+                    any()
+                )
+            } returns mockk<DexFile> {
+                every { classes } returns mutableSetOf(
+                    ImmutableClassDef(
+                        "class",
+                        0,
+                        null,
+                        null,
+                        null,
+                        null,
+                        null,
+                        listOf(method),
+                    )
+                )
+                every { opcodes } returns Opcodes.getDefault()
+            }
+
+            every { this@bytecodePatchContext.getProperty("apkFile") } returns mockk<File>()
+
+            every { this@bytecodePatchContext.classDefs } returns ClassDefs().apply {
+                javaClass.getDeclaredMethod($$"initializeCache$patcher").apply {
+                    isAccessible = true
+                }.invoke(this)
+            }
+
+            every { get() } returns emptySet()
+
+            justRun { this@bytecodePatchContext["extendWith"](any<InputStream>()) }
+        }
+    }
+
+    protected operator fun Set<Patch>.invoke() {
+        runCatching {
+            apply(
+                bytecodePatchContext,
+                resourcePatchContext
+            ) { }
+        }.fold(
+            { it.dexFiles },
+            { it.printStackTrace() }
+        )
+    }
+
+    protected operator fun Patch.invoke() = setOf(this)()
+}
--- a/patcher/src/jvmTest/kotlin/app/revanced/patcher/extensions/MethodExtensionsTest.kt
+++ b/patcher/src/jvmTest/kotlin/app/revanced/patcher/extensions/MethodExtensionsTest.kt
@@ -1,16 +1,5 @@
 package app.revanced.patcher.extensions

-import app.revanced.patcher.extensions.InstructionExtensions.addInstruction
-import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
-import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
-import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
-import app.revanced.patcher.extensions.InstructionExtensions.removeInstruction
-import app.revanced.patcher.extensions.InstructionExtensions.removeInstructions
-import app.revanced.patcher.extensions.InstructionExtensions.replaceInstruction
-import app.revanced.patcher.extensions.InstructionExtensions.replaceInstructions
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
-import app.revanced.patcher.util.smali.ExternalLabel
 import com.android.tools.smali.dexlib2.AccessFlags
 import com.android.tools.smali.dexlib2.Opcode
 import com.android.tools.smali.dexlib2.builder.BuilderOffsetInstruction
@@ -18,28 +7,30 @@ import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
 import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction21s
 import com.android.tools.smali.dexlib2.iface.instruction.OneRegisterInstruction
 import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
+import com.android.tools.smali.dexlib2.mutable.MutableMethod
+import com.android.tools.smali.dexlib2.mutable.MutableMethod.Companion.toMutable
 import org.junit.jupiter.api.BeforeEach
 import kotlin.test.Test
 import kotlin.test.assertEquals

-private object InstructionExtensionsTest {
-    private lateinit var testMethod: MutableMethod
-    private lateinit var testMethodImplementation: MutableMethodImplementation
+internal class MethodExtensionsTest {
+    private val testInstructions = (0..9).map { i -> TestInstruction(i) }
+    private var method = ImmutableMethod(
+        "TestClass;",
+        "testMethod",
+        null,
+        "V",
+        AccessFlags.PUBLIC.value,
+        null,
+        null,
+        MutableMethodImplementation(16)
+    ).toMutable()

    @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 setup() {
+        method.instructions.clear()
+        method.addInstructions(testInstructions)
+    }

    @Test
    fun addInstructionsToImplementationIndexed() =
@@ -227,11 +218,11 @@ private object InstructionExtensionsTest {
    // region Helper methods

    private fun applyToImplementation(block: MutableMethodImplementation.() -> Unit) {
-        testMethodImplementation.apply(block)
+        method.implementation!!.apply(block)
    }

    private fun applyToMethod(block: MutableMethod.() -> Unit) {
-        testMethod.apply(block)
+        method.apply(block)
    }

    private fun MutableMethodImplementation.assertRegisterIs(
--- a/patcher/src/jvmTest/kotlin/app/revanced/patcher/patch/OptionsTest.kt
+++ b/patcher/src/jvmTest/kotlin/app/revanced/patcher/patch/OptionsTest.kt
@@ -0,0 +1,146 @@
+package app.revanced.patcher.patch
+
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.api.assertThrows
+import kotlin.reflect.typeOf
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+internal object OptionsTest {
+    private val externalOption = stringOption("external", "default")
+
+    private val optionsTestPatch = bytecodePatch {
+        externalOption()
+
+        booleanOption("bool", true)
+
+        stringOption("required", "default", required = true)
+
+        stringsOption("list", listOf("1", "2"))
+
+        stringOption("choices", "value", values = mapOf("Valid option value" to "valid"))
+
+        stringOption("validated", "default") { it == "valid" }
+
+        stringOption("resettable", null, required = true)
+    }
+
+    @Test
+    fun `should not fail because default value is unvalidated`() = options {
+        assertDoesNotThrow { get("required") }
+    }
+
+    @Test
+    fun `should not allow setting custom value with validation`() = options {
+        // Getter validation on incorrect value.
+        assertThrows<OptionException.ValueValidationException> {
+            set("validated", get("validated"))
+        }
+
+        // Setter validation on incorrect value.
+        assertThrows<OptionException.ValueValidationException> {
+            set("validated", "invalid")
+        }
+
+        // Setter validation on correct value.
+        assertDoesNotThrow {
+            set("validated", "valid")
+        }
+    }
+
+    @Test
+    fun `should throw due to incorrect type`() = options {
+        assertThrows<OptionException.InvalidValueTypeException> {
+            set("bool", "not a boolean")
+        }
+    }
+
+    @Test
+    fun `should be nullable`() = options {
+        assertDoesNotThrow {
+            set("bool", null)
+        }
+    }
+
+    @Test
+    fun `option should not be found`() = options {
+        assertThrows<OptionException.OptionNotFoundException> {
+            set("this option does not exist", 1)
+        }
+    }
+
+    @Test
+    fun `should be able to add options manually`() = options {
+        assertDoesNotThrow {
+            bytecodePatch {
+                get("list")()
+            }.options["list"]
+        }
+    }
+
+    @Test
+    fun `should allow setting value from values`() = options {
+        @Suppress("UNCHECKED_CAST")
+        val option = get("choices") as Option<String>
+
+        option.value = option.values!!.values.last()
+
+        assertTrue(option.value == "valid")
+    }
+
+    @Test
+    fun `should allow setting custom value`() = options {
+        assertDoesNotThrow {
+            set("choices", "unknown")
+        }
+    }
+
+    @Test
+    fun `should allow resetting value`() = options {
+        assertDoesNotThrow {
+            set("choices", null)
+        }
+
+        assert(get("choices").value == null)
+    }
+
+    @Test
+    fun `reset should not fail`() = options {
+        assertDoesNotThrow {
+            set("resettable", "test")
+            get("resettable").reset()
+        }
+
+        assertThrows<OptionException.ValueRequiredException> {
+            get("resettable").value
+        }
+    }
+
+    @Test
+    fun `option types should be known`() = options {
+        assertEquals(typeOf<List<String>>(), get("list").type)
+    }
+
+    @Test
+    fun `getting default value should work`() = options {
+        assertDoesNotThrow {
+            assertNull(get("resettable").default)
+        }
+    }
+
+    @Test
+    fun `external option should be accessible`() {
+        assertDoesNotThrow {
+            externalOption.value = "test"
+        }
+    }
+
+    @Test
+    fun `should allow getting the external option from the patch`() {
+        assertEquals(optionsTestPatch.options["external"].value, externalOption.value)
+    }
+
+    private fun options(block: Options.() -> Unit) = optionsTestPatch.options.let(block)
+}
--- a/patcher/src/jvmTest/kotlin/app/revanced/patcher/patch/PatchTest.kt
+++ b/patcher/src/jvmTest/kotlin/app/revanced/patcher/patch/PatchTest.kt
@@ -0,0 +1,85 @@
+package app.revanced.patcher.patch
+
+import kotlin.reflect.jvm.javaField
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+internal object PatchTest {
+    @Test
+    fun `can create patch with name`() {
+        val patch = bytecodePatch(name = "Test") {}
+
+        assertEquals("Test", patch.name)
+    }
+
+    @Test
+    fun `can create patch with compatible packages`() {
+        val patch = bytecodePatch(name = "Test") {
+            compatibleWith(
+                "compatible.package"("1.0.0"),
+            )
+        }
+
+        assertEquals(1, patch.compatiblePackages!!.size)
+        assertEquals("compatible.package", patch.compatiblePackages!!.first().first)
+    }
+
+    @Test
+    fun `can create patch with dependencies`() {
+        val patch = bytecodePatch(name = "Test") {
+            dependsOn(resourcePatch {})
+        }
+
+        assertEquals(1, patch.dependencies.size)
+    }
+
+    @Test
+    fun `can create patch with options`() {
+        val patch = bytecodePatch(name = "Test") {
+            val print by stringOption("print")
+            val custom = option<String>("custom")()
+
+            this.apply {
+                println(print)
+                println(custom.value)
+            }
+        }
+
+        assertEquals(2, patch.options.size)
+    }
+
+    @Test
+    fun `loads patches correctly`() {
+        val patchesClass = ::Public.javaField!!.declaringClass.name
+        val classLoader = ::Public.javaClass.classLoader
+
+        val patches = getPatches(listOf(patchesClass), classLoader)
+
+        assertEquals(
+            2,
+            patches.size,
+            "Expected 2 patches to be loaded, " +
+                    "because there's only two named patches declared as public static fields " +
+                    "or returned by public static and non-parametrized methods.",
+        )
+    }
+}
+
+val publicUnnamedPatch = bytecodePatch {} // Not loaded, because it's unnamed.
+
+val Public by creatingBytecodePatch {} // Loaded, because it's named.
+
+private val privateUnnamedPatch = bytecodePatch {} // Not loaded, because it's private.
+
+private val Private by creatingBytecodePatch {}  // Not loaded, because it's private.
+
+fun publicUnnamedPatchFunction() = publicUnnamedPatch // Not loaded, because it's unnamed.
+
+fun publicNamedPatchFunction() = bytecodePatch("Public") { } // Loaded, because it's named.
+
+fun parameterizedFunction(@Suppress("UNUSED_PARAMETER") param: Any) =
+    publicNamedPatchFunction() // Not loaded, because it's parameterized.
+
+private fun privateUnnamedPatchFunction() = privateUnnamedPatch // Not loaded, because it's private.
+
+private fun privateNamedPatchFunction() = Private // Not loaded, because it's private.
--- a/patcher/src/jvmTest/kotlin/app/revanced/patcher/util/SmaliTest.kt
+++ b/patcher/src/jvmTest/kotlin/app/revanced/patcher/util/SmaliTest.kt
@@ -0,0 +1,76 @@
+package app.revanced.patcher.util
+
+import app.revanced.patcher.extensions.*
+import com.android.tools.smali.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.builder.BuilderOffsetInstruction
+import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
+import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction21t
+import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
+import com.android.tools.smali.dexlib2.mutable.MutableMethod.Companion.toMutable
+import org.junit.jupiter.api.BeforeEach
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+internal class SmaliTest {
+    val method = ImmutableMethod(
+        "Ldummy;",
+        "name",
+        emptyList(), // parameters
+        "V",
+        AccessFlags.PUBLIC.value,
+        null,
+        null,
+        MutableMethodImplementation(1),
+    ).toMutable()
+
+
+    @BeforeEach
+    fun setup() {
+        method.instructions.clear()
+    }
+
+    @Test
+    fun `own branches work`() {
+        method.addInstructionsWithLabels(
+            0,
+            """
+                :test
+                const/4 v0, 0x1
+                if-eqz v0, :test
+            """,
+        )
+
+        val targetLocationIndex = method.getInstruction<BuilderOffsetInstruction>(1).target.location.index
+
+        assertEquals(0, targetLocationIndex, "Label should point to index 0")
+    }
+
+    @Test
+    fun `external branches work`() {
+        val instructionIndex = 3
+        val labelIndex = 1
+
+        method.addInstructions(
+            """
+                const/4 v0, 0x1
+                const/4 v0, 0x0
+            """,
+        )
+
+        method.addInstructionsWithLabels(
+            method.instructions.size,
+            """
+                const/4 v0, 0x1
+                if-eqz v0, :test
+                return-void
+            """,
+            ExternalLabel("test", method.getInstruction(1)),
+        )
+
+        val instruction = method.getInstruction<BuilderInstruction21t>(instructionIndex)
+
+        assertTrue(instruction.target.isPlaced, "Label should be placed")
+        assertEquals(labelIndex, instruction.target.location.index)
+    }
+}
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,7 +1,24 @@
 rootProject.name = "revanced-patcher"
+enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")

-buildCache {
-    local {
-        isEnabled = "CI" !in System.getenv()
+pluginManagement {
+    repositories {
+        mavenCentral()
+        google()
    }
 }
+
+dependencyResolutionManagement {
+    repositories {
+        mavenCentral()
+        google()
+        maven {
+            name = "githubPackages"
+            // A repository must be specified for some reason. "registry" is a dummy.
+            url = uri("https://maven.pkg.github.com/revanced/registry")
+            credentials(PasswordCredentials::class)
+        }
+    }
+}
+
+include(":patcher")
--- a/src/main/kotlin/app/revanced/patcher/IntegrationsConsumer.kt
+++ b/src/main/kotlin/app/revanced/patcher/IntegrationsConsumer.kt
@@ -1,11 +0,0 @@
-package app.revanced.patcher
-
-import java.io.File
-
-@FunctionalInterface
-interface IntegrationsConsumer {
-    fun acceptIntegrations(integrations: Set<File>)
-
-    @Deprecated("Use acceptIntegrations(Set<File>) instead.")
-    fun acceptIntegrations(integrations: List<File>)
-}
--- a/src/main/kotlin/app/revanced/patcher/InternalApi.kt
+++ b/src/main/kotlin/app/revanced/patcher/InternalApi.kt
@@ -1,7 +0,0 @@
-package app.revanced.patcher
-
-@RequiresOptIn(
-    level = RequiresOptIn.Level.ERROR,
-    message = "This is an internal API, don't rely on it.",
-)
-annotation class InternalApi
--- a/src/main/kotlin/app/revanced/patcher/PackageMetadata.kt
+++ b/src/main/kotlin/app/revanced/patcher/PackageMetadata.kt
@@ -1,16 +0,0 @@
-package app.revanced.patcher
-
-import brut.androlib.apk.ApkInfo
-
-/**
- * Metadata about a package.
- *
- * @param apkInfo The [ApkInfo] of the apk file.
- */
-class PackageMetadata internal constructor(internal val apkInfo: ApkInfo) {
-    lateinit var packageName: String
-        internal set
-
-    lateinit var packageVersion: String
-        internal set
-}
--- a/src/main/kotlin/app/revanced/patcher/PatchBundleLoader.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatchBundleLoader.kt
@@ -1,136 +0,0 @@
-@file:Suppress("unused")
-
-package app.revanced.patcher
-
-import app.revanced.patcher.patch.Patch
-import dalvik.system.DexClassLoader
-import lanchon.multidexlib2.BasicDexFileNamer
-import lanchon.multidexlib2.MultiDexIO
-import java.io.File
-import java.net.URLClassLoader
-import java.util.jar.JarFile
-import java.util.logging.Logger
-import kotlin.reflect.KClass
-
-
-/**
- * A set of [Patch]es.
- */
-typealias PatchSet = Set<Patch<*>>
-
-/**
- * A [Patch] class.
- */
-typealias PatchClass = KClass<out Patch<*>>
-
-/**
- * A loader of [Patch]es from patch bundles.
- * This will load all [Patch]es from the given patch bundles that have a name.
- *
- * @param getBinaryClassNames A function that returns the binary names of all classes in a patch bundle.
- * @param classLoader The [ClassLoader] to use for loading the classes.
- * @param patchBundles A set of patches to initialize this instance with.
- */
-sealed class PatchBundleLoader private constructor(
-    classLoader: ClassLoader,
-    patchBundles: Array<out File>,
-    getBinaryClassNames: (patchBundle: File) -> List<String>,
-    // 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(),
-) : PatchSet by patchSet {
-    private val logger = Logger.getLogger(PatchBundleLoader::class.java.name)
-
-    init {
-        patchBundles.flatMap(getBinaryClassNames).asSequence().map {
-            classLoader.loadClass(it)
-        }.filter {
-            Patch::class.java.isAssignableFrom(it)
-        }.mapNotNull { patchClass ->
-            patchClass.getInstance(logger, silent = true)
-        }.filter {
-            it.name != null
-        }.let { patches ->
-            patchSet.addAll(patches)
-        }
-    }
-
-    internal companion object Utils {
-        /**
-         * Instantiates a [Patch]. If the class is a singleton, the INSTANCE field will be used.
-         *
-         * @param logger The [Logger] to use for logging.
-         * @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<*>? {
-            return try {
-                getField("INSTANCE").get(null)
-            } catch (exception: NoSuchFieldException) {
-                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 is ignored.",
-                        )
-                    }
-
-                    return null
-                }
-            } as Patch<*>
-        }
-    }
-
-    /**
-     * A [PatchBundleLoader] for JAR files.
-     *
-     * @param patchBundles The path to patch bundles of JAR format.
-     */
-    class Jar(vararg patchBundles: File) : PatchBundleLoader(
-        URLClassLoader(patchBundles.map { it.toURI().toURL() }.toTypedArray()),
-        patchBundles,
-        { patchBundle ->
-            JarFile(patchBundle).entries().toList().filter { it.name.endsWith(".class") }
-                .map { it.name.replace('/', '.').replace(".class", "") }
-        },
-    )
-
-    /**
-     * A [PatchBundleLoader] for [Dex] files.
-     *
-     * @param patchBundles The path to patch bundles of DEX format.
-     * @param optimizedDexDirectory The directory to store optimized DEX files in.
-     * This parameter is deprecated and has no effect since API level 26.
-     */
-    class Dex(vararg patchBundles: File, optimizedDexDirectory: File? = null) : PatchBundleLoader(
-        DexClassLoader(
-            patchBundles.joinToString(File.pathSeparator) { it.absolutePath },
-            optimizedDexDirectory?.absolutePath,
-            null,
-            PatchBundleLoader::class.java.classLoader,
-        ),
-        patchBundles,
-        { patchBundle ->
-            MultiDexIO.readDexFile(true, patchBundle, BasicDexFileNamer(), null, null).classes
-                .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
@@ -1,8 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.patch.PatchResult
-import kotlinx.coroutines.flow.Flow
-import java.util.function.Function
-
-@FunctionalInterface
-interface PatchExecutorFunction : Function<Boolean, Flow<PatchResult>>
--- a/src/main/kotlin/app/revanced/patcher/Patcher.kt
+++ b/src/main/kotlin/app/revanced/patcher/Patcher.kt
@@ -1,270 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.PatchBundleLoader.Utils.getInstance
-import app.revanced.patcher.data.ResourceContext
-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
-import java.io.File
-import java.util.function.Supplier
-import java.util.logging.Logger
-
-/**
- * A Patcher.
- *
- * @param config The configuration to use for the patcher.
- */
-class Patcher(
-    private val config: PatcherConfig,
-) : PatchExecutorFunction, PatchesConsumer, IntegrationsConsumer, Supplier<PatcherResult>, Closeable {
-    private val logger = Logger.getLogger(Patcher::class.java.name)
-
-    /**
-     * A context for the patcher containing the current state of the patcher.
-     */
-    val context = PatcherContext(config)
-
-    @Suppress("DEPRECATION")
-    @Deprecated("Use Patcher(PatcherConfig) instead.")
-    constructor(
-        patcherOptions: PatcherOptions,
-    ) : this(
-        PatcherConfig(
-            patcherOptions.inputFile,
-            patcherOptions.resourceCachePath,
-            patcherOptions.aaptBinaryPath,
-            patcherOptions.frameworkFileDirectory,
-            patcherOptions.multithreadingDexFileWriter,
-        ),
-    )
-
-    init {
-        context.resourceContext.decodeResources(ResourceContext.ResourceMode.NONE)
-    }
-
-    /**
-     * Add [Patch]es to ReVanced [Patcher].
-     *
-     * @param patches The [Patch]es to add.
-     */
-    @Suppress("NAME_SHADOWING")
-    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.
-         */
-        fun PatchClass.putDependenciesRecursively() {
-            if (context.allPatches.contains(this)) return
-
-            val dependency = this.java.getInstance(logger)!!
-            context.allPatches[this] = dependency
-
-            dependency.dependencies?.forEach { it.putDependenciesRecursively() }
-        }
-
-        // Add all patches and their dependencies to the context.
-        patches.forEach { patch ->
-            context.executablePatches.putIfAbsent(patch::class, patch) ?: run {
-                context.allPatches[patch::class] = patch
-
-                patch.dependencies?.forEach { it.putDependenciesRecursively() }
-            }
-        }
-
-        // TODO: Detect circular dependencies.
-
-        /**
-         * Returns true if at least one patch or its dependencies matches the given predicate.
-         *
-         * @param predicate The predicate to match.
-         */
-        fun Patch<*>.anyRecursively(predicate: (Patch<*>) -> Boolean): Boolean =
-            predicate(this) || dependencies?.any { dependency ->
-                context.allPatches[dependency]!!.anyRecursively(predicate)
-            } ?: false
-
-        context.allPatches.values.let { patches ->
-            // Determine the resource mode.
-
-            config.resourceMode = if (patches.any { patch -> patch.anyRecursively { it is ResourcePatch } }) {
-                ResourceContext.ResourceMode.FULL
-            } else if (patches.any { patch -> patch.anyRecursively { it is RawResourcePatch } }) {
-                ResourceContext.ResourceMode.RAW_ONLY
-            } else {
-                ResourceContext.ResourceMode.NONE
-            }
-
-            // Determine, if merging integrations is required.
-            for (patch in patches)
-                if (patch.anyRecursively { it.requiresIntegrations }) {
-                    context.bytecodeContext.integrations.merge = true
-                    break
-                }
-        }
-    }
-
-    /**
-     * Add integrations to the [Patcher].
-     *
-     * @param integrations The integrations to add. Must be a DEX file or container of DEX files.
-     */
-    override fun acceptIntegrations(integrations: Set<File>) {
-        context.bytecodeContext.integrations.addAll(integrations)
-    }
-
-    @Deprecated(
-        "Use acceptIntegrations(Set<File>) instead.",
-        ReplaceWith("acceptIntegrations(integrations.toSet())"),
-    )
-    override fun acceptIntegrations(integrations: List<File>) = acceptIntegrations(integrations.toSet())
-
-    /**
-     * Execute [Patch]es that were added to ReVanced [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 {
-            /**
-             * 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.toString()
-
-                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"))
-                }
-
-                // 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()}",
-                            ),
-                        )
-                    }
-                }
-
-                return try {
-                    // TODO: Implement this in a more polymorphic way.
-                    when (patch) {
-                        is BytecodePatch -> {
-                            patch.fingerprints.resolveUsingLookupMap(context.bytecodeContext)
-                            patch.execute(context.bytecodeContext)
-                        }
-                        is RawResourcePatch -> {
-                            patch.execute(context.resourceContext)
-                        }
-                        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 }
-            }
-
-            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 (config.resourceMode != ResourceContext.ResourceMode.NONE) {
-                context.resourceContext.decodeResources(config.resourceMode)
-            }
-
-            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
-                        } catch (exception: PatchException) {
-                            PatchResult(patch, exception)
-                        } catch (exception: Exception) {
-                            PatchResult(patch, PatchException(exception))
-                        }
-
-                    result.exception?.let {
-                        emit(
-                            PatchResult(
-                                patch,
-                                PatchException(
-                                    "'$patch' 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.
-     */
-    @OptIn(InternalApi::class)
-    override fun get() =
-        PatcherResult(
-            context.bytecodeContext.get(),
-            context.resourceContext.get(),
-        )
-}
--- a/src/main/kotlin/app/revanced/patcher/PatcherConfig.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatcherConfig.kt
@@ -1,72 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.data.ResourceContext
-import brut.androlib.Config
-import java.io.File
-import java.util.logging.Logger
-
-/**
- * The configuration for the patcher.
- *
- * @param apkFile The apk file to patch.
- * @param temporaryFilesPath A path to a folder to store temporary files in.
- * @param aaptBinaryPath A path to a custom aapt binary.
- * @param frameworkFileDirectory A path to the directory to cache the framework file in.
- * @param multithreadingDexFileWriter Whether to use multiple threads for writing dex files.
- * This has impact on memory usage and performance.
- */
-class PatcherConfig(
-    internal val apkFile: File,
-    private val temporaryFilesPath: File = File("revanced-temporary-files"),
-    aaptBinaryPath: String? = null,
-    frameworkFileDirectory: String? = null,
-    internal val multithreadingDexFileWriter: Boolean = false,
-) {
-    private val logger = Logger.getLogger(PatcherConfig::class.java.name)
-
-    /**
-     * The mode to use for resource decoding and compiling.
-     *
-     * @see ResourceContext.ResourceMode
-     */
-    internal var resourceMode = ResourceContext.ResourceMode.NONE
-
-    /**
-     * The configuration for decoding and compiling resources.
-     */
-    internal val resourceConfig =
-        Config.getDefaultConfig().apply {
-            useAapt2 = true
-            aaptPath = aaptBinaryPath ?: ""
-            frameworkDirectory = frameworkFileDirectory
-        }
-
-    /**
-     * The path to the temporary apk files directory.
-     */
-    internal val apkFiles = temporaryFilesPath.resolve("apk")
-
-    /**
-     * The path to the temporary patched files directory.
-     */
-    internal val patchedFiles = temporaryFilesPath.resolve("patched")
-
-    /**
-     * Initialize the temporary files' directories.
-     * This will delete the existing temporary files directory if it exists.
-     */
-    internal fun initializeTemporaryFilesDirectories() {
-        temporaryFilesPath.apply {
-            if (exists()) {
-                logger.info("Deleting existing temporary files directory")
-
-                if (!deleteRecursively()) {
-                    logger.severe("Failed to delete existing temporary files directory")
-                }
-            }
-        }
-
-        apkFiles.mkdirs()
-        patchedFiles.mkdirs()
-    }
-}
--- a/src/main/kotlin/app/revanced/patcher/PatcherContext.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatcherContext.kt
@@ -1,40 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.patch.Patch
-import brut.androlib.apk.ApkInfo
-import brut.directory.ExtFile
-
-/**
- * A context for the patcher containing the current state of the patcher.
- *
- * @param config The configuration for the patcher.
- */
-@Suppress("MemberVisibilityCanBePrivate")
-class PatcherContext internal constructor(config: PatcherConfig) {
-    /**
-     * [PackageMetadata] of the supplied [PatcherConfig.apkFile].
-     */
-    val packageMetadata = PackageMetadata(ApkInfo(ExtFile(config.apkFile)))
-
-    /**
-     * The map of [Patch]es associated by their [PatchClass].
-     */
-    internal val executablePatches = mutableMapOf<PatchClass, Patch<*>>()
-
-    /**
-     * The map of all [Patch]es and their dependencies associated by their [PatchClass].
-     */
-    internal val allPatches = mutableMapOf<PatchClass, Patch<*>>()
-
-    /**
-     * A context for the patcher containing the current state of the resources.
-     */
-    internal val resourceContext = ResourceContext(packageMetadata, config)
-
-    /**
-     * A context for the patcher containing the current state of the bytecode.
-     */
-    internal val bytecodeContext = BytecodeContext(config)
-}
--- a/src/main/kotlin/app/revanced/patcher/PatcherException.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatcherException.kt
@@ -1,15 +0,0 @@
-package app.revanced.patcher
-
-/**
- * An exception thrown by ReVanced [Patcher].
- *
- * @param errorMessage The exception message.
- * @param cause The corresponding [Throwable].
- */
-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",
-    )
-}
--- a/src/main/kotlin/app/revanced/patcher/PatcherOptions.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatcherOptions.kt
@@ -1,25 +0,0 @@
-package app.revanced.patcher
-
-import java.io.File
-
-@Deprecated("Use PatcherConfig instead.")
-data class PatcherOptions(
-    internal val inputFile: File,
-    internal val resourceCachePath: File = File("revanced-resource-cache"),
-    internal val aaptBinaryPath: String? = null,
-    internal val frameworkFileDirectory: String? = null,
-    internal val multithreadingDexFileWriter: Boolean = false,
-) {
-    @Deprecated("This method will be removed in the future.")
-    fun recreateResourceCacheDirectory(): File {
-        PatcherConfig(
-            inputFile,
-            resourceCachePath,
-            aaptBinaryPath,
-            frameworkFileDirectory,
-            multithreadingDexFileWriter,
-        ).initializeTemporaryFilesDirectories()
-
-        return resourceCachePath
-    }
-}
--- a/src/main/kotlin/app/revanced/patcher/PatcherResult.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatcherResult.kt
@@ -1,125 +0,0 @@
-package app.revanced.patcher
-
-import java.io.File
-import java.io.InputStream
-import kotlin.jvm.internal.Intrinsics
-
-/**
- * The result of a patcher.
- *
- * @param dexFiles The patched dex files.
- * @param resources The patched resources.
- */
-@Suppress("MemberVisibilityCanBePrivate")
-class PatcherResult internal constructor(
-    val dexFiles: Set<PatchedDexFile>,
-    val resources: PatchedResources?,
-) {
-    @Deprecated("This method is not used anymore")
-    constructor(
-        dexFiles: List<PatchedDexFile>,
-        resourceFile: File?,
-        doNotCompress: List<String>? = null,
-    ) : this(dexFiles.toSet(), PatchedResources(resourceFile, null, doNotCompress?.toSet() ?: emptySet(), emptySet()))
-
-    @Deprecated("This method is not used anymore")
-    fun component1(): List<PatchedDexFile> {
-        return dexFiles.toList()
-    }
-
-    @Deprecated("This method is not used anymore")
-    fun component2(): File? {
-        return resources?.resourcesApk
-    }
-
-    @Deprecated("This method is not used anymore")
-    fun component3(): List<String>? {
-        return resources?.doNotCompress?.toList()
-    }
-
-    @Deprecated("This method is not used anymore")
-    fun copy(
-        dexFiles: List<PatchedDexFile>,
-        resourceFile: File?,
-        doNotCompress: List<String>? = null,
-    ): PatcherResult {
-        return PatcherResult(
-            dexFiles.toSet(),
-            PatchedResources(
-                resourceFile,
-                null,
-                doNotCompress?.toSet() ?: emptySet(),
-                emptySet(),
-            ),
-        )
-    }
-
-    @Deprecated("This method is not used anymore")
-    override fun toString(): String {
-        return (("PatcherResult(dexFiles=" + this.dexFiles + ", resourceFile=" + this.resources?.resourcesApk) + ", doNotCompress=" + this.resources?.doNotCompress) + ")"
-    }
-
-    @Deprecated("This method is not used anymore")
-    override fun hashCode(): Int {
-        val result = dexFiles.hashCode()
-        return (
-            (
-                (result * 31) +
-                    (if (this.resources?.resourcesApk == null) 0 else this.resources.resourcesApk.hashCode())
-                ) * 31
-            ) +
-            (if (this.resources?.doNotCompress == null) 0 else this.resources.doNotCompress.hashCode())
-    }
-
-    @Deprecated("This method is not used anymore")
-    override fun equals(other: Any?): Boolean {
-        if (this === other) {
-            return true
-        }
-        if (other is PatcherResult) {
-            return Intrinsics.areEqual(this.dexFiles, other.dexFiles) && Intrinsics.areEqual(
-                this.resources?.resourcesApk,
-                other.resources?.resourcesApk,
-            ) && Intrinsics.areEqual(this.resources?.doNotCompress, other.resources?.doNotCompress)
-        }
-        return false
-    }
-
-    @Suppress("DEPRECATION")
-    @Deprecated("This method is not used anymore")
-    fun getDexFiles() = component1()
-
-    @Suppress("DEPRECATION")
-    @Deprecated("This method is not used anymore")
-    fun getResourceFile() = component2()
-
-    @Suppress("DEPRECATION")
-    @Deprecated("This method is not used anymore")
-    fun getDoNotCompress() = component3()
-
-    /**
-     * A dex file.
-     *
-     * @param name The original name of the dex file.
-     * @param stream The dex file as [InputStream].
-     */
-    class PatchedDexFile
-    // TODO: Add internal modifier.
-    @Deprecated("This constructor will be removed in the future.")
-    constructor(val name: String, val stream: InputStream)
-
-    /**
-     * The resources of a patched apk.
-     *
-     * @param resourcesApk The compiled resources.apk file.
-     * @param otherResources The directory containing other resources files.
-     * @param doNotCompress List of files that should not be compressed.
-     * @param deleteResources List of predicates about resources that should be deleted.
-     */
-    class PatchedResources internal constructor(
-        val resourcesApk: File?,
-        val otherResources: File?,
-        val doNotCompress: Set<String>,
-        val deleteResources: Set<(String) -> Boolean>,
-    )
-}
--- a/src/main/kotlin/app/revanced/patcher/PatchesConsumer.kt
+++ b/src/main/kotlin/app/revanced/patcher/PatchesConsumer.kt
@@ -1,10 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.patch.Patch
-
-@FunctionalInterface
-interface PatchesConsumer {
-    @Deprecated("Use acceptPatches(PatchSet) instead.", ReplaceWith("acceptPatches(patches.toSet())"))
-    fun acceptPatches(patches: List<Patch<*>>) = acceptPatches(patches.toSet())
-    fun acceptPatches(patches: PatchSet)
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
oSumAtrIX	91cb464a27	fix nullability	2026-01-11 03:09:49 +01:00
oSumAtrIX	dc8565e8a6	use context params for apis	2026-01-09 19:06:50 +01:00
oSumAtrIX	1a052b9787	contextualize delegate variants and composite api	2026-01-09 18:53:35 +01:00
oSumAtrIX	ed56bf49ad	make typealiases public	2026-01-09 16:02:46 +01:00
oSumAtrIX	56fd65d6ce	formatting	2026-01-08 00:51:56 +01:00
oSumAtrIX	5674c1f2a2	more completeness	2026-01-08 00:51:17 +01:00
oSumAtrIX	d2461f92aa	more or less finish composite api	2026-01-06 04:06:37 +01:00
oSumAtrIX	18570656cc	merge matching and tests module with patcher, make builder api context aware and refactor	2025-12-30 00:02:16 +01:00
oSumAtrIX	005c91bc08	Modernize patch api names, deprecate fingerprints, simplify patching code even more, add mutablemethod implementation setter, refactor tests and improve for better coverage	2025-12-29 07:41:07 +01:00
oSumAtrIX	f17fbd8c40	Refactor matching API into separate module, simplify & refactor matching code, convert patcher to functions/DSL, refactor & greatly simplify internal code, refactor & simplify patch api internal code, update deps, fix workflow, add callback for patches files failed to load to be able to be able to load the rest of the patches	2025-12-29 03:41:10 +01:00
oSumAtrIX	2c97de2894	Use Kotlin Multiplatform, update to new binary compatibility plugin, more or less finish composite api, modularize project for separation of APIs, update Gradle wrapper, add new handy declarative predicate APIs, use new publishing plugin, simplify/modernize build system, standardize gitignore, and optimize build properties for performance	2025-12-14 03:17:33 +01:00
oSumAtrIX	2509997432	feat: Fix property delegates & add cache	2025-11-30 19:21:35 +01:00
oSumAtrIX	58ff464192	feat: Simplify composite API	2025-11-28 17:43:51 +01:00
oSumAtrIX	4106ce4070	feat: Composition API	2025-11-28 16:10:58 +01:00
oSumAtrIX	e6eaf6cb73	feat: Infer cache key from unique instance hashcode	2025-11-28 14:25:35 +01:00
oSumAtrIX	c56ac7a81f	fix: Everything works now	2025-11-27 00:36:36 +01:00
oSumAtrIX	cdc480acea	fix: More bugfixes, patches now compile	2025-11-26 23:12:46 +01:00
oSumAtrIX	14f2eb69e4	fix: Couple more matching fixes	2025-11-26 10:25:19 +01:00
oSumAtrIX	fcdaf324fe	fix: Do not create a new matcher instance if provided with one	2025-11-23 16:02:26 +01:00
oSumAtrIX	8653d8304b	feat: Appy upstream	2025-11-22 23:20:51 +01:00
oSumAtrIX	e2c781f12c	feat: Builds now	2025-11-22 19:23:48 +01:00
oSumAtrIX	0b5e8b791d	feat: More progress towards compatibility	2025-11-20 20:08:22 +01:00
oSumAtrIX	cf57726bbb	feat: More APIs/adjustments	2025-11-19 20:08:49 +01:00
oSumAtrIX	79d3640186	feat: Modernize APIs	2025-11-19 00:20:41 +01:00
semantic-release-bot	3a8b2ba935	chore: Release v21.1.0-dev.5 [skip ci] # [21.1.0-dev.5](https://github.com/ReVanced/revanced-patcher/compare/v21.1.0-dev.4...v21.1.0-dev.5) (2025-10-16)	2025-10-16 15:03:36 +00:00
dependabot[bot]	39c5a66ce3	build(Needs bump): Bump dependencies	2025-10-16 17:01:58 +02:00
semantic-release-bot	b160a2adc0	chore: Release v21.1.0-dev.4 [skip ci] # [21.1.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v21.1.0-dev.3...v21.1.0-dev.4) (2025-07-18) ### Bug Fixes * Correctly save XML files in UTF-8 by using a bufferedWriter ([#356](https://github.com/ReVanced/revanced-patcher/issues/356)) ([`33fadcb`](`33fadcbd0c`))	2025-07-18 19:33:42 +00:00
kitadai31	33fadcbd0c	fix: Correctly save XML files in UTF-8 by using a bufferedWriter (#356 )	2025-07-18 21:31:51 +02:00
semantic-release-bot	68db95b99b	chore: Release v21.1.0-dev.3 [skip ci] # [21.1.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v21.1.0-dev.2...v21.1.0-dev.3) (2025-06-20) ### Bug Fixes * Encode XML files as UTF-8 to fix compilation of resources ([#339](https://github.com/ReVanced/revanced-patcher/issues/339)) ([`4f2ef3c`](`4f2ef3c47c`))	2025-06-20 14:44:18 +00:00
Pg	4f2ef3c47c	fix: Encode XML files as UTF-8 to fix compilation of resources (#339 ) Co-authored-by: kitadai31 <90122968+kitadai31@users.noreply.github.com> Co-authored-by: oSumAtrIX <johan.melkonyan1@web.de>	2025-06-20 16:41:53 +02:00
semantic-release-bot	062ae14936	chore: Release v21.1.0-dev.2 [skip ci] # [21.1.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v21.1.0-dev.1...v21.1.0-dev.2) (2025-06-20) ### Bug Fixes * Add back missing log by naming logger correctly ([#332](https://github.com/ReVanced/revanced-patcher/issues/332)) ([`e4e66b0`](`e4e66b0d8b`)) * Support UTF-8 chars when compiling instructions in Smali in non UTF-8 environments ([#331](https://github.com/ReVanced/revanced-patcher/issues/331)) ([`bb8771b`](`bb8771bb8b`)) ### Features * Use option name as key for simplicity and consistency ([`754b02e`](`754b02e4ca`)) ### Performance Improvements * Use a buffered writer to reduce IO overhead ([#347](https://github.com/ReVanced/revanced-patcher/issues/347)) ([`99f4318`](`99f431897e`))	2025-06-20 13:28:31 +00:00
Pg	99f431897e	perf: Use a buffered writer to reduce IO overhead (#347 )	2025-06-20 15:26:10 +02:00
oSumAtrIX	d80abbcd17	docs: Correct API usage of fingerprints	2025-03-10 13:52:09 +01:00
oSumAtrIX	509ecc81e1	docs: Correct API usage of fingerprints	2025-03-10 13:47:55 +01:00
kitadai31	e4e66b0d8b	fix: Add back missing log by naming logger correctly (#332 )	2025-01-20 00:40:26 +01:00
Vologhat	bb8771bb8b	fix: Support UTF-8 chars when compiling instructions in Smali in non UTF-8 environments (#331 )	2025-01-07 01:30:21 +01:00
oSumAtrIX	754b02e4ca	feat: Use option name as key for simplicity and consistency	2024-12-24 16:47:48 +01:00
oSumAtrIX	fe5fb736cb	build: Bump dependencies	2024-12-17 04:20:28 +01:00
semantic-release-bot	fc505a8726	chore: Release v21.1.0-dev.1 [skip ci] # [21.1.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0...v21.1.0-dev.1) (2024-12-07) ### Features * Add identity hash code to unnamed patches ([`88a3252`](`88a3252574`))	2024-12-07 05:20:15 +00:00
oSumAtrIX	88a3252574	feat: Add identity hash code to unnamed patches	2024-12-07 06:19:08 +01:00
semantic-release-bot	ead701bdaf	chore: Release v21.0.0 [skip ci] # [21.0.0](https://github.com/ReVanced/revanced-patcher/compare/v20.0.2...v21.0.0) (2024-11-05) ### Bug Fixes * Match fingerprint before delegating the match property ([`5d996de`](`5d996def4d`)) * Merge extension only when patch executes ([#315](https://github.com/ReVanced/revanced-patcher/issues/315)) ([`aa472eb`](`aa472eb985`)) ### Features * Improve Fingerprint API ([#316](https://github.com/ReVanced/revanced-patcher/issues/316)) ([`0abf1c6`](`0abf1c6c02`)) * Improve various APIs ([#317](https://github.com/ReVanced/revanced-patcher/issues/317)) ([`b824978`](`b8249789df`)) * Move fingerprint match members to fingerprint for ease of access by using context receivers ([`0746c22`](`0746c22743`)) ### Performance Improvements * Use smallest lookup map for strings ([`1358d3f`](`1358d3fa10`)) ### BREAKING CHANGES * Various APIs have been changed. * Many APIs have been changed.	2024-11-05 18:18:41 +00:00
oSumAtrIX	0581dcf931	chore: Merge branch `dev` to `main`	2024-11-05 19:16:28 +01:00
semantic-release-bot	62191e3c4a	chore: Release v21.0.0-dev.4 [skip ci] # [21.0.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0-dev.3...v21.0.0-dev.4) (2024-11-05) ### Performance Improvements * Use smallest lookup map for strings ([`1358d3f`](`1358d3fa10`))	2024-11-05 13:41:06 +00:00
oSumAtrIX	1358d3fa10	perf: Use smallest lookup map for strings	2024-11-05 14:39:18 +01:00
semantic-release-bot	6712f0ea72	chore: Release v21.0.0-dev.3 [skip ci] # [21.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0-dev.2...v21.0.0-dev.3) (2024-11-05) ### Features * Move fingerprint match members to fingerprint for ease of access by using context receivers ([`0746c22`](`0746c22743`))	2024-11-05 13:25:22 +00:00
oSumAtrIX	0746c22743	feat: Move fingerprint match members to fingerprint for ease of access by using context receivers	2024-11-05 14:23:19 +01:00
semantic-release-bot	7f55868e6f	chore: Release v21.0.0-dev.2 [skip ci] # [21.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v21.0.0-dev.1...v21.0.0-dev.2) (2024-11-01) ### Bug Fixes * Match fingerprint before delegating the match property ([`5d996de`](`5d996def4d`))	2024-11-01 01:49:47 +00:00
oSumAtrIX	5d996def4d	fix: Match fingerprint before delegating the match property	2024-11-01 02:47:57 +01:00
semantic-release-bot	49f4570164	chore: Release v21.0.0-dev.1 [skip ci] # [21.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v20.0.2...v21.0.0-dev.1) (2024-10-27) ### Bug Fixes * Merge extension only when patch executes ([#315](https://github.com/ReVanced/revanced-patcher/issues/315)) ([`aa472eb`](`aa472eb985`)) ### Features * Improve Fingerprint API ([#316](https://github.com/ReVanced/revanced-patcher/issues/316)) ([`0abf1c6`](`0abf1c6c02`)) * Improve various APIs ([#317](https://github.com/ReVanced/revanced-patcher/issues/317)) ([`b824978`](`b8249789df`)) ### BREAKING CHANGES * Various APIs have been changed. * Many APIs have been changed.	2024-10-27 15:08:13 +00:00
oSumAtrIX	b8249789df	feat: Improve various APIs (#317 ) Some APIs have been slightly changed, and API docs have been added. BREAKING CHANGE: Various APIs have been changed.	2024-10-27 16:06:25 +01:00
oSumAtrIX	0abf1c6c02	feat: Improve Fingerprint API (#316 ) Fingerprints can now be matched easily without adding them to a patch first. BREAKING CHANGE: Many APIs have been changed.	2024-10-27 16:04:30 +01:00
oSumAtrIX	aa472eb985	fix: Merge extension only when patch executes (#315 )	2024-10-27 16:00:30 +01:00
semantic-release-bot	ab624f04f6	chore: Release v20.0.2 [skip ci] ## [20.0.2](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1...v20.0.2) (2024-10-17) ### Bug Fixes * Make it work on Android 12 and lower by using existing APIs ([#312](https://github.com/ReVanced/revanced-patcher/issues/312)) ([`a44802e`](`a44802ef4e`))	2024-10-17 18:03:27 +00:00
oSumAtrIX	21b5c079fb	chore: Merge branch `dev` to `main` (#314 )	2024-10-17 20:01:49 +02:00
semantic-release-bot	5024204046	chore: Release v20.0.2-dev.1 [skip ci] ## [20.0.2-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1...v20.0.2-dev.1) (2024-10-15) ### Bug Fixes * Make it work on Android 12 and lower by using existing APIs ([#312](https://github.com/ReVanced/revanced-patcher/issues/312)) ([`a44802e`](`a44802ef4e`))	2024-10-15 11:41:01 +00:00
LisoUseInAIKyrios	a44802ef4e	fix: Make it work on Android 12 and lower by using existing APIs (#312 ) Co-authored-by: oSumAtrIX <johan.melkonyan1@web.de>	2024-10-15 13:39:33 +02:00
semantic-release-bot	4c1c34ad01	chore: Release v20.0.1 [skip ci] ## [20.0.1](https://github.com/ReVanced/revanced-patcher/compare/v20.0.0...v20.0.1) (2024-10-13) ### Bug Fixes * Check for class type exactly instead of with contains ([#310](https://github.com/ReVanced/revanced-patcher/issues/310)) ([`69f2f20`](`69f2f20fd9`)) * Make it work on Android by not using APIs from JVM unavailable to Android. ([`2be6e97`](`2be6e97817`)) * Use non-nullable type for options ([`ea6fc70`](`ea6fc70caa`)) ### Performance Improvements * Free memory earlier and remove negligible lookup maps ([`d53aacd`](`d53aacdad4`))	2024-10-13 01:54:23 +00:00
oSumAtrIX	b2aecb726d	chore: Merge branch `dev` to `main` (#304 )	2024-10-13 03:52:31 +02:00
semantic-release-bot	851f9c7885	chore: Release v20.0.1-dev.5 [skip ci] ## [20.0.1-dev.5](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1-dev.4...v20.0.1-dev.5) (2024-10-11) ### Bug Fixes * Use non-nullable type for options ([`ea6fc70`](`ea6fc70caa`))	2024-10-11 03:30:03 +00:00
oSumAtrIX	ea6fc70caa	fix: Use non-nullable type for options	2024-10-11 05:28:15 +02:00
semantic-release-bot	a2875d1d64	chore: Release v20.0.1-dev.4 [skip ci] ## [20.0.1-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1-dev.3...v20.0.1-dev.4) (2024-10-07) ### Bug Fixes * Make it work on Android by not using APIs from JVM unavailable to Android. ([`2be6e97`](`2be6e97817`))	2024-10-07 16:27:20 +00:00
oSumAtrIX	2be6e97817	fix: Make it work on Android by not using APIs from JVM unavailable to Android.	2024-10-07 18:25:43 +02:00
semantic-release-bot	348d0070e7	chore: Release v20.0.1-dev.3 [skip ci] ## [20.0.1-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1-dev.2...v20.0.1-dev.3) (2024-10-03) ### Performance Improvements * Free memory earlier and remove negligible lookup maps ([`d53aacd`](`d53aacdad4`))	2024-10-03 14:08:34 +00:00
oSumAtrIX	d53aacdad4	perf: Free memory earlier and remove negligible lookup maps Negligible lookup maps used for matching fingerprints have been removed to reduce the likelihood of OOM when the maps are instantiated, commonly observed with 400M RAM. Additionally, lookup maps previously kept for the duration of the patcher instance are now cleared before the classes are compiled. This reduces the likelihood of OOM when compiling classes. On a related note, a linear increase in memory usage is observed with every compiled class until all classes are compiled implying compiled classes not being freed by GC because they are still referenced. After compiling a class, the class is technically free-able though. The classes are assumed to be referenced in the `multidexlib2` library that takes the list of all classes to compile multiple DEX with and seems to hold the reference to all these classes in memory until all DEX are compiled. A clever fix would involve splitting the list of classes into chunks and getting rid of the list of all classes so that after every DEX compilation, the corresponding split of classes can be freed.	2024-10-03 16:06:42 +02:00
semantic-release-bot	f1615b7ab5	chore: Release v20.0.1-dev.2 [skip ci] ## [20.0.1-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v20.0.1-dev.1...v20.0.1-dev.2) (2024-10-01)	2024-10-01 15:31:49 +00:00
oSumAtrIX	ffb1d880d7	ci: Use permissions and regular GitHub token instead of PAT	2024-10-01 17:25:49 +02:00
oSumAtrIX	e95f13ae3e	build(Needs bump): Update dependencies	2024-09-30 23:21:44 +02:00
oSumAtrIX	e1b984d601	ci: Adjust release commit message	2024-09-30 22:34:23 +02:00
semantic-release-bot	c2dc29e061	chore(release): 20.0.1-dev.1 [skip ci] ## [20.0.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v20.0.0...v20.0.1-dev.1) (2024-09-18) ### Bug Fixes * Check for class type exactly instead of with contains ([#310](https://github.com/ReVanced/revanced-patcher/issues/310)) ([`69f2f20`](`69f2f20fd9`))	2024-09-18 12:38:03 +00:00
oSumAtrIX	69f2f20fd9	fix: Check for class type exactly instead of with contains (#310 )	2024-09-18 14:36:15 +02:00
Pg	525beda18e	docs: Fix code example (#306 )	2024-08-29 08:59:33 +02:00
oSumAtrIX	73d3cbf4ff	build: Bump Gradle Wrapper to 8.9	2024-08-06 17:46:39 +02:00
semantic-release-bot	70278dd79d	chore(release): 20.0.0 [skip ci] # [20.0.0](https://github.com/ReVanced/revanced-patcher/compare/v19.3.1...v20.0.0) (2024-08-06) ### Bug Fixes * Downgrade smali to fix dex compilation issue ([`5227e98`](`5227e98abf`)) * Improve exception message wording ([`5481d0c`](`5481d0c54c`)) * Make constructor internal as supposed ([`7f44174`](`7f44174d91`)) * Merge all extensions before initializing lookup maps ([`8c4dd5b`](`8c4dd5b3a3`)) * Use null for compatible package version when adding packages only ([`736b3ee`](`736b3eebbf`)) ### Features * Add ability to create options outside of a patch ([`d310246`](`d310246852`)) * Convert APIs to Kotlin DSL ([#298](https://github.com/ReVanced/revanced-patcher/issues/298)) ([`11a911d`](`11a911dc67`)) ### BREAKING CHANGES * Various old APIs are removed, and DSL APIs are added instead.	2024-08-06 14:56:20 +00:00
oSumAtrIX	5e98e9e30a	chore: Merge branch `dev` to `main` (#279 )	2024-08-06 16:54:38 +02:00
semantic-release-bot	ac1aff5a1a	chore(release): 20.0.0-dev.4 [skip ci] # [20.0.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v20.0.0-dev.3...v20.0.0-dev.4) (2024-08-06) ### Bug Fixes * Improve exception message wording ([`bd434ce`](`bd434ceb33`))	2024-08-06 16:53:42 +02:00
oSumAtrIX	5481d0c54c	fix: Improve exception message wording	2024-08-06 16:53:42 +02:00
semantic-release-bot	4604742d0f	chore(release): 20.0.0-dev.3 [skip ci] # [20.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v20.0.0-dev.2...v20.0.0-dev.3) (2024-08-01) ### Bug Fixes * Make constructor internal as supposed ([`e95fcd1`](`e95fcd1c0b`)) ### Features * Add ability to create options outside of a patch ([`b8d763a`](`b8d763a66e`))	2024-08-06 16:53:42 +02:00
oSumAtrIX	4beb907a61	refactor: Sort dependencies	2024-08-06 16:53:42 +02:00
oSumAtrIX	7f44174d91	fix: Make constructor internal as supposed	2024-08-06 16:53:42 +02:00
oSumAtrIX	d310246852	feat: Add ability to create options outside of a patch	2024-08-06 16:53:42 +02:00
semantic-release-bot	dcc989243c	chore(release): 20.0.0-dev.2 [skip ci] # [20.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v20.0.0-dev.1...v20.0.0-dev.2) (2024-07-31) ### Bug Fixes * Downgrade smali to fix dex compilation issue ([`714447d`](`714447de70`)) * Merge all extensions before initializing lookup maps ([`328aa87`](`328aa876d8`)) * Use null for compatible package version when adding packages only ([`a8e8fa4`](`a8e8fa4093`))	2024-08-06 16:53:42 +02:00
oSumAtrIX	5227e98abf	fix: Downgrade smali to fix dex compilation issue	2024-08-06 16:53:42 +02:00
oSumAtrIX	8c4dd5b3a3	fix: Merge all extensions before initializing lookup maps	2024-08-06 16:53:42 +02:00
oSumAtrIX	736b3eebbf	fix: Use null for compatible package version when adding packages only	2024-08-06 16:53:42 +02:00
oSumAtrIX	b41a542952	refactor: Convert method bodies to single expression functions	2024-08-06 16:53:42 +02:00
oSumAtrIX	d21128fe2e	build(Needs bump): Bump dependencies	2024-08-06 16:53:42 +02:00
oSumAtrIX	cf4374b8cf	docs: Fix syntax issues and improve wording	2024-08-06 16:53:42 +02:00
semantic-release-bot	8a30b0fa10	chore(release): 20.0.0-dev.1 [skip ci] # [20.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v19.3.1...v20.0.0-dev.1) (2024-07-22) ### Features * Convert APIs to Kotlin DSL ([#298](https://github.com/ReVanced/revanced-patcher/issues/298)) ([`3f9cbd2`](`3f9cbd2408`)) ### BREAKING CHANGES * Various old APIs are removed, and DSL APIs are added instead.	2024-08-06 16:53:42 +02:00
oSumAtrIX	11a911dc67	feat: Convert APIs to Kotlin DSL (#298 ) This commit converts various APIs to Kotlin DSL. BREAKING CHANGE: Various old APIs are removed, and DSL APIs are added instead.	2024-08-06 16:53:42 +02:00
oSumAtrIX	6e3ba7419b	ci: Correct usage of repository variable	2024-08-06 16:53:42 +02:00
oSumAtrIX	50a66ccfed	docs: Improve issue templates	2024-08-06 16:53:42 +02:00
oSumAtrIX	0be79840b1	chore: Fix spelling mistake	2024-08-06 16:53:42 +02:00
Vologhat	d8b4c60321	refactor: Simplify mapping classes to their names (#290 ) Co-authored-by: oSumAtrIX <johan.melkonyan1@web.de>	2024-08-06 16:53:42 +02:00
oSumAtrIX	f77e99e817	build: Publish sources	2024-08-06 16:53:42 +02:00
oSumAtrIX	ea26c486c0	build: Set target bytecode level to JVM 11	2024-08-06 16:53:42 +02:00
oSumAtrIX	bebb734608	ci: Update action	2024-08-06 16:53:42 +02:00
oSumAtrIX	d842f82d07	chore: Lint code	2024-08-06 16:53:42 +02:00
oSumAtrIX	82bab58ac2	build: Bump dependencies	2024-08-06 16:53:42 +02:00
oSumAtrIX	90b7631d9e	refactor: Properly abstract `Patch#execute` function	2024-08-06 16:53:42 +02:00
oSumAtrIX	26d449e6d9	docs: Fix broken links	2024-08-06 16:53:42 +02:00
oSumAtrIX	49466060e3	docs: Fix docs link [skip ci]	2024-08-06 16:53:42 +02:00
oSumAtrIX	620ea5b852	docs: Un-indent markdown to fix rendering	2024-08-06 16:53:42 +02:00
oSumAtrIX	3e2168a2b2	chore: Revert using a relative image path For some reason GitHub does not render them correctly	2024-08-06 16:53:42 +02:00
oSumAtrIX	13c77967b1	build: Bump dependencies	2024-08-06 16:53:42 +02:00
oSumAtrIX	f57e571a14	chore: Merge branch `dev` to `main` (#276 )	2024-02-25 03:33:57 +01:00