chore(release): 18.0.0-dev.3 [skip ci]

# [18.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.2...v18.0.0-dev.3) (2023-10-22)

### Features

* Make `PatchOption#values` nullable ([56ce9ec](56ce9ec2f9))

.github/workflows/pull_request.yml

@@ -1,4 +1,4 @@
-name: PR to main
+name: Open a PR to main
 
 on:
   push:
@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  MESSAGE: merge branch `${{ github.head_ref || github.ref_name }}` to `main`
+  MESSAGE: Merge branch `${{ github.head_ref || github.ref_name }}` to `main`
 
 jobs:
   pull-request:
@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Open pull request
         uses: repo-sync/pull-request@v2
         with:

.github/workflows/release.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           # Make sure the release step uses its own credentials:
           # https://github.com/cycjimmy/semantic-release-action#private-packages
@@ -36,7 +36,7 @@ jobs:
       - name: Build with Gradle
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: ./gradlew clean --no-daemon
+        run: ./gradlew build clean --no-daemon
       - name: Setup semantic-release
         run: npm install
       - name: Release

CHANGELOG.md

@@ -1,3 +1,299 @@
+# [18.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.2...v18.0.0-dev.3) (2023-10-22)
+
+
+### Features
+
+* Make `PatchOption#values` nullable ([56ce9ec](https://github.com/ReVanced/revanced-patcher/commit/56ce9ec2f98ff351c3d42df71b49e5c88f07e665))
+
+# [18.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.1...v18.0.0-dev.2) (2023-10-22)
+
+
+### Code Refactoring
+
+* Change `PatchOption` from abstract to open class ([09cd6aa](https://github.com/ReVanced/revanced-patcher/commit/09cd6aa568988dd5241bfa6a2e12b7926a7b0683))
+
+
+### Features
+
+* Add function to reset options to their default value ([ebbaafb](https://github.com/ReVanced/revanced-patcher/commit/ebbaafb78e88f34faeafe9ff8532afe29231bd79))
+* Add function to reset options to their default value ([e6de90d](https://github.com/ReVanced/revanced-patcher/commit/e6de90d300bc9c82ca1696cb898db04c65a1cd5b))
+* Add getter for default option value ([c7922e9](https://github.com/ReVanced/revanced-patcher/commit/c7922e90d0c6ae83f513611c706ebea33c1a2b63))
+* Name patch option value validator property correctly ([caa634f](https://github.com/ReVanced/revanced-patcher/commit/caa634fac6d7a717f54e3b015827c8858fd637b9))
+
+
+### BREAKING CHANGES
+
+* This gets rid of the existing basic implementations of the `PatchOptions` type and moves extension functions.
+* This changes the getter name of the property.
+
+# [18.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v17.0.1-dev.1...v18.0.0-dev.1) (2023-10-14)
+
+
+### Features
+
+* Remove patch annotation processor ([4456031](https://github.com/ReVanced/revanced-patcher/commit/445603145979a6f67823a79f9d6cd140299cff37))
+
+
+### BREAKING CHANGES
+
+* Various patch constructor signatures have changed.
+
+## [17.0.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v17.0.0...v17.0.1-dev.1) (2023-10-10)
+
+
+### Performance Improvements
+
+* Run the garbage collector after writing dex files ([d9fb241](https://github.com/ReVanced/revanced-patcher/commit/d9fb241d57b0c4340130c0e5900250e66730ea56))
+
+# [17.0.0](https://github.com/ReVanced/revanced-patcher/compare/v16.0.2...v17.0.0) (2023-10-09)
+
+
+### Features
+
+* Add option to use single threaded writer for dex files ([77dbee3](https://github.com/ReVanced/revanced-patcher/commit/77dbee3d6ae7b8dc77543e036624daa68ae63504))
+
+
+### BREAKING CHANGES
+
+* This commit gets rid of deprecated constructors.
+
+# [17.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v16.0.2...v17.0.0-dev.1) (2023-10-09)
+
+
+### Features
+
+* Add option to use single threaded writer for dex files ([77dbee3](https://github.com/ReVanced/revanced-patcher/commit/77dbee3d6ae7b8dc77543e036624daa68ae63504))
+
+
+### BREAKING CHANGES
+
+* This commit gets rid of deprecated constructors.
+
+## [16.0.2](https://github.com/ReVanced/revanced-patcher/compare/v16.0.1...v16.0.2) (2023-10-06)
+
+
+### Performance Improvements
+
+* Use a map to merge integrations classes ([6059d3c](https://github.com/ReVanced/revanced-patcher/commit/6059d3ca2685cb659023b171b95d4b9d279c6e53))
+
+## [16.0.2-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v16.0.1...v16.0.2-dev.1) (2023-10-06)
+
+
+### Performance Improvements
+
+* Use a map to merge integrations classes ([6059d3c](https://github.com/ReVanced/revanced-patcher/commit/6059d3ca2685cb659023b171b95d4b9d279c6e53))
+
+## [16.0.1](https://github.com/ReVanced/revanced-patcher/compare/v16.0.0...v16.0.1) (2023-10-05)
+
+
+### Bug Fixes
+
+* Merge integrations when required ([06c2b76](https://github.com/ReVanced/revanced-patcher/commit/06c2b76f11ac1bfe43d51d54d425e7577ecefdf6))
+
+## [16.0.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v16.0.0...v16.0.1-dev.1) (2023-10-05)
+
+
+### Bug Fixes
+
+* Merge integrations when required ([06c2b76](https://github.com/ReVanced/revanced-patcher/commit/06c2b76f11ac1bfe43d51d54d425e7577ecefdf6))
+
+# [16.0.0](https://github.com/ReVanced/revanced-patcher/compare/v15.0.3...v16.0.0) (2023-10-04)
+
+
+### Bug Fixes
+
+* Use correct super class type ([f590436](https://github.com/ReVanced/revanced-patcher/commit/f590436399f6385c51cea54618251b5d823c31f9))
+
+
+### BREAKING CHANGES
+
+* This changes the super classes of some `PatchOptionException` classes
+
+# [16.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v15.0.3...v16.0.0-dev.1) (2023-10-04)
+
+
+### Bug Fixes
+
+* Use correct super class type ([f590436](https://github.com/ReVanced/revanced-patcher/commit/f590436399f6385c51cea54618251b5d823c31f9))
+
+
+### BREAKING CHANGES
+
+* This changes the super classes of some `PatchOptionException` classes
+
+## [15.0.3](https://github.com/ReVanced/revanced-patcher/compare/v15.0.2...v15.0.3) (2023-10-01)
+
+
+### Bug Fixes
+
+* Fix SMALI compilation on devices with RTL language ([#242](https://github.com/ReVanced/revanced-patcher/issues/242)) ([356f1f1](https://github.com/ReVanced/revanced-patcher/commit/356f1f155348347a8f318a2e024716ebf4fec99b))
+
+## [15.0.3-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v15.0.2...v15.0.3-dev.1) (2023-09-29)
+
+
+### Bug Fixes
+
+* Fix SMALI compilation on devices with RTL language ([#242](https://github.com/ReVanced/revanced-patcher/issues/242)) ([356f1f1](https://github.com/ReVanced/revanced-patcher/commit/356f1f155348347a8f318a2e024716ebf4fec99b))
+
+## [15.0.2](https://github.com/ReVanced/revanced-patcher/compare/v15.0.1...v15.0.2) (2023-09-27)
+
+
+### Performance Improvements
+
+* Do not unnecessary resolve fingeprints twice ([#241](https://github.com/ReVanced/revanced-patcher/issues/241)) ([4d6e08a](https://github.com/ReVanced/revanced-patcher/commit/4d6e08a650dde6ec2e18611c5db1ab92b9a61dd1))
+
+## [15.0.2-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v15.0.1...v15.0.2-dev.1) (2023-09-26)
+
+
+### Performance Improvements
+
+* Do not unnecessary resolve fingeprints twice ([#241](https://github.com/ReVanced/revanced-patcher/issues/241)) ([4d6e08a](https://github.com/ReVanced/revanced-patcher/commit/4d6e08a650dde6ec2e18611c5db1ab92b9a61dd1))
+
+## [15.0.1](https://github.com/ReVanced/revanced-patcher/compare/v15.0.0...v15.0.1) (2023-09-20)
+
+
+### Bug Fixes
+
+* Remove log management ([d51bc32](https://github.com/ReVanced/revanced-patcher/commit/d51bc32e37a865194c3825471085b3ccf8c78421))
+
+## [15.0.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v15.0.0...v15.0.1-dev.1) (2023-09-20)
+
+
+### Bug Fixes
+
+* Remove log management ([d51bc32](https://github.com/ReVanced/revanced-patcher/commit/d51bc32e37a865194c3825471085b3ccf8c78421))
+
+# [15.0.0](https://github.com/ReVanced/revanced-patcher/compare/v14.2.2...v15.0.0) (2023-09-18)
+
+
+### Bug Fixes
+
+* Account for source patch dependency for tests ([6918418](https://github.com/ReVanced/revanced-patcher/commit/69184187d90f126478d2f49415c1e3381217557f))
+* Always make the generated patch depend on the source patch ([8de3063](https://github.com/ReVanced/revanced-patcher/commit/8de30633ae6eb7acf7f0a351e26d4a6c2fdbdfec))
+* Catch correct exception ([637d487](https://github.com/ReVanced/revanced-patcher/commit/637d48746ff8694e01c5aead1c75a9a1efeb5ac8))
+* Delegate `PatchBundleLoader` by mutable set of patches ([9a109c1](https://github.com/ReVanced/revanced-patcher/commit/9a109c129b135a634be1aad4130a06d9e8e96ecd))
+* Do not resolve the proxied patch to the proxy in the dependency list ([e112837](https://github.com/ReVanced/revanced-patcher/commit/e11283744a21fe2d09435e99d6924462b6aac3b8))
+* Do not set `CompatiblePackage.versions` if `@CompatiblePackage.versions` is empty ([6b1e0a1](https://github.com/ReVanced/revanced-patcher/commit/6b1e0a16568124e9f82fb5740353360fa8ec614a))
+* Filter for patches correctly ([4bc4b0d](https://github.com/ReVanced/revanced-patcher/commit/4bc4b0dc0104073b62528d02a88383cecd7a50e7))
+* Find dependency in `context.allPatches` ([670f015](https://github.com/ReVanced/revanced-patcher/commit/670f0153de10c6f0db25b08df1c01a2905037f84))
+* Log the correct patch names ([9fdb8f0](https://github.com/ReVanced/revanced-patcher/commit/9fdb8f087f62babf6081879db65c80db639aa0a7))
+* Make `CompatiblePackage.versions` a property ([67b7dff](https://github.com/ReVanced/revanced-patcher/commit/67b7dff67a212b4fc30eb4f0cbe58f0ba09fb09a))
+* Print patch name instead of class name ([4e7811e](https://github.com/ReVanced/revanced-patcher/commit/4e7811ea07762667a1f22526dc176022038f60eb))
+* Print stack trace of exception ([aa71146](https://github.com/ReVanced/revanced-patcher/commit/aa71146b1bf4ffebcc81a1663e15abae89e97ff0))
+* Run code-block if `executablePatches` does not yet contain `patch` ([1d7aeca](https://github.com/ReVanced/revanced-patcher/commit/1d7aeca696be873dfaf88eaa6d312949a3b8572b))
+* Suppress logger when loading patches in `PatchBundleLoader` ([72c9eb2](https://github.com/ReVanced/revanced-patcher/commit/72c9eb212985f99f3390cf1faa10ab547d2dbe7e))
+* Use correct module name ([080fbe9](https://github.com/ReVanced/revanced-patcher/commit/080fbe9feb9d4ea9ec4e599ecef296eacd803b05))
+
+
+### Code Refactoring
+
+* Internalize processor constructor ([a802d0d](https://github.com/ReVanced/revanced-patcher/commit/a802d0df463695976e85d8391762942eb977920b))
+
+
+* feat Use `Set` as super type for `PatchBundleLoader` ([4b76d19](https://github.com/ReVanced/revanced-patcher/commit/4b76d1959691babf8c99d3d5235df4a4388956f0))
+* feat!: Add patch annotation processor ([3fc6a13](https://github.com/ReVanced/revanced-patcher/commit/3fc6a139eef67237c116fb4e3e29bf9542d3a981))
+* feat!: Remove patch annotations ([3b4db3d](https://github.com/ReVanced/revanced-patcher/commit/3b4db3ddb72cdcee8af2f787eadf58eeb37543de))
+
+
+### Features
+
+* Add patch annotation processor ([#231](https://github.com/ReVanced/revanced-patcher/issues/231)) ([a29931f](https://github.com/ReVanced/revanced-patcher/commit/a29931f2ec0a666dba209b54855425d9dc2f4462))
+
+
+### BREAKING CHANGES
+
+* This gets rid of the public constructor.
+* `PatchBundleLoader` is not a map anymore
+* This renames packages and the Maven package.
+* The manifest for patches has been removed, and the properties have been added to patches. Patches are now `OptionsContainer`. The `@Patch` annotation has been removed in favour of the `@Patch` annotation from the annotation processor.
+* Patch annotations have been removed. PatcherException is now thrown in various places. PatchBundleLoader is now a map of patches associated by their name. Patches are now instances.
+
+# [15.0.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v15.0.0-dev.3...v15.0.0-dev.4) (2023-09-13)
+
+
+### Bug Fixes
+
+* Account for source patch dependency for tests ([6918418](https://github.com/ReVanced/revanced-patcher/commit/69184187d90f126478d2f49415c1e3381217557f))
+* Always make the generated patch depend on the source patch ([8de3063](https://github.com/ReVanced/revanced-patcher/commit/8de30633ae6eb7acf7f0a351e26d4a6c2fdbdfec))
+* Catch correct exception ([637d487](https://github.com/ReVanced/revanced-patcher/commit/637d48746ff8694e01c5aead1c75a9a1efeb5ac8))
+* Delegate `PatchBundleLoader` by mutable set of patches ([9a109c1](https://github.com/ReVanced/revanced-patcher/commit/9a109c129b135a634be1aad4130a06d9e8e96ecd))
+* Do not resolve the proxied patch to the proxy in the dependency list ([e112837](https://github.com/ReVanced/revanced-patcher/commit/e11283744a21fe2d09435e99d6924462b6aac3b8))
+* Do not set `CompatiblePackage.versions` if `@CompatiblePackage.versions` is empty ([6b1e0a1](https://github.com/ReVanced/revanced-patcher/commit/6b1e0a16568124e9f82fb5740353360fa8ec614a))
+* Filter for patches correctly ([4bc4b0d](https://github.com/ReVanced/revanced-patcher/commit/4bc4b0dc0104073b62528d02a88383cecd7a50e7))
+* Find dependency in `context.allPatches` ([670f015](https://github.com/ReVanced/revanced-patcher/commit/670f0153de10c6f0db25b08df1c01a2905037f84))
+* Log the correct patch names ([9fdb8f0](https://github.com/ReVanced/revanced-patcher/commit/9fdb8f087f62babf6081879db65c80db639aa0a7))
+* Print patch name instead of class name ([4e7811e](https://github.com/ReVanced/revanced-patcher/commit/4e7811ea07762667a1f22526dc176022038f60eb))
+* Print stack trace of exception ([aa71146](https://github.com/ReVanced/revanced-patcher/commit/aa71146b1bf4ffebcc81a1663e15abae89e97ff0))
+* Run code-block if `executablePatches` does not yet contain `patch` ([1d7aeca](https://github.com/ReVanced/revanced-patcher/commit/1d7aeca696be873dfaf88eaa6d312949a3b8572b))
+* Suppress logger when loading patches in `PatchBundleLoader` ([72c9eb2](https://github.com/ReVanced/revanced-patcher/commit/72c9eb212985f99f3390cf1faa10ab547d2dbe7e))
+
+
+### Code Refactoring
+
+* Internalize processor constructor ([a802d0d](https://github.com/ReVanced/revanced-patcher/commit/a802d0df463695976e85d8391762942eb977920b))
+
+
+### BREAKING CHANGES
+
+* This gets rid of the public constructor.
+
+# [15.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v15.0.0-dev.2...v15.0.0-dev.3) (2023-09-06)
+
+
+### Bug Fixes
+
+* Make `CompatiblePackage.versions` a property ([67b7dff](https://github.com/ReVanced/revanced-patcher/commit/67b7dff67a212b4fc30eb4f0cbe58f0ba09fb09a))
+* Use correct module name ([080fbe9](https://github.com/ReVanced/revanced-patcher/commit/080fbe9feb9d4ea9ec4e599ecef296eacd803b05))
+
+
+* feat Use `Set` as super type for `PatchBundleLoader` ([4b76d19](https://github.com/ReVanced/revanced-patcher/commit/4b76d1959691babf8c99d3d5235df4a4388956f0))
+
+
+### BREAKING CHANGES
+
+* `PatchBundleLoader` is not a map anymore
+* This renames packages and the Maven package.
+
+# [15.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v15.0.0-dev.1...v15.0.0-dev.2) (2023-09-06)
+
+# [15.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v14.2.2...v15.0.0-dev.1) (2023-09-04)
+
+
+* feat!: Add patch annotation processor ([3fc6a13](https://github.com/ReVanced/revanced-patcher/commit/3fc6a139eef67237c116fb4e3e29bf9542d3a981))
+* feat!: Remove patch annotations ([3b4db3d](https://github.com/ReVanced/revanced-patcher/commit/3b4db3ddb72cdcee8af2f787eadf58eeb37543de))
+
+
+### Features
+
+* Add patch annotation processor ([#231](https://github.com/ReVanced/revanced-patcher/issues/231)) ([a29931f](https://github.com/ReVanced/revanced-patcher/commit/a29931f2ec0a666dba209b54855425d9dc2f4462))
+
+
+### BREAKING CHANGES
+
+* The manifest for patches has been removed, and the properties have been added to patches. Patches are now `OptionsContainer`. The `@Patch` annotation has been removed in favour of the `@Patch` annotation from the annotation processor.
+* Patch annotations have been removed. PatcherException is now thrown in various places. PatchBundleLoader is now a map of patches associated by their name. Patches are now instances.
+
+## [14.2.2](https://github.com/ReVanced/revanced-patcher/compare/v14.2.1...v14.2.2) (2023-08-30)
+
+
+### Bug Fixes
+
+* allow setting `DexClassLoader.optimizedDirectory` ([11a3378](https://github.com/ReVanced/revanced-patcher/commit/11a337865947a6ac74a63ebb3f3f9bc2610f7771))
+
+## [14.2.2-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v14.2.1...v14.2.2-dev.1) (2023-08-29)
+
+
+### Bug Fixes
+
+* allow setting `DexClassLoader.optimizedDirectory` ([11a3378](https://github.com/ReVanced/revanced-patcher/commit/11a337865947a6ac74a63ebb3f3f9bc2610f7771))
+
+## [14.2.1](https://github.com/ReVanced/revanced-patcher/compare/v14.2.0...v14.2.1) (2023-08-27)
+
+
+### Bug Fixes
+
+* do not flag resource table as sparse when main package is not loaded ([b832812](https://github.com/ReVanced/revanced-patcher/commit/b832812767a06ec6ec232291e6d14c8c2f14118c))
+
 ## [14.2.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v14.2.0...v14.2.1-dev.1) (2023-08-27)
 
 

api/revanced-patcher.api

@@ -0,0 +1,842 @@
+public abstract interface class app/revanced/patcher/IntegrationsConsumer {
+	public abstract fun acceptIntegrations (Ljava/util/List;)V
+}
+
+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/PatcherOptions;)V
+	public fun acceptIntegrations (Ljava/util/List;)V
+	public fun acceptPatches (Ljava/util/List;)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/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;)V
+	public synthetic fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;Z)V
+	public synthetic fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;ZILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun copy (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;Z)Lapp/revanced/patcher/PatcherOptions;
+	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 getDoNotCompress ()Ljava/util/List;
+	public final fun getResourceFile ()Ljava/io/File;
+	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 abstract interface class app/revanced/patcher/PatchesConsumer {
+	public abstract fun acceptPatches (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/List;
+	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 ()Ljava/io/File;
+	public synthetic fun get ()Ljava/lang/Object;
+	public final fun get (Ljava/lang/String;)Ljava/io/File;
+	public final fun getXmlEditor ()Lapp/revanced/patcher/data/ResourceContext$XmlFileHolder;
+	public fun iterator ()Ljava/util/Iterator;
+}
+
+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/method/impl/MethodFingerprint;)Lapp/revanced/patcher/fingerprint/method/annotation/FuzzyPatternScanMethod;
+}
+
+public abstract interface class app/revanced/patcher/fingerprint/Fingerprint {
+}
+
+public abstract interface annotation class app/revanced/patcher/fingerprint/method/annotation/FuzzyPatternScanMethod : java/lang/annotation/Annotation {
+	public abstract fun threshold ()I
+}
+
+public abstract class app/revanced/patcher/fingerprint/method/impl/MethodFingerprint : app/revanced/patcher/fingerprint/Fingerprint {
+	public static final field Companion Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint$Companion;
+	public fun <init> ()V
+	public fun <init> (Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/Iterable;Ljava/lang/Iterable;Ljava/lang/Iterable;Lkotlin/jvm/functions/Function2;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/Iterable;Ljava/lang/Iterable;Ljava/lang/Iterable;Lkotlin/jvm/functions/Function2;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun getResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;
+	public final fun setResult (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;)V
+}
+
+public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprint$Companion {
+	public final fun resolve (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint;Lapp/revanced/patcher/data/BytecodeContext;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
+	public final fun resolve (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint;Lapp/revanced/patcher/data/BytecodeContext;Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
+	public final fun resolve (Ljava/lang/Iterable;Lapp/revanced/patcher/data/BytecodeContext;Ljava/lang/Iterable;)V
+}
+
+public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult {
+	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;)V
+	public final fun component1 ()Lcom/android/tools/smali/dexlib2/iface/Method;
+	public final fun component2 ()Lcom/android/tools/smali/dexlib2/iface/ClassDef;
+	public final fun component3 ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
+	public final fun copy (Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;
+	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getClassDef ()Lcom/android/tools/smali/dexlib2/iface/ClassDef;
+	public final fun getMethod ()Lcom/android/tools/smali/dexlib2/iface/Method;
+	public final fun getMutableClass ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass;
+	public final fun getMutableMethod ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;
+	public final fun getScanResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult {
+	public fun <init> (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;)V
+	public final fun component1 ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
+	public final fun component2 ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
+	public final fun copy (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
+	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getPatternScanResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
+	public final fun getStringsScanResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult {
+	public fun <init> (IILjava/util/List;)V
+	public synthetic fun <init> (IILjava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun component3 ()Ljava/util/List;
+	public final fun copy (IILjava/util/List;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
+	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;IILjava/util/List;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getEndIndex ()I
+	public final fun getStartIndex ()I
+	public final fun getWarnings ()Ljava/util/List;
+	public fun hashCode ()I
+	public final fun setWarnings (Ljava/util/List;)V
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning {
+	public fun <init> (Lcom/android/tools/smali/dexlib2/Opcode;Lcom/android/tools/smali/dexlib2/Opcode;II)V
+	public final fun component1 ()Lcom/android/tools/smali/dexlib2/Opcode;
+	public final fun component2 ()Lcom/android/tools/smali/dexlib2/Opcode;
+	public final fun component3 ()I
+	public final fun component4 ()I
+	public final fun copy (Lcom/android/tools/smali/dexlib2/Opcode;Lcom/android/tools/smali/dexlib2/Opcode;II)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning;
+	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning;Lcom/android/tools/smali/dexlib2/Opcode;Lcom/android/tools/smali/dexlib2/Opcode;IIILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getCorrectOpcode ()Lcom/android/tools/smali/dexlib2/Opcode;
+	public final fun getInstructionIndex ()I
+	public final fun getPatternIndex ()I
+	public final fun getWrongOpcode ()Lcom/android/tools/smali/dexlib2/Opcode;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult {
+	public fun <init> (Ljava/util/List;)V
+	public final fun component1 ()Ljava/util/List;
+	public final fun copy (Ljava/util/List;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
+	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;Ljava/util/List;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getMatches ()Ljava/util/List;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch {
+	public fun <init> (Ljava/lang/String;I)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()I
+	public final fun copy (Ljava/lang/String;I)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch;
+	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch;Ljava/lang/String;IILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getIndex ()I
+	public final fun getString ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class app/revanced/patcher/logging/Logger {
+	public abstract fun error (Ljava/lang/String;)V
+	public abstract fun info (Ljava/lang/String;)V
+	public abstract fun trace (Ljava/lang/String;)V
+	public abstract fun warn (Ljava/lang/String;)V
+}
+
+public final class app/revanced/patcher/logging/Logger$DefaultImpls {
+	public static fun error (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
+	public static fun info (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
+	public static fun trace (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
+	public static fun warn (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
+}
+
+public final class app/revanced/patcher/logging/impl/NopLogger : app/revanced/patcher/logging/Logger {
+	public static final field INSTANCE Lapp/revanced/patcher/logging/impl/NopLogger;
+	public fun error (Ljava/lang/String;)V
+	public fun info (Ljava/lang/String;)V
+	public fun trace (Ljava/lang/String;)V
+	public fun warn (Ljava/lang/String;)V
+}
+
+public abstract class app/revanced/patcher/patch/BytecodePatch : app/revanced/patcher/patch/Patch {
+	public fun <init> ()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 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/ResourcePatch : app/revanced/patcher/patch/Patch {
+	public fun <init> ()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/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/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 getValues ()Ljava/util/Set;
+	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/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun booleanArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Boolean;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun booleanPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Boolean;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun booleanPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Boolean;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun floatArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Float;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun floatArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Float;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun floatPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Float;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun floatPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Float;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun intArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Integer;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun intArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Integer;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun intPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Integer;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun intPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Integer;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun longArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Long;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun longArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Long;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun longPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Long;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun longPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Long;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun stringArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/String;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun stringArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/String;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun stringPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun stringPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+}
+
+public 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/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;
+}
+

build.gradle.kts

@@ -1,10 +1,33 @@
 plugins {
-    kotlin("jvm") version "1.8.20"
+    kotlin("jvm") version "1.9.0"
+    alias(libs.plugins.binary.compatibility.validator)
     `maven-publish`
+    signing
+    java
 }
 
 group = "app.revanced"
 
+tasks {
+    processResources {
+        expand("projectVersion" to project.version)
+    }
+
+    test {
+        useJUnitPlatform()
+        testLogging {
+            events("PASSED", "SKIPPED", "FAILED")
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+    maven { url = uri("https://jitpack.io") }
+    google()
+}
+
 dependencies {
     implementation(libs.kotlinx.coroutines.core)
     implementation(libs.xpp3)
@@ -18,40 +41,46 @@ dependencies {
     testImplementation(libs.kotlin.test)
 }
 
-tasks {
-    test {
-        useJUnitPlatform()
-        testLogging {
-            events("PASSED", "SKIPPED", "FAILED")
-        }
-    }
-
-    processResources {
-        expand("projectVersion" to project.version)
-    }
-}
-
-kotlin { jvmToolchain(11) }
-
 java {
+    withJavadocJar()
     withSourcesJar()
 }
 
+kotlin {
+    jvmToolchain(11)
+}
+
 publishing {
-    repositories {
-        mavenLocal()
-        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"
+                }
             }
         }
     }
-    publications {
-        create<MavenPublication>("gpr") {
-            from(components["java"])
-        }
-    }
-}
+}

gradle.properties

@@ -1,4 +1,4 @@
 org.gradle.parallel = true
 org.gradle.caching = true
 kotlin.code.style = official
-version = 14.2.1-dev.1
+version = 18.0.0-dev.3

gradle/libs.versions.toml

@@ -1,21 +1,23 @@
 [versions]
 android = "4.1.1.4"
 kotlin-reflect = "1.9.0"
-apktool-lib = "2.8.2-6"
+apktool-lib = "2.9.1"
 kotlin-test = "1.8.20-RC"
-kotlinx-coroutines-core = "1.7.1"
-multidexlib2 = "3.0.3.r2"
-shadow = "8.1.1"
+kotlinx-coroutines-core = "1.7.3"
+multidexlib2 = "3.0.3.r3"
 smali = "3.0.3"
 xpp3 = "1.1.4c"
-
+binary-compatibility-validator = "0.13.2"
 
 [libraries]
 android = { module = "com.google.android:android", version.ref = "android" }
 kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin-reflect" }
-apktool-lib = { module = "app.revanced:apktool-lib", version.ref = "apktool-lib" }
+apktool-lib = { module = "app.revanced:apktool", version.ref = "apktool-lib" }
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin-test" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines-core" }
 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" }

settings.gradle.kts

@@ -1,22 +1 @@
-val githubUsername: String = providers.gradleProperty("gpr.user").orNull ?: System.getenv("GITHUB_ACTOR")
-val githubPassword: String = providers.gradleProperty("gpr.key").orNull ?: System.getenv("GITHUB_TOKEN")
-
-dependencyResolutionManagement {
-    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
-    repositories {
-        mavenCentral()
-        google()
-        mavenLocal()
-        listOf("multidexlib2", "apktool").forEach { repo ->
-            maven {
-                url = uri("https://maven.pkg.github.com/revanced/$repo")
-                credentials {
-                    username = githubUsername
-                    password = githubPassword
-                }
-            }
-        }
-    }
-}
-
-rootProject.name = "revanced-patcher"
+rootProject.name = "revanced-patcher"

src/main/kotlin/app/revanced/patcher/PatchBundleLoader.kt

@@ -2,36 +2,88 @@
 
 package app.revanced.patcher
 
-import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
-import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.PatchClass
 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 patch bundle.
+ * 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 fromClasses The classes to get [Patch]es from.
+ * @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(
-    fromClasses: Iterable<Class<*>>
-) : MutableList<PatchClass> by mutableListOf() {
-    init {
-        fromClasses.filter {
-            if (it.isAnnotation) return@filter false
+    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)
 
-            it.findAnnotationRecursively(app.revanced.patcher.patch.annotations.Patch::class) != null
-        }.map {
-            @Suppress("UNCHECKED_CAST")
-            it as PatchClass
-        }.sortedBy {
-            it.patchName
-        }.let { addAll(it) }
+    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. " +
+                            "Will try to instantiate it."
+                )
+
+                try {
+                    getDeclaredConstructor().newInstance()
+                } catch (exception: Exception) {
+                    if (!silent) logger.severe(
+                        "Patch class '${name}' is not singleton and has no suitable constructor, " +
+                                "therefor cannot be instantiated and will be ignored."
+                    )
+
+                    return null
+                }
+            } as Patch<*>
+        }
     }
 
     /**
@@ -39,36 +91,37 @@ sealed class PatchBundleLoader private constructor(
      *
      * @param patchBundles The path to patch bundles of JAR format.
      */
-    class Jar(vararg patchBundles: File) :
-        PatchBundleLoader(with(URLClassLoader(patchBundles.map { it.toURI().toURL() }.toTypedArray())) {
-            patchBundles.flatMap { patchBundle ->
-                // Get the names of all classes in the DEX file.
-
-                JarFile(patchBundle).entries().asSequence()
-                    .filter { it.name.endsWith(".class") }
-                    .map { it.name.replace('/', '.').replace(".class", "") }
-                    .map { loadClass(it) }
-            }
-        })
+    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) : PatchBundleLoader(with(
+    class Dex(vararg patchBundles: File, optimizedDexDirectory: File? = null) : PatchBundleLoader(
         DexClassLoader(
-            patchBundles.joinToString(File.pathSeparator) { it.absolutePath },
-            null,
+            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)
+                }
+        }
     ) {
-        patchBundles
-            .flatMap {
-                MultiDexIO.readDexFile(true, it, BasicDexFileNamer(), null, null).classes
-            }
-            .map { classDef -> classDef.type.substring(1, classDef.length - 1) }
-            .map { loadClass(it) }
-    })
+        @Deprecated("This constructor is deprecated. Use the constructor with the second parameter instead.")
+        constructor(vararg patchBundles: File) : this(*patchBundles, optimizedDexDirectory = null)
+    }
 }

src/main/kotlin/app/revanced/patcher/Patcher.kt

@@ -1,11 +1,7 @@
 package app.revanced.patcher
 
-import app.revanced.patcher.data.Context
+import app.revanced.patcher.PatchBundleLoader.Utils.getInstance
 import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
-import app.revanced.patcher.extensions.PatchExtensions.dependencies
-import app.revanced.patcher.extensions.PatchExtensions.patchName
-import app.revanced.patcher.extensions.PatchExtensions.requiresIntegrations
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolveUsingLookupMap
 import app.revanced.patcher.patch.*
@@ -13,8 +9,6 @@ import kotlinx.coroutines.flow.flow
 import java.io.Closeable
 import java.io.File
 import java.util.function.Supplier
-import java.util.logging.Level
-import java.util.logging.LogManager
 import java.util.logging.Logger
 
 /**
@@ -34,47 +28,87 @@ class Patcher(
     val context = PatcherContext(options)
 
     init {
-        LogManager.getLogManager().let { manager ->
-            // Disable root logger.
-            manager.getLogger("").level = Level.OFF
-
-            // Enable ReVanced logging only.
-            manager.loggerNames
-                .toList()
-                .filter { it.startsWith("app.revanced") }
-                .map { manager.getLogger(it) }
-                .forEach { it.level = Level.INFO }
-        }
-
         context.resourceContext.decodeResources(ResourceContext.ResourceDecodingMode.MANIFEST_ONLY)
     }
 
-    override fun acceptPatches(patches: List<PatchClass>) {
+    // TODO: Fix circular dependency detection.
+    // /**
+    //  * Add [Patch]es to ReVanced [Patcher].
+    //  * It is not guaranteed that all supplied [Patch]es will be accepted, if an exception is thrown.
+    //  *
+    //  * @param patches The [Patch]es to add.
+    //  * @throws PatcherException.CircularDependencyException If a circular dependency is detected.
+    // */
+    /**
+     * Add [Patch]es to ReVanced [Patcher].
+     *
+     * @param patches The [Patch]es to add.
+    */
+    @Suppress("NAME_SHADOWING")
+    override fun acceptPatches(patches: List<Patch<*>>) {
         /**
-         * Returns true if at least one patches or its dependencies matches the given predicate.
+         * 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.anyRecursively(predicate: (PatchClass) -> Boolean): Boolean =
+        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.
+        for (patch in patches) context.executablePatches.putIfAbsent(patch::class, patch) ?: run {
+            context.allPatches[patch::class] = patch
+
+            patch.dependencies?.forEach { it.putDependenciesRecursively() }
+        }
+
+        /* TODO: Fix circular dependency detection.
+        val graph = mutableMapOf<PatchClass, MutableList<PatchClass>>()
+        fun PatchClass.visit() {
+            if (this in graph) return
+
+            val group = graph.getOrPut(this) { mutableListOf(this) }
+
+            val dependencies = context.allPatches[this]!!.manifest.dependencies ?: return
+            dependencies.forEach { dependency ->
+                if (group == graph[dependency])
+                    throw PatcherException.CircularDependencyException(context.allPatches[this]!!.manifest.name)
+
+                graph[dependency] = group.apply { add(dependency) }
+                dependency.visit()
+            }
+        }
+        */
+
+        /**
+         * 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 ->
-                dependency.java.anyRecursively(predicate)
+                context.allPatches[dependency]!!.anyRecursively(predicate)
             } ?: false
 
-        // Determine if resource patching is required.
-        for (patch in patches) {
-            if (patch.anyRecursively { ResourcePatch::class.java.isAssignableFrom(it) }) {
-                options.resourceDecodingMode = ResourceContext.ResourceDecodingMode.FULL
-                break
-            }
-        }
+        context.allPatches.values.let { patches ->
+            // Determine, if resource patching is required.
+            for (patch in patches)
+                if (patch.anyRecursively { patch is ResourcePatch }) {
+                    options.resourceDecodingMode = ResourceContext.ResourceDecodingMode.FULL
+                    break
+                }
 
-        // Determine if merging integrations is required.
-        for (patch in patches) {
-            if (patch.anyRecursively { it.requiresIntegrations }) {
-                context.bytecodeContext.integrations.merge = true
-                break
-            }
+            // Determine, if merging integrations is required.
+            for (patch in patches)
+                if (patch.anyRecursively { it.requiresIntegrations }) {
+                    context.bytecodeContext.integrations.merge = true
+                    break
+                }
         }
-
-        context.patches.addAll(patches)
     }
 
     /**
@@ -93,65 +127,62 @@ class Patcher(
      * @return A pair of the name of the [Patch] and its [PatchResult].
      */
     override fun apply(returnOnError: Boolean) = flow {
-        class ExecutedPatch(val patchInstance: Patch<Context<*>>, val patchResult: PatchResult)
 
         /**
          * Execute a [Patch] and its dependencies recursively.
          *
-         * @param patchClass The [Patch] to execute.
+         * @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(
-            patchClass: PatchClass,
-            executedPatches: LinkedHashMap<String, ExecutedPatch>
+            patch: Patch<*>,
+            executedPatches: LinkedHashMap<Patch<*>, PatchResult>
         ): PatchResult {
-            val patchName = patchClass.patchName
+            val patchName = patch.name ?: patch.toString()
 
-            executedPatches[patchName]?.let { executedPatch ->
-                executedPatch.patchResult.exception ?: return executedPatch.patchResult
+            executedPatches[patch]?.let { patchResult ->
+                patchResult.exception ?: return patchResult
 
                 // Return a new result with an exception indicating that the patch was not executed previously,
                 // because it is a dependency of another patch that failed.
-                return PatchResult(patchName, PatchException("'$patchName' did not succeed previously"))
+                return PatchResult(patch, PatchException("'$patchName' did not succeed previously"))
             }
 
             // Recursively execute all dependency patches.
-            patchClass.dependencies?.forEach { dependencyClass ->
-                val dependency = dependencyClass.java
-
+            patch.dependencies?.forEach { dependencyClass ->
+                val dependency = context.allPatches[dependencyClass]!!
                 val result = executePatch(dependency, executedPatches)
 
                 result.exception?.let {
                     return PatchResult(
-                        patchName,
+                        patch,
                         PatchException(
-                            "'$patchName' depends on '${dependency.patchName}' that raised an exception: $it"
+                            "'$patchName' depends on '${dependency.name ?: dependency}' " +
+                                    "that raised an exception:\n${it.stackTraceToString()}"
                         )
                     )
                 }
             }
 
-            // TODO: Implement this in a more polymorphic way.
-            val patchInstance = patchClass.getDeclaredConstructor().newInstance()
-
-            val patchContext = if (patchInstance is BytecodePatch) {
-                patchInstance.fingerprints?.resolveUsingLookupMap(context.bytecodeContext)
-
-                context.bytecodeContext
-            } else {
-                context.resourceContext
-            }
-
             return try {
-                patchInstance.execute(patchContext)
+                // TODO: Implement this in a more polymorphic way.
+                when (patch) {
+                    is BytecodePatch -> {
+                        patch.fingerprints.resolveUsingLookupMap(context.bytecodeContext)
+                        patch.execute(context.bytecodeContext)
+                    }
+                    is ResourcePatch -> {
+                        patch.execute(context.resourceContext)
+                    }
+                }
 
-                PatchResult(patchName)
+                PatchResult(patch)
             } catch (exception: PatchException) {
-                PatchResult(patchName, exception)
+                PatchResult(patch, exception)
             } catch (exception: Exception) {
-                PatchResult(patchName, PatchException(exception))
-            }.also { executedPatches[patchName] = ExecutedPatch(patchInstance, it) }
+                PatchResult(patch, PatchException(exception))
+            }.also { executedPatches[patch] = it }
         }
 
         if (context.bytecodeContext.integrations.merge) context.bytecodeContext.integrations.flush()
@@ -164,63 +195,61 @@ class Patcher(
 
         logger.info("Executing patches")
 
-        val executedPatches = LinkedHashMap<String, ExecutedPatch>() // Key is name.
+        val executedPatches = LinkedHashMap<Patch<*>, PatchResult>() // Key is name.
 
-        context.patches.forEach { patch ->
-            val result = executePatch(patch, executedPatches)
+        context.executablePatches.values.sortedBy { it.name }.forEach { patch ->
+            val patchResult = executePatch(patch, executedPatches)
 
-            // If the patch failed, or if the patch is not closeable, emit the result.
-            // Results of patches that are closeable will be emitted later.
-            result.exception?.let {
-                emit(result)
+            // 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 (executedPatches[result.patchName]!!.patchInstance is Closeable) return@run
+                if (patch is Closeable) return@run
 
-                emit(result)
+                emit(patchResult)
             }
         }
 
         executedPatches.values
-            .filter { it.patchResult.exception == null }
-            .filter { it.patchInstance is Closeable }.asReversed().forEach { executedPatch ->
-                val patchName = executedPatch.patchResult.patchName
+            .filter { it.exception == null }
+            .filter { it.patch is Closeable }.asReversed().forEach { executedPatch ->
+                val patch = executedPatch.patch
 
                 val result = try {
-                    (executedPatch.patchInstance as Closeable).close()
+                    (patch as Closeable).close()
 
-                    executedPatch.patchResult
+                    executedPatch
                 } catch (exception: PatchException) {
-                    PatchResult(patchName, exception)
+                    PatchResult(patch, exception)
                 } catch (exception: Exception) {
-                    PatchResult(patchName, PatchException(exception))
+                    PatchResult(patch, PatchException(exception))
                 }
 
                 result.exception?.let {
                     emit(
                         PatchResult(
-                            patchName,
-                            PatchException("'$patchName' raised an exception while being closed: $it")
+                            patch,
+                            PatchException(
+                                "'${patch.name}' raised an exception while being closed: ${it.stackTraceToString()}",
+                                result.exception
+                            )
                         )
                     )
 
                     if (returnOnError) return@flow
                 } ?: run {
-                    executedPatch
-                        .patchInstance::class
-                        .java
-                        .findAnnotationRecursively(app.revanced.patcher.patch.annotations.Patch::class)
-                        ?: return@run
+                    patch.name ?: return@run
 
                     emit(result)
                 }
             }
     }
 
-    override fun close() {
-        MethodFingerprint.clearFingerprintResolutionLookupMaps()
-    }
+    override fun close() = MethodFingerprint.clearFingerprintResolutionLookupMaps()
 
     /**
      * Compile and save the patched APK file.

src/main/kotlin/app/revanced/patcher/PatcherContext.kt

@@ -3,7 +3,6 @@ package app.revanced.patcher
 import app.revanced.patcher.data.BytecodeContext
 import app.revanced.patcher.data.ResourceContext
 import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.PatchClass
 import brut.androlib.apk.ApkInfo
 import brut.directory.ExtFile
 
@@ -19,9 +18,14 @@ class PatcherContext internal constructor(options: PatcherOptions) {
     val packageMetadata = PackageMetadata(ApkInfo(ExtFile(options.inputFile)))
 
     /**
-     * The list of [Patch]es to execute.
+     * The map of [Patch]es associated by their [PatchClass].
      */
-    internal val patches = mutableListOf<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<*>>()
 
     /**
      * The [ResourceContext] of this [PatcherContext].

src/main/kotlin/app/revanced/patcher/PatcherException.kt

@@ -0,0 +1,16 @@
+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"
+    )
+}

src/main/kotlin/app/revanced/patcher/PatcherOptions.kt

@@ -1,7 +1,6 @@
 package app.revanced.patcher
 
 import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.logging.impl.NopLogger
 import brut.androlib.Config
 import java.io.File
 import java.util.logging.Logger
@@ -12,16 +11,15 @@ import java.util.logging.Logger
  * @param resourceCachePath The path to the directory to use for caching resources.
  * @param aaptBinaryPath The path to a custom aapt binary.
  * @param frameworkFileDirectory The path to the directory to cache the framework file in.
- * @param unusedLogger The logger to use for logging.
+ * @param multithreadingDexFileWriter Whether to use multiple threads for writing dex files.
+ * This can impact memory usage.
  */
-data class PatcherOptions
-@Deprecated("Use the constructor without the logger parameter instead")
-constructor(
+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 unusedLogger: app.revanced.patcher.logging.Logger = NopLogger
+    internal val multithreadingDexFileWriter: Boolean = false,
 ) {
     private val logger = Logger.getLogger(PatcherOptions::class.java.name)
 
@@ -47,6 +45,7 @@ constructor(
      * @param aaptBinaryPath The path to a custom aapt binary.
      * @param frameworkFileDirectory The path to the directory to cache the framework file in.
      */
+    @Deprecated("Use the constructor with the multithreadingDexFileWriter parameter instead")
     constructor(
         inputFile: File,
         resourceCachePath: File = File("revanced-resource-cache"),
@@ -57,7 +56,7 @@ constructor(
         resourceCachePath,
         aaptBinaryPath,
         frameworkFileDirectory,
-        NopLogger
+        false,
     )
 
     fun recreateResourceCacheDirectory() = resourceCachePath.also {

src/main/kotlin/app/revanced/patcher/PatchesConsumer.kt

@@ -1,8 +1,8 @@
 package app.revanced.patcher
 
-import app.revanced.patcher.patch.PatchClass
+import app.revanced.patcher.patch.Patch
 
 @FunctionalInterface
 interface PatchesConsumer {
-    fun acceptPatches(patches: List<PatchClass>)
+    fun acceptPatches(patches: List<Patch<*>>)
 }

src/main/kotlin/app/revanced/patcher/annotation/CompatibilityAnnotation.kt

@@ -1,23 +0,0 @@
-package app.revanced.patcher.annotation
-
-import app.revanced.patcher.patch.Patch
-
-/**
- * Annotation to constrain a [Patch] to compatible packages.
- * @param compatiblePackages A list of packages a [Patch] is compatible with.
- */
-@Target(AnnotationTarget.CLASS)
-annotation class Compatibility(
-    val compatiblePackages: Array<Package>,
-)
-
-/**
- * Annotation to represent packages a patch can be compatible with.
- * @param name The package identifier name.
- * @param versions The versions of the package the [Patch] is compatible with.
- */
-@Target()
-annotation class Package(
-    val name: String,
-    val versions: Array<String> = [],
-)

src/main/kotlin/app/revanced/patcher/annotation/MetadataAnnotation.kt

@@ -1,21 +0,0 @@
-package app.revanced.patcher.annotation
-
-import app.revanced.patcher.patch.Patch
-
-/**
- * Annotation to name a [Patch].
- * @param name A suggestive name for the [Patch].
- */
-@Target(AnnotationTarget.CLASS)
-annotation class Name(
-    val name: String,
-)
-
-/**
- * Annotation to describe a [Patch].
- * @param description A description for the [Patch].
- */
-@Target(AnnotationTarget.CLASS)
-annotation class Description(
-    val description: String,
-)

src/main/kotlin/app/revanced/patcher/data/BytecodeContext.kt

@@ -4,7 +4,6 @@ import app.revanced.patcher.PatcherContext
 import app.revanced.patcher.PatcherOptions
 import app.revanced.patcher.PatcherResult
 import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.annotations.RequiresIntegrations
 import app.revanced.patcher.util.ClassMerger.merge
 import app.revanced.patcher.util.ProxyClassList
 import app.revanced.patcher.util.method.MethodWalker
@@ -13,11 +12,11 @@ import com.android.tools.smali.dexlib2.Opcodes
 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.writer.io.MemoryDataStore
 import lanchon.multidexlib2.BasicDexFileNamer
 import lanchon.multidexlib2.DexIO
 import lanchon.multidexlib2.MultiDexIO
 import java.io.File
+import java.io.FileFilter
 import java.io.Flushable
 import java.util.logging.Logger
 
@@ -91,13 +90,43 @@ class BytecodeContext internal constructor(private val options: PatcherOptions)
      */
     fun toMethodWalker(startMethod: Method) = MethodWalker(this, startMethod)
 
+    /**
+     * Compile bytecode from the [BytecodeContext].
+     *
+     * @return The compiled bytecode.
+     */
+    override fun get(): List<PatcherResult.PatchedDexFile> {
+        logger.info("Compiling patched dex files")
+
+        val patchedDexFileResults = options.resourceCachePath.resolve("dex").also {
+            it.deleteRecursively() // Make sure the directory is empty.
+            it.mkdirs()
+        }.apply {
+            MultiDexIO.writeDexFile(
+                true,
+                if (options.multithreadingDexFileWriter) -1 else 1,
+                this,
+                BasicDexFileNamer(),
+                object : DexFile {
+                    override fun getClasses() = this@BytecodeContext.classes.also(ProxyClassList::replaceClasses)
+                    override fun getOpcodes() = this@BytecodeContext.opcodes
+                },
+                DexIO.DEFAULT_MAX_DEX_POOL_SIZE
+            ) { _, entryName, _ -> logger.info("Compiled $entryName") }
+        }.listFiles(FileFilter { it.isFile })!!.map { PatcherResult.PatchedDexFile(it.name, it.inputStream()) }
+
+        System.gc()
+
+        return patchedDexFileResults
+    }
+
     /**
      * The integrations of a [PatcherContext].
      */
     internal inner class Integrations : MutableList<File> by mutableListOf(), Flushable {
         /**
          * Whether to merge integrations.
-         * True when any supplied [Patch] is annotated with [RequiresIntegrations].
+         * Set to true, if the field requiresIntegrations of any supplied [Patch] is true.
          */
         var merge = false
 
@@ -109,7 +138,8 @@ class BytecodeContext internal constructor(private val options: PatcherOptions)
 
             logger.info("Merging integrations")
 
-            // TODO: Multi-thread this.
+            val classMap = classes.associateBy { it.type }
+
             this@Integrations.forEach { integrations ->
                 MultiDexIO.readDexFile(
                     true,
@@ -117,8 +147,8 @@ class BytecodeContext internal constructor(private val options: PatcherOptions)
                     null,
                     null
                 ).classes.forEach classDef@{ classDef ->
-                    val existingClass = classes.find { it.type == classDef.type } ?: run {
-                        logger.fine("Merging $classDef")
+                    val existingClass = classMap[classDef.type] ?: run {
+                        logger.fine("Adding $classDef")
                         classes.add(classDef)
                         return@classDef
                     }
@@ -132,27 +162,7 @@ class BytecodeContext internal constructor(private val options: PatcherOptions)
                     }
                 }
             }
-
             clear()
         }
     }
-
-    /**
-     * Compile bytecode from the [BytecodeContext].
-     *
-     * @return The compiled bytecode.
-     */
-    override fun get(): List<PatcherResult.PatchedDexFile> {
-        logger.info("Compiling modified dex files")
-
-        return mutableMapOf<String, MemoryDataStore>().apply {
-            MultiDexIO.writeDexFile(
-                true, -1, // Defaults to amount of available cores.
-                this, BasicDexFileNamer(), object : DexFile {
-                    override fun getClasses() = this@BytecodeContext.classes.also(ProxyClassList::replaceClasses)
-                    override fun getOpcodes() = this@BytecodeContext.opcodes
-                }, DexIO.DEFAULT_MAX_DEX_POOL_SIZE, null
-            )
-        }.map { PatcherResult.PatchedDexFile(it.key, it.value.readAt(0)) }
-    }
 }

src/main/kotlin/app/revanced/patcher/extensions/MethodFingerprintExtensions.kt

@@ -5,13 +5,7 @@ import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
 
 object MethodFingerprintExtensions {
-
-    /**
-     * The name of a [MethodFingerprint].
-     */
-    val MethodFingerprint.name: String
-        get() = this.javaClass.simpleName
-
+    // TODO: Make this a property.
     /**
      * The [FuzzyPatternScanMethod] annotation of a [MethodFingerprint].
      */

src/main/kotlin/app/revanced/patcher/extensions/PatchExtensions.kt

@@ -1,64 +0,0 @@
-package app.revanced.patcher.extensions
-
-import app.revanced.patcher.annotation.Compatibility
-import app.revanced.patcher.annotation.Description
-import app.revanced.patcher.annotation.Name
-import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
-import app.revanced.patcher.patch.OptionsContainer
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.PatchClass
-import app.revanced.patcher.patch.PatchOptions
-import app.revanced.patcher.patch.annotations.DependsOn
-import app.revanced.patcher.patch.annotations.RequiresIntegrations
-import kotlin.reflect.KVisibility
-import kotlin.reflect.full.companionObject
-import kotlin.reflect.full.companionObjectInstance
-
-object PatchExtensions {
-    /**
-     * The name of a [Patch].
-     */
-    val PatchClass.patchName: String
-        get() = findAnnotationRecursively(Name::class)?.name ?: this.simpleName
-
-    /**
-     * Weather or not a [Patch] should be included.
-     */
-    val PatchClass.include
-        get() = findAnnotationRecursively(app.revanced.patcher.patch.annotations.Patch::class)!!.include
-
-    /**
-     * The description of a [Patch].
-     */
-    val PatchClass.description
-        get() = findAnnotationRecursively(Description::class)?.description
-
-    /**
-     * The dependencies of a [Patch].
-     */
-    val PatchClass.dependencies
-        get() = findAnnotationRecursively(DependsOn::class)?.dependencies
-
-    /**
-     * The packages a [Patch] is compatible with.
-     */
-    val PatchClass.compatiblePackages
-        get() = findAnnotationRecursively(Compatibility::class)?.compatiblePackages
-
-    /**
-     * Weather or not a [Patch] requires integrations.
-     */
-    internal val PatchClass.requiresIntegrations
-        get() = findAnnotationRecursively(RequiresIntegrations::class) != null
-
-    /**
-     * The options of a [Patch].
-     */
-    val PatchClass.options: PatchOptions?
-        get() = kotlin.companionObject?.let { cl ->
-            if (cl.visibility != KVisibility.PUBLIC) return null
-            kotlin.companionObjectInstance?.let {
-                (it as? OptionsContainer)?.options
-            }
-        }
-}

src/main/kotlin/app/revanced/patcher/fingerprint/method/impl/MethodFingerprint.kt

@@ -159,10 +159,10 @@ abstract class MethodFingerprint(
          * - Faster: Specify [accessFlags], [returnType] and [parameters].
          * - Fastest: Specify [strings], with at least one string being an exact (non-partial) match.
          */
-        internal fun Iterable<MethodFingerprint>.resolveUsingLookupMap(context: BytecodeContext) {
+        internal fun Set<MethodFingerprint>.resolveUsingLookupMap(context: BytecodeContext) {
             if (methods.isEmpty()) throw PatchException("lookup map not initialized")
 
-            for (fingerprint in this) {
+            forEach { fingerprint ->
                 fingerprint.resolveUsingLookupMap(context)
             }
         }

src/main/kotlin/app/revanced/patcher/patch/BytecodePatch.kt

@@ -0,0 +1,13 @@
+package app.revanced.patcher.patch
+
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+
+/**
+ * A ReVanced [Patch] that works on [BytecodeContext].
+ *
+ * @param fingerprints A list of [MethodFingerprint]s which will be resolved before the patch is executed.
+ */
+abstract class BytecodePatch(
+    internal val fingerprints : Set<MethodFingerprint> = emptySet(),
+) : Patch<BytecodeContext>()

src/main/kotlin/app/revanced/patcher/patch/OptionsContainer.kt

@@ -1,18 +0,0 @@
-package app.revanced.patcher.patch
-
-/**
- * A container for patch options.
- */
-abstract class OptionsContainer {
-    /**
-     * A list of [PatchOption]s.
-     * @see PatchOptions
-     */
-    @Suppress("MemberVisibilityCanBePrivate")
-    val options = PatchOptions()
-
-    protected fun <T> option(opt: PatchOption<T>): PatchOption<T> {
-        options.register(opt)
-        return opt
-    }
-}

src/main/kotlin/app/revanced/patcher/patch/Patch.kt

@@ -1,39 +1,106 @@
+@file:Suppress("MemberVisibilityCanBePrivate")
+
 package app.revanced.patcher.patch
 
-import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.PatchClass
+import app.revanced.patcher.Patcher
 import app.revanced.patcher.data.Context
-import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.patch.options.PatchOptions
 import java.io.Closeable
-
-typealias PatchClass = Class<out Patch<Context<*>>>
+import kotlin.reflect.full.findAnnotation
 
 /**
  * A ReVanced patch.
+ * If an implementation of [Patch] also implements [Closeable]
+ * it will be closed in reverse execution order of patches executed by ReVanced [Patcher].
  *
- * If it implements [Closeable], it will be closed after all patches have been executed.
- * Closing will be done in reverse execution order.
+ * @param T The [Context] type this patch will work on.
  */
-sealed interface Patch<out T : Context<*>> {
+sealed class Patch<out T : Context<*>> {
     /**
-     * The main function of the [Patch] which the patcher will call.
+     * The name of the patch.
+     */
+    var name: String? = null
+        private set
+
+    /**
+     * The description of the patch.
+     */
+    var description: String? = null
+        private set
+
+    /**
+     * The packages the patch is compatible with.
+     */
+    var compatiblePackages: Set<CompatiblePackage>? = null
+        private set
+
+    /**
+     * Other patches this patch depends on.
+     */
+    var dependencies: Set<PatchClass>? = null
+        private set
+
+    /**
+     * Weather or not the patch should be used.
+     */
+    var use = true
+        private set
+
+
+    // TODO: Remove this property, once integrations are coupled with patches.
+    /**
+     * Weather or not the patch requires integrations.
+     */
+    var requiresIntegrations = false
+        private set
+
+    /**
+     * The options of the patch associated by the options key.
+     */
+    val options = PatchOptions()
+
+    init {
+        this::class.findAnnotation<app.revanced.patcher.patch.annotation.Patch>()?.let { annotation ->
+            name = annotation.name.ifEmpty { null }
+            description = annotation.description.ifEmpty { null }
+            compatiblePackages = annotation.compatiblePackages
+                .map { CompatiblePackage(it.name, it.versions.toSet()) }.toSet()
+            dependencies = annotation.dependencies.toSet().ifEmpty { null }
+            use = annotation.use
+            requiresIntegrations = annotation.requiresIntegrations
+        }
+    }
+
+    /**
+     * The execution function of the patch.
      *
      * @param context The [Context] the patch will work on.
      * @return The result of executing the patch.
      */
-    fun execute(context: @UnsafeVariance T)
-}
+    abstract fun execute(context: @UnsafeVariance T)
 
-/**
- * Resource patch for the Patcher.
- */
-interface ResourcePatch : Patch<ResourceContext>
+    override fun hashCode() = name.hashCode()
 
-/**
- * Bytecode patch for the Patcher.
- *
- * @param fingerprints A list of [MethodFingerprint] this patch relies on.
- */
-abstract class BytecodePatch(
-    internal val fingerprints: Iterable<MethodFingerprint>? = null
-) : Patch<BytecodeContext>
+    override fun toString() = name ?: this::class.simpleName ?: "Unnamed patch"
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as Patch<*>
+
+        return name == other.name
+    }
+
+    /**
+     * A package a [Patch] is compatible with.
+     *
+     * @param name The name of the package.
+     * @param versions The versions of the package.
+     */
+    class CompatiblePackage(
+        val name: String,
+        val versions: Set<String>? = null,
+    )
+}

src/main/kotlin/app/revanced/patcher/patch/PatchOption.kt

@@ -1,232 +0,0 @@
-@file:Suppress("CanBeParameter", "MemberVisibilityCanBePrivate", "UNCHECKED_CAST")
-
-package app.revanced.patcher.patch
-
-import java.nio.file.Path
-import kotlin.io.path.pathString
-import kotlin.reflect.KProperty
-
-class NoSuchOptionException(val option: String) : Exception("No such option: $option")
-class IllegalValueException(val value: Any?) : Exception("Illegal value: $value")
-class InvalidTypeException(val got: String, val expected: String) :
-    Exception("Invalid option value type: $got, expected $expected")
-
-object RequirementNotMetException : Exception("null was passed into an option that requires a value")
-
-/**
- * A registry for an array of [PatchOption]s.
- * @param options An array of [PatchOption]s.
- */
-class PatchOptions(vararg options: PatchOption<*>) : Iterable<PatchOption<*>> {
-    private val register = mutableMapOf<String, PatchOption<*>>()
-
-    init {
-        options.forEach { register(it) }
-    }
-
-    internal fun register(option: PatchOption<*>) {
-        if (register.containsKey(option.key)) {
-            throw IllegalStateException("Multiple options found with the same key")
-        }
-        register[option.key] = option
-    }
-
-    /**
-     * Get a [PatchOption] by its key.
-     * @param key The key of the [PatchOption].
-     */
-    @JvmName("getUntyped")
-    operator fun get(key: String) = register[key] ?: throw NoSuchOptionException(key)
-
-    /**
-     * Get a [PatchOption] by its key.
-     * @param key The key of the [PatchOption].
-     */
-    inline operator fun <reified T> get(key: String): PatchOption<T> {
-        val opt = get(key)
-        if (opt.value !is T) throw InvalidTypeException(
-            opt.value?.let { it::class.java.canonicalName } ?: "null",
-            T::class.java.canonicalName
-        )
-        return opt as PatchOption<T>
-    }
-
-    /**
-     * Set the value of a [PatchOption].
-     * @param key The key of the [PatchOption].
-     * @param value The value you want it to be.
-     * Please note that using the wrong value type results in a runtime error.
-     */
-    inline operator fun <reified T> set(key: String, value: T) {
-        val opt = get<T>(key)
-        if (opt.value !is T) throw InvalidTypeException(
-            T::class.java.canonicalName,
-            opt.value?.let { it::class.java.canonicalName } ?: "null"
-        )
-        opt.value = value
-    }
-
-    /**
-     * Sets the value of a [PatchOption] to `null`.
-     * @param key The key of the [PatchOption].
-     */
-    fun nullify(key: String) {
-        get(key).value = null
-    }
-
-    override fun iterator() = register.values.iterator()
-}
-
-/**
- * A [Patch] option.
- * @param key Unique identifier of the option. Example: _`settings`_
- * @param default The default value of the option.
- * @param title A human-readable title of the option. Example: _Patch Settings_
- * @param description A human-readable description of the option. Example: _Settings for the patches._
- * @param required Whether the option is required.
- */
-@Suppress("MemberVisibilityCanBePrivate")
-sealed class PatchOption<T>(
-    val key: String,
-    default: T?,
-    val title: String,
-    val description: String,
-    val required: Boolean,
-    val validator: (T?) -> Boolean
-) {
-    var value: T? = default
-        get() {
-            if (field == null && required) {
-                throw RequirementNotMetException
-            }
-            return field
-        }
-        set(value) {
-            if (value == null && required) {
-                throw RequirementNotMetException
-            }
-            if (!validator(value)) {
-                throw IllegalValueException(value)
-            }
-            field = value
-        }
-
-    /**
-     * Gets the value of the option.
-     * Please note that using the wrong value type results in a runtime error.
-     */
-    @JvmName("getValueTyped")
-    inline operator fun <reified V> getValue(thisRef: Nothing?, property: KProperty<*>): V? {
-        if (value !is V?) throw InvalidTypeException(
-            V::class.java.canonicalName,
-            value?.let { it::class.java.canonicalName } ?: "null"
-        )
-        return value as? V?
-    }
-
-    operator fun getValue(thisRef: Any?, property: KProperty<*>) = value
-
-    /**
-     * Gets the value of the option.
-     * Please note that using the wrong value type results in a runtime error.
-     */
-    @JvmName("setValueTyped")
-    inline operator fun <reified V> setValue(thisRef: Nothing?, property: KProperty<*>, new: V) {
-        if (value !is V) throw InvalidTypeException(
-            V::class.java.canonicalName,
-            value?.let { it::class.java.canonicalName } ?: "null"
-        )
-        value = new as T
-    }
-
-    operator fun setValue(thisRef: Any?, property: KProperty<*>, new: T?) {
-        value = new
-    }
-
-    /**
-     * A [PatchOption] representing a [String].
-     * @see PatchOption
-     */
-    class StringOption(
-        key: String,
-        default: String?,
-        title: String,
-        description: String,
-        required: Boolean = false,
-        validator: (String?) -> Boolean = { true }
-    ) : PatchOption<String>(
-        key, default, title, description, required, validator
-    )
-
-    /**
-     * A [PatchOption] representing a [Boolean].
-     * @see PatchOption
-     */
-    class BooleanOption(
-        key: String,
-        default: Boolean?,
-        title: String,
-        description: String,
-        required: Boolean = false,
-        validator: (Boolean?) -> Boolean = { true }
-    ) : PatchOption<Boolean>(
-        key, default, title, description, required, validator
-    )
-
-    /**
-     * A [PatchOption] with a list of allowed options.
-     * @param options A list of allowed options for the [ListOption].
-     * @see PatchOption
-     */
-    sealed class ListOption<E>(
-        key: String,
-        default: E?,
-        val options: Iterable<E>,
-        title: String,
-        description: String,
-        required: Boolean = false,
-        validator: (E?) -> Boolean = { true }
-    ) : PatchOption<E>(
-        key, default, title, description, required, {
-            (it?.let { it in options } ?: true) && validator(it)
-        }
-    ) {
-        init {
-            if (default != null && default !in options) {
-                throw IllegalStateException("Default option must be an allowed option")
-            }
-        }
-    }
-
-    /**
-     * A [ListOption] of type [String].
-     * @see ListOption
-     */
-    class StringListOption(
-        key: String,
-        default: String?,
-        options: Iterable<String>,
-        title: String,
-        description: String,
-        required: Boolean = false,
-        validator: (String?) -> Boolean = { true }
-    ) : ListOption<String>(
-        key, default, options, title, description, required, validator
-    )
-
-    /**
-     * A [ListOption] of type [Int].
-     * @see ListOption
-     */
-    class IntListOption(
-        key: String,
-        default: Int?,
-        options: Iterable<Int>,
-        title: String,
-        description: String,
-        required: Boolean = false,
-        validator: (Int?) -> Boolean = { true }
-    ) : ListOption<Int>(
-        key, default, options, title, description, required, validator
-    )
-}

src/main/kotlin/app/revanced/patcher/patch/PatchResult.kt

@@ -3,8 +3,7 @@ package app.revanced.patcher.patch
 /**
  * A result of executing a [Patch].
  *
- * @param patchName The name of the [Patch].
+ * @param patch The [Patch] that was executed.
  * @param exception The [PatchException] thrown, if any.
  */
-@Suppress("MemberVisibilityCanBePrivate")
-class PatchResult internal constructor(val patchName: String, val exception: PatchException? = null)
+class PatchResult internal constructor(val patch: Patch<*>, val exception: PatchException? = null)

src/main/kotlin/app/revanced/patcher/patch/ResourcePatch.kt

@@ -0,0 +1,8 @@
+package app.revanced.patcher.patch
+
+import app.revanced.patcher.data.ResourceContext
+
+/**
+ * A ReVanced [Patch] that works on [ResourceContext].
+ */
+abstract class ResourcePatch : Patch<ResourceContext>()

src/main/kotlin/app/revanced/patcher/patch/annotation/PatchAnnotations.kt

@@ -0,0 +1,37 @@
+package app.revanced.patcher.patch.annotation
+
+import java.lang.annotation.Inherited
+import kotlin.reflect.KClass
+
+/**
+ * Annotation for [app.revanced.patcher.patch.Patch] classes.
+ *
+ * @param name The name of the patch. If empty, the patch will be unnamed.
+ * @param description The description of the patch. If empty, no description will be used.
+ * @param dependencies The patches this patch depends on.
+ * @param compatiblePackages The packages this patch is compatible with.
+ * @param use Whether this patch should be used.
+ * @param requiresIntegrations Whether this patch requires integrations.
+ */
+@Target(AnnotationTarget.CLASS)
+@Inherited
+annotation class Patch(
+    val name: String = "",
+    val description: String = "",
+    val dependencies: Array<KClass<out app.revanced.patcher.patch.Patch<*>>> = [],
+    val compatiblePackages: Array<CompatiblePackage> = [],
+    val use: Boolean = true,
+    // TODO: Remove this property, once integrations are coupled with patches.
+    val requiresIntegrations: Boolean = false,
+)
+
+/**
+ * A package that a [app.revanced.patcher.patch.Patch] is compatible with.
+ *
+ * @param name The name of the package.
+ * @param versions The versions of the package.
+ */
+annotation class CompatiblePackage(
+    val name: String,
+    val versions: Array<String> = [],
+)

src/main/kotlin/app/revanced/patcher/patch/annotations/PatchAnnotation.kt

@@ -1,27 +0,0 @@
-package app.revanced.patcher.patch.annotations
-
-import app.revanced.patcher.data.Context
-import app.revanced.patcher.patch.Patch
-import kotlin.reflect.KClass
-
-/**
- * Annotation to mark a class as a patch.
- * @param include If false, the patch should be treated as optional by default.
- */
-@Target(AnnotationTarget.CLASS)
-annotation class Patch(val include: Boolean = true)
-
-/**
- * Annotation for dependencies of [Patch]es.
- */
-@Target(AnnotationTarget.CLASS)
-annotation class DependsOn(
-    val dependencies: Array<KClass<out Patch<Context<*>>>> = []
-)
-
-// TODO: Remove this annotation, once integrations are coupled with patches.
-/**
- * Annotation to mark [Patch]es which depend on integrations.
- */
-@Target(AnnotationTarget.CLASS)
-annotation class RequiresIntegrations

src/main/kotlin/app/revanced/patcher/patch/options/PatchOption.kt

@@ -0,0 +1,342 @@
+package app.revanced.patcher.patch.options
+
+import app.revanced.patcher.patch.Patch
+import kotlin.reflect.KProperty
+
+/**
+ * A [Patch] option.
+ *
+ * @param key The identifier.
+ * @param default The default value.
+ * @param values The set of guaranteed valid values.
+ * @param title The title.
+ * @param description A description.
+ * @param required Whether the option is required.
+ * @param validator The function to validate the option value.
+ * @param T The value type of the option.
+ */
+@Suppress("MemberVisibilityCanBePrivate", "unused")
+open class PatchOption<T>(
+    val key: String,
+    val default: T?,
+    val values: Set<T>?,
+    val title: String?,
+    val description: String?,
+    val required: Boolean,
+    val validator: PatchOption<T>.(T?) -> Boolean
+) {
+    /**
+     * The value of the [PatchOption].
+     */
+    var value: T?
+        /**
+         * Set the value of the [PatchOption].
+         *
+         * @param value The value to set.
+         *
+         * @throws PatchOptionException.ValueRequiredException If the value is required but null.
+         * @throws PatchOptionException.ValueValidationException If the value is invalid.
+         */
+        set(value) {
+            assertRequiredButNotNull(value)
+            assertValid(value)
+
+            uncheckedValue = value
+        }
+        /**
+         * Get the value of the [PatchOption].
+         *
+         * @return The value.
+         *
+         * @throws PatchOptionException.ValueRequiredException If the value is required but null.
+         * @throws PatchOptionException.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 [PatchOption] to its default value.
+     * Override this method if you need to mutate the value instead of replacing it.
+     */
+    open fun reset() {
+        uncheckedValue = default
+    }
+
+    private fun assertRequiredButNotNull(value: T?) {
+        if (required && value == null) throw PatchOptionException.ValueRequiredException(this)
+    }
+
+    private fun assertValid(value: T?) {
+        if (!validator(value)) throw PatchOptionException.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
+    }
+
+    @Suppress("unused")
+    companion object PatchExtensions {
+        /**
+         * Create a new [PatchOption] with a string value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>> P.stringPatchOption(
+            key: String,
+            default: String? = null,
+            values: Set<String>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<String>.(String?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * Create a new [PatchOption] with an integer value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>> P.intPatchOption(
+            key: String,
+            default: Int? = null,
+            values: Set<Int>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Int?>.(Int?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * Create a new [PatchOption] with a boolean value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>> P.booleanPatchOption(
+            key: String,
+            default: Boolean? = null,
+            values: Set<Boolean>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Boolean?>.(Boolean?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * Create a new [PatchOption] with a float value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>> P.floatPatchOption(
+            key: String,
+            default: Float? = null,
+            values: Set<Float>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Float?>.(Float?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * Create a new [PatchOption] with a long value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>> P.longPatchOption(
+            key: String,
+            default: Long? = null,
+            values: Set<Long>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Long?>.(Long?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * Create a new [PatchOption] with a string array value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>> P.stringArrayPatchOption(
+            key: String,
+            default: Array<String>? = null,
+            values: Set<Array<String>>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Array<String>?>.(Array<String>?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * Create a new [PatchOption] with an integer array value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>> P.intArrayPatchOption(
+            key: String,
+            default: Array<Int>? = null,
+            values: Set<Array<Int>>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Array<Int>?>.(Array<Int>?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * Create a new [PatchOption] with a boolean array value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>> P.booleanArrayPatchOption(
+            key: String,
+            default: Array<Boolean>? = null,
+            values: Set<Array<Boolean>>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Array<Boolean>?>.(Array<Boolean>?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * Create a new [PatchOption] with a float array value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>> P.floatArrayPatchOption(
+            key: String,
+            default: Array<Float>? = null,
+            values: Set<Array<Float>>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Array<Float>?>.(Array<Float>?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * Create a new [PatchOption] with a long array value and add it to the current [Patch].
+         *
+         * @param key The identifier.
+         * @param default The default value.
+         * @param values The set of guaranteed valid values.
+         * @param title The title.
+         * @param description A description.
+         * @param required Whether the option is required.
+         * @param validator The function to validate the option value.
+         *
+         * @return The created [PatchOption].
+         *
+         * @see PatchOption
+         */
+        fun <P : Patch<*>> P.longArrayPatchOption(
+            key: String,
+            default: Array<Long>? = null,
+            values: Set<Array<Long>>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Array<Long>?>.(Array<Long>?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        private fun <P : Patch<*>> P.registerOption(option: PatchOption<*>) = option.also { options.register(it) }
+    }
+}

src/main/kotlin/app/revanced/patcher/patch/options/PatchOptionException.kt

@@ -0,0 +1,41 @@
+package app.revanced.patcher.patch.options
+
+/**
+ * An exception thrown when using [PatchOption]s.
+ *
+ * @param errorMessage The exception message.
+ */
+sealed class PatchOptionException(errorMessage: String) : Exception(errorMessage, null) {
+    /**
+     * An exception thrown when a [PatchOption] 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) :
+        PatchOptionException("Type $expectedType was expected but received type $invalidType")
+
+    /**
+     * An exception thrown when a value did not satisfy the value conditions specified by the [PatchOption].
+     *
+     * @param value The value that failed validation.
+     */
+    class ValueValidationException(value: Any?, option: PatchOption<*>) :
+        PatchOptionException("The option value \"$value\" failed validation for ${option.key}")
+
+    /**
+     * An exception thrown when a value is required but null was passed.
+     *
+     * @param option The [PatchOption] that requires a value.
+     */
+    class ValueRequiredException(option: PatchOption<*>) :
+        PatchOptionException("The option ${option.key} requires a value, but null was passed")
+
+    /**
+     * An exception thrown when a [PatchOption] is not found.
+     *
+     * @param key The key of the [PatchOption].
+     */
+    class PatchOptionNotFoundException(key: String)
+        : PatchOptionException("No option with key $key")
+}

src/main/kotlin/app/revanced/patcher/patch/options/PatchOptions.kt

@@ -0,0 +1,45 @@
+package app.revanced.patcher.patch.options
+
+
+/**
+ * A map of [PatchOption]s associated by their keys.
+ *
+ * @param options The [PatchOption]s to initialize with.
+ */
+class PatchOptions internal constructor(
+    private val options: MutableMap<String, PatchOption<*>> = mutableMapOf()
+) : MutableMap<String, PatchOption<*>> by options {
+    /**
+     * Register a [PatchOption]. Acts like [MutableMap.put].
+     * @param value The [PatchOption] to register.
+     */
+    fun register(value: PatchOption<*>) {
+        options[value.key] = value
+    }
+
+    /**
+     * Set an option's value.
+     * @param key The identifier.
+     * @param value The value.
+     * @throws PatchOptionException.PatchOptionNotFoundException If the option does not exist.
+     */
+    operator fun <T : Any> set(key: String, value: T?) {
+        val option = this[key]
+
+        try {
+            @Suppress("UNCHECKED_CAST")
+            (option as PatchOption<T>).value = value
+        } catch (e: ClassCastException) {
+            throw PatchOptionException.InvalidValueTypeException(
+                value?.let { it::class.java.name } ?: "null",
+                option.value?.let { it::class.java.name } ?: "null",
+            )
+        }
+    }
+
+    /**
+     * Get an option.
+     */
+    override operator fun get(key: String) =
+        options[key] ?: throw PatchOptionException.PatchOptionNotFoundException(key)
+}

src/main/kotlin/app/revanced/patcher/util/smali/InlineSmaliCompiler.kt

@@ -13,6 +13,7 @@ import com.android.tools.smali.smali.smaliFlexLexer
 import com.android.tools.smali.smali.smaliParser
 import com.android.tools.smali.smali.smaliTreeWalker
 import java.io.InputStreamReader
+import java.util.Locale
 
 private const val METHOD_TEMPLATE = """
     .class LInlineCompiler;
@@ -33,7 +34,7 @@ class InlineSmaliCompiler {
         fun compile(
             instructions: String, parameters: String, registers: Int, forStaticMethod: Boolean
         ): List<BuilderInstruction> {
-            val input = METHOD_TEMPLATE.format(
+            val input = METHOD_TEMPLATE.format(Locale.ENGLISH,
                 if (forStaticMethod) {
                     "static"
                 } else {

src/test/kotlin/app/revanced/patcher/extensions/InstructionExtensionsTest.kt

@@ -19,7 +19,7 @@ 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 org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Test
+import kotlin.test.Test
 import kotlin.test.assertEquals
 
 private object InstructionExtensionsTest {

src/test/kotlin/app/revanced/patcher/issues/Issue98.kt

@@ -1,18 +0,0 @@
-package app.revanced.patcher.issues
-
-import app.revanced.patcher.patch.PatchOption
-import org.junit.jupiter.api.Test
-import kotlin.test.assertNull
-
-internal class Issue98 {
-    companion object {
-        var key1: String? by PatchOption.StringOption(
-            "key1", null, "title", "description"
-        )
-    }
-
-    @Test
-    fun `should infer nullable type correctly`() {
-        assertNull(key1)
-    }
-}

src/test/kotlin/app/revanced/patcher/patch/PatchOptionsTest.kt

@@ -1,107 +0,0 @@
-package app.revanced.patcher.patch
-
-import app.revanced.patcher.usage.bytecode.ExampleBytecodePatch
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertThrows
-import kotlin.test.assertNotEquals
-
-internal class PatchOptionsTest {
-    private val options = ExampleBytecodePatch.options
-
-    @Test
-    fun `should not throw an exception`() {
-        for (option in options) {
-            when (option) {
-                is PatchOption.StringOption -> {
-                    option.value = "Hello World"
-                }
-
-                is PatchOption.BooleanOption -> {
-                    option.value = false
-                }
-
-                is PatchOption.StringListOption -> {
-                    option.value = option.options.first()
-                    for (choice in option.options) {
-                        println(choice)
-                    }
-                }
-
-                is PatchOption.IntListOption -> {
-                    option.value = option.options.first()
-                    for (choice in option.options) {
-                        println(choice)
-                    }
-                }
-            }
-        }
-        val option = options.get<String>("key1")
-        // or: val option: String? by options["key1"]
-        // then you won't need `.value` every time
-        println(option.value)
-        options["key1"] = "Hello, world!"
-        println(option.value)
-    }
-
-    @Test
-    fun `should return a different value when changed`() {
-        var value: String? by options["key1"]
-        val current = value + "" // force a copy
-        value = "Hello, world!"
-        assertNotEquals(current, value)
-    }
-
-    @Test
-    fun `should be able to set value to null`() {
-        // Sadly, doing:
-        // > options["key2"] = null
-        // is not possible because Kotlin
-        // cannot reify the type "Nothing?".
-        // So we have to do this instead:
-        options["key2"] = null as Any?
-        // This is a cleaner replacement for the above:
-        options.nullify("key2")
-    }
-
-    @Test
-    fun `should fail because the option does not exist`() {
-        assertThrows<NoSuchOptionException> {
-            options["this option does not exist"] = 123
-        }
-    }
-
-    @Test
-    fun `should fail because of invalid value type when setting an option`() {
-        assertThrows<InvalidTypeException> {
-            options["key1"] = 123
-        }
-    }
-
-    @Test
-    fun `should fail because of invalid value type when getting an option`() {
-        assertThrows<InvalidTypeException> {
-            options.get<Int>("key1")
-        }
-    }
-
-    @Test
-    fun `should fail because of an illegal value`() {
-        assertThrows<IllegalValueException> {
-            options["key3"] = "this value is not an allowed option"
-        }
-    }
-
-    @Test
-    fun `should fail because the requirement is not met`() {
-        assertThrows<RequirementNotMetException> {
-            options.nullify("key1")
-        }
-    }
-
-    @Test
-    fun `should fail because getting a non-initialized option is illegal`() {
-        assertThrows<RequirementNotMetException> {
-            println(options["key5"].value)
-        }
-    }
-}

src/test/kotlin/app/revanced/patcher/patch/options/PatchOptionsTest.kt

@@ -0,0 +1,102 @@
+package app.revanced.patcher.patch.options
+
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.patch.BytecodePatch
+import app.revanced.patcher.patch.options.PatchOption.PatchExtensions.booleanPatchOption
+import app.revanced.patcher.patch.options.PatchOption.PatchExtensions.stringArrayPatchOption
+import app.revanced.patcher.patch.options.PatchOption.PatchExtensions.stringPatchOption
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.Test
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+internal class PatchOptionsTest {
+    @Test
+    fun `should not fail because default value is unvalidated`() {
+        assertDoesNotThrow { OptionsTestPatch.requiredStringOption }
+    }
+
+    @Test
+    fun `should not allow setting custom value with validation`() {
+        // Getter validation on incorrect value.
+        assertThrows<PatchOptionException.ValueValidationException> { OptionsTestPatch.validatedOption }
+
+        // Setter validation on incorrect value.
+        assertThrows<PatchOptionException.ValueValidationException> { OptionsTestPatch.validatedOption = "invalid" }
+
+        // Setter validation on correct value.
+        assertDoesNotThrow { OptionsTestPatch.validatedOption = "valid" }
+    }
+
+    @Test
+    fun `should throw due to incorrect type`() {
+        assertThrows<PatchOptionException.InvalidValueTypeException> {
+            OptionsTestPatch.options["bool"] = "not a boolean"
+        }
+    }
+
+    @Test
+    fun `should be nullable`() {
+        OptionsTestPatch.booleanOption = null
+    }
+
+    @Test
+    fun `option should not be found`() {
+        assertThrows<PatchOptionException.PatchOptionNotFoundException> {
+            OptionsTestPatch.options["this option does not exist"] = 1
+        }
+    }
+
+    @Test
+    fun `should be able to add options manually`() {
+        assertThrows<PatchOptionException.InvalidValueTypeException> {
+            OptionsTestPatch.options["array"] = OptionsTestPatch.stringArrayOption
+        }
+        assertDoesNotThrow {
+            OptionsTestPatch.options.register(OptionsTestPatch.stringArrayOption)
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Test
+    fun `should allow setting value from values`() =
+        with(OptionsTestPatch.options["choices"] as PatchOption<String>) {
+            value = values!!.last()
+            assertTrue(value == "valid")
+        }
+
+    @Test
+    fun `should allow setting custom value`() =
+        assertDoesNotThrow { OptionsTestPatch.stringOptionWithChoices = "unknown" }
+
+    @Test
+    fun `should allow resetting value`() = assertDoesNotThrow { OptionsTestPatch.stringOptionWithChoices = null }
+
+    @Test
+    fun `reset should not fail`() {
+        assertDoesNotThrow {
+            OptionsTestPatch.resettableOption.value = "test"
+            OptionsTestPatch.resettableOption.reset()
+        }
+
+        assertThrows<PatchOptionException.ValueRequiredException> {
+            OptionsTestPatch.resettableOption.value
+        }
+    }
+
+    @Test
+    fun `getting default value should work`() =
+        assertDoesNotThrow { assertNull(OptionsTestPatch.resettableOption.default) }
+
+    private object OptionsTestPatch : BytecodePatch() {
+        var booleanOption by booleanPatchOption("bool", true)
+        var requiredStringOption by stringPatchOption("required", "default", required = true)
+        var stringArrayOption = stringArrayPatchOption("array", arrayOf("1", "2"))
+        var stringOptionWithChoices by stringPatchOption("choices", "value", values = setOf("valid"))
+        var validatedOption by stringPatchOption("validated", "default") { it == "valid" }
+        var resettableOption = stringPatchOption("resettable", null, required = true)
+
+        override fun execute(context: BytecodeContext) {}
+    }
+}

src/test/kotlin/app/revanced/patcher/patch/usage/ExampleBytecodePatch.kt

@@ -0,0 +1,146 @@
+package app.revanced.patcher.patch.usage
+
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
+import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
+import app.revanced.patcher.extensions.InstructionExtensions.replaceInstruction
+import app.revanced.patcher.extensions.or
+import app.revanced.patcher.patch.BytecodePatch
+import app.revanced.patcher.patch.PatchException
+import app.revanced.patcher.patch.annotation.CompatiblePackage
+import app.revanced.patcher.patch.annotation.Patch
+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.Format
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction11x
+import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction21c
+import com.android.tools.smali.dexlib2.iface.instruction.formats.Instruction21c
+import com.android.tools.smali.dexlib2.immutable.ImmutableField
+import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
+import com.android.tools.smali.dexlib2.immutable.ImmutableMethodImplementation
+import com.android.tools.smali.dexlib2.immutable.reference.ImmutableFieldReference
+import com.android.tools.smali.dexlib2.immutable.reference.ImmutableStringReference
+import com.android.tools.smali.dexlib2.immutable.value.ImmutableFieldEncodedValue
+import com.android.tools.smali.dexlib2.util.Preconditions
+import com.google.common.collect.ImmutableList
+
+@Suppress("unused")
+@Patch(
+    name = "Example bytecode patch",
+    description = "Example demonstration of a bytecode patch.",
+    dependencies = [ExampleResourcePatch::class],
+    compatiblePackages = [CompatiblePackage("com.example.examplePackage", arrayOf("0.0.1", "0.0.2"))]
+)
+object ExampleBytecodePatch : BytecodePatch(setOf(ExampleFingerprint)) {
+    // Entry point of a patch. Supplied fingerprints are resolved at this point.
+    override fun execute(context: BytecodeContext) {
+        ExampleFingerprint.result?.let { result ->
+            // Let's modify it, so it prints "Hello, ReVanced! Editing bytecode."
+            // Get the start index of our opcode pattern.
+            // This will be the index of the instruction with the opcode CONST_STRING.
+            val startIndex = result.scanResult.patternScanResult!!.startIndex
+
+            result.mutableMethod.apply {
+                replaceStringAt(startIndex, "Hello, ReVanced! Editing bytecode.")
+
+                // Store the fields initial value into the first virtual register.
+                replaceInstruction(0, "sget-object v0, LTestClass;->dummyField:Ljava/io/PrintStream;")
+
+                // Now let's create a new call to our method and print the return value!
+                // You can also use the smali compiler to create instructions.
+                // For this sake of example I reuse the TestClass field dummyField inside the virtual register 0.
+                //
+                // Control flow instructions are not supported as of now.
+                addInstructionsWithLabels(
+                    startIndex + 2,
+                    """
+                        invoke-static { }, LTestClass;->returnHello()Ljava/lang/String;
+                        move-result-object v1
+                        invoke-virtual { v0, v1 }, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
+                    """
+                )
+            }
+
+            // Find the class in which the method matching our fingerprint is defined in.
+            context.findClass(result.classDef.type)!!.mutableClass.apply {
+                // Add a new method that returns a string.
+                methods.add(
+                    ImmutableMethod(
+                        result.classDef.type,
+                        "returnHello",
+                        null,
+                        "Ljava/lang/String;",
+                        AccessFlags.PRIVATE or AccessFlags.STATIC,
+                        null,
+                        null,
+                        ImmutableMethodImplementation(
+                            1,
+                            ImmutableList.of(
+                                BuilderInstruction21c(
+                                    Opcode.CONST_STRING,
+                                    0,
+                                    ImmutableStringReference("Hello, ReVanced! Adding bytecode.")
+                                ),
+                                BuilderInstruction11x(Opcode.RETURN_OBJECT, 0)
+                            ),
+                            null,
+                            null
+                        )
+                    ).toMutable()
+                )
+
+                // Add a field in the main class.
+                // We will use this field in our method below to call println on.
+                // The field holds the Ljava/io/PrintStream->out; field.
+                fields.add(
+                    ImmutableField(
+                        type,
+                        "dummyField",
+                        "Ljava/io/PrintStream;",
+                        AccessFlags.PRIVATE or AccessFlags.STATIC,
+                        ImmutableFieldEncodedValue(
+                            ImmutableFieldReference(
+                                "Ljava/lang/System;",
+                                "out",
+                                "Ljava/io/PrintStream;"
+                            )
+                        ),
+                        null,
+                        null
+                    ).toMutable()
+                )
+            }
+        } ?: throw PatchException("Fingerprint failed to resolve.")
+    }
+
+    /**
+     * Replace an existing instruction with a new one containing a reference to a new string.
+     * @param index The index of the instruction to replace.
+     * @param string The replacement string.
+     */
+    private fun MutableMethod.replaceStringAt(index: Int, string: String) {
+        val instruction = getInstruction(index)
+
+        // Utility method of dexlib2.
+        Preconditions.checkFormat(instruction.opcode, Format.Format21c)
+
+        // Cast this to an instruction of the format 21c.
+        // The instruction format can be found in the docs at
+        // https://source.android.com/devices/tech/dalvik/dalvik-bytecode
+        val strInstruction = instruction as Instruction21c
+
+        // In our case we want an instruction with the opcode CONST_STRING
+        // The format is 21c, so we create a new BuilderInstruction21c
+        // This instruction will hold the string reference constant in the virtual register of the original instruction
+        // For that a reference to the string is needed. It can be created with an ImmutableStringReference.
+        // At last, use the method replaceInstruction to replace it at the given index startIndex.
+        replaceInstruction(
+            index,
+            "const-string ${strInstruction.registerA}, ${ImmutableStringReference(string)}"
+        )
+    }
+}
+

src/test/kotlin/app/revanced/patcher/patch/usage/ExampleFingerprint.kt

@@ -1,4 +1,4 @@
-package app.revanced.patcher.usage.bytecode
+package app.revanced.patcher.patch.usage
 import app.revanced.patcher.extensions.or
 import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
@@ -12,8 +12,8 @@ object ExampleFingerprint : MethodFingerprint(
     listOf("[L"),
     listOf(
         Opcode.SGET_OBJECT,
-        null,                 // Testing unknown opcodes.
-        Opcode.INVOKE_STATIC, // This is intentionally wrong to test the Fuzzy resolver.
+        null,                 // Matching unknown opcodes.
+        Opcode.INVOKE_STATIC, // This is intentionally wrong to test fuzzy matching.
         Opcode.RETURN_VOID
     ),
     null

src/test/kotlin/app/revanced/patcher/patch/usage/ExampleResourcePatch.kt

@@ -1,18 +1,11 @@
-package app.revanced.patcher.usage.resource.patch
+package app.revanced.patcher.patch.usage
 
-import app.revanced.patcher.annotation.Description
-import app.revanced.patcher.annotation.Name
 import app.revanced.patcher.data.ResourceContext
 import app.revanced.patcher.patch.ResourcePatch
-import app.revanced.patcher.patch.annotations.Patch
-import app.revanced.patcher.usage.resource.annotation.ExampleResourceCompatibility
 import org.w3c.dom.Element
 
-@Patch
-@Name("example-resource-patch")
-@Description("Example demonstration of a resource patch.")
-@ExampleResourceCompatibility
-class ExampleResourcePatch : ResourcePatch {
+
+class ExampleResourcePatch : ResourcePatch() {
     override fun execute(context: ResourceContext) {
         context.xmlEditor["AndroidManifest.xml"].use { editor ->
             val element = editor // regular DomFileEditor

src/test/kotlin/app/revanced/patcher/usage/bytecode/ExampleBytecodeCompatibility.kt

@@ -1,13 +0,0 @@
-package app.revanced.patcher.usage.bytecode
-
-import app.revanced.patcher.annotation.Compatibility
-import app.revanced.patcher.annotation.Package
-
-@Compatibility(
-    [Package(
-        "com.example.examplePackage", arrayOf("0.0.1", "0.0.2")
-    )]
-)
-@Target(AnnotationTarget.CLASS)
-internal annotation class ExampleBytecodeCompatibility
-

src/test/kotlin/app/revanced/patcher/usage/bytecode/ExampleBytecodePatch.kt

@@ -1,190 +0,0 @@
-package app.revanced.patcher.usage.bytecode
-
-import app.revanced.patcher.annotation.Description
-import app.revanced.patcher.annotation.Name
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
-import app.revanced.patcher.extensions.InstructionExtensions.replaceInstruction
-import app.revanced.patcher.extensions.or
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.OptionsContainer
-import app.revanced.patcher.patch.PatchOption
-import app.revanced.patcher.patch.annotations.DependsOn
-import app.revanced.patcher.patch.annotations.Patch
-import app.revanced.patcher.usage.resource.annotation.ExampleResourceCompatibility
-import app.revanced.patcher.usage.resource.patch.ExampleResourcePatch
-import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
-import com.android.tools.smali.dexlib2.AccessFlags
-import com.android.tools.smali.dexlib2.Format
-import com.android.tools.smali.dexlib2.Opcode
-import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
-import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction11x
-import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction21c
-import com.android.tools.smali.dexlib2.iface.instruction.formats.Instruction21c
-import com.android.tools.smali.dexlib2.immutable.ImmutableField
-import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
-import com.android.tools.smali.dexlib2.immutable.ImmutableMethodImplementation
-import com.android.tools.smali.dexlib2.immutable.reference.ImmutableFieldReference
-import com.android.tools.smali.dexlib2.immutable.reference.ImmutableStringReference
-import com.android.tools.smali.dexlib2.immutable.value.ImmutableFieldEncodedValue
-import com.android.tools.smali.dexlib2.util.Preconditions
-import com.google.common.collect.ImmutableList
-
-@Patch
-@Name("example-bytecode-patch")
-@Description("Example demonstration of a bytecode patch.")
-@ExampleResourceCompatibility
-@DependsOn([ExampleResourcePatch::class])
-class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
-    // This function will be executed by the patcher.
-    // You can treat it as a constructor
-    override fun execute(context: BytecodeContext) {
-        // Get the resolved method by its fingerprint from the resolver cache
-        val result = ExampleFingerprint.result!!
-
-        // Patch options
-        println(key1)
-        key2 = false
-
-        // Get the implementation for the resolved method
-        val method = result.mutableMethod
-        val implementation = method.implementation!!
-
-        // Let's modify it, so it prints "Hello, ReVanced! Editing bytecode."
-        // Get the start index of our opcode pattern.
-        // This will be the index of the instruction with the opcode CONST_STRING.
-        val startIndex = result.scanResult.patternScanResult!!.startIndex
-
-        implementation.replaceStringAt(startIndex, "Hello, ReVanced! Editing bytecode.")
-
-        // Get the class in which the method matching our fingerprint is defined in.
-        val mainClass = context.findClass {
-            it.type == result.classDef.type
-        }!!.mutableClass
-
-        // Add a new method returning a string
-        mainClass.methods.add(
-            ImmutableMethod(
-                result.classDef.type,
-                "returnHello",
-                null,
-                "Ljava/lang/String;",
-                AccessFlags.PRIVATE or AccessFlags.STATIC,
-                null,
-                null,
-                ImmutableMethodImplementation(
-                    1,
-                    ImmutableList.of(
-                        BuilderInstruction21c(
-                            Opcode.CONST_STRING,
-                            0,
-                            ImmutableStringReference("Hello, ReVanced! Adding bytecode.")
-                        ),
-                        BuilderInstruction11x(Opcode.RETURN_OBJECT, 0)
-                    ),
-                    null,
-                    null
-                )
-            ).toMutable()
-        )
-
-        // Add a field in the main class
-        // We will use this field in our method below to call println on
-        // The field holds the Ljava/io/PrintStream->out; field
-        mainClass.fields.add(
-            ImmutableField(
-                mainClass.type,
-                "dummyField",
-                "Ljava/io/PrintStream;",
-                AccessFlags.PRIVATE or AccessFlags.STATIC,
-                ImmutableFieldEncodedValue(
-                    ImmutableFieldReference(
-                        "Ljava/lang/System;",
-                        "out",
-                        "Ljava/io/PrintStream;"
-                    )
-                ),
-                null,
-                null
-            ).toMutable()
-        )
-
-        // store the fields initial value into the first virtual register
-        method.replaceInstruction(0, "sget-object v0, LTestClass;->dummyField:Ljava/io/PrintStream;")
-
-        // Now let's create a new call to our method and print the return value!
-        // You can also use the smali compiler to create instructions.
-        // For this sake of example I reuse the TestClass field dummyField inside the virtual register 0.
-        //
-        // Control flow instructions are not supported as of now.
-        method.addInstructionsWithLabels(
-            startIndex + 2,
-            """
-                invoke-static { }, LTestClass;->returnHello()Ljava/lang/String;
-                move-result-object v1
-                invoke-virtual { v0, v1 }, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
-                """
-        )
-    }
-
-    /**
-     * Replace the string for an instruction at the given index with a new one.
-     * @param index The index of the instruction to replace the string for
-     * @param string The replacing string
-     */
-    private fun MutableMethodImplementation.replaceStringAt(index: Int, string: String) {
-        val instruction = this.instructions[index]
-
-        // Utility method of dexlib2
-        Preconditions.checkFormat(instruction.opcode, Format.Format21c)
-
-        // Cast this to an instruction of the format 21c
-        // The instruction format can be found in the docs at
-        // https://source.android.com/devices/tech/dalvik/dalvik-bytecode
-        val strInstruction = instruction as Instruction21c
-
-        // In our case we want an instruction with the opcode CONST_STRING
-        // The format is 21c, so we create a new BuilderInstruction21c
-        // This instruction will hold the string reference constant in the virtual register of the original instruction
-        // For that a reference to the string is needed. It can be created with an ImmutableStringReference.
-        // At last, use the method replaceInstruction to replace it at the given index startIndex.
-        this.replaceInstruction(
-            index,
-            BuilderInstruction21c(
-                Opcode.CONST_STRING,
-                strInstruction.registerA,
-                ImmutableStringReference(string)
-            )
-        )
-    }
-
-    @Suppress("unused")
-    companion object : OptionsContainer() {
-        private var key1 by option(
-            PatchOption.StringOption(
-                "key1", "default", "title", "description", true
-            )
-        )
-        private var key2 by option(
-            PatchOption.BooleanOption(
-                "key2", true, "title", "description" // required defaults to false
-            )
-        )
-        private var key3 by option(
-            PatchOption.StringListOption(
-                "key3", "TEST", listOf("TEST", "TEST1", "TEST2"), "title", "description"
-            )
-        )
-        private var key4 by option(
-            PatchOption.IntListOption(
-                "key4", 1, listOf(1, 2, 3), "title", "description"
-            )
-        )
-        private var key5 by option(
-            PatchOption.StringOption(
-                "key5", null, "title", "description", true
-            )
-        )
-    }
-}

src/test/kotlin/app/revanced/patcher/usage/resource/annotation/ExampleResourceCompatibility.kt

@@ -1,13 +0,0 @@
-package app.revanced.patcher.usage.resource.annotation
-
-import app.revanced.patcher.annotation.Compatibility
-import app.revanced.patcher.annotation.Package
-
-@Compatibility(
-    [Package(
-        "com.example.examplePackage", arrayOf("0.0.1", "0.0.2")
-    )]
-)
-@Target(AnnotationTarget.CLASS)
-internal annotation class ExampleResourceCompatibility
-