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

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

### Bug Fixes

* Only allow setting `MethodFingerprint#result` privately ([aed1eac](aed1eac315))

### Code Refactoring

* Change data classes to actual classes ([6192089](6192089b71))
* Convert extension functions to member functions ([e2ca507](e2ca50729d))
* Move files to simplify package structure ([124a2e9](124a2e9d3e))
* Remove deprecated classes and members ([a4212f6](a4212f6bf9))

* refactor!: Remove `Fingerprint` interface ([54a2f8f](54a2f8f16f))

### BREAKING CHANGES

* The `MethodFingerprint#result` member can now only be set inside `MethodFingerprint`.
* The `Fingerprint` interface is no longer present.
* Some extension functions are now member functions.
* This gets rid of data class members.
* Some deprecated classes and members are not present anymore.
* Classes and members have changed packages.

.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

CHANGELOG.md

@@ -1,3 +1,255 @@
+# [18.0.0-dev.6](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.5...v18.0.0-dev.6) (2023-10-22)
+
+
+### Bug Fixes
+
+* Only allow setting `MethodFingerprint#result` privately ([aed1eac](https://github.com/ReVanced/revanced-patcher/commit/aed1eac3157317acf87f522750cf2f41509606c3))
+
+
+### Code Refactoring
+
+* Change data classes to actual classes ([6192089](https://github.com/ReVanced/revanced-patcher/commit/6192089b71bdca15765369f3e607ddd1f8266205))
+* Convert extension functions to member functions ([e2ca507](https://github.com/ReVanced/revanced-patcher/commit/e2ca50729da7085799c0ff6fc4f7afaf82579738))
+* Move files to simplify package structure ([124a2e9](https://github.com/ReVanced/revanced-patcher/commit/124a2e9d3efb88f0f038ae306d941e918ad3ad3c))
+* Remove deprecated classes and members ([a4212f6](https://github.com/ReVanced/revanced-patcher/commit/a4212f6bf952971541c4550e20f6bf57a382e19a))
+
+
+* refactor!: Remove `Fingerprint` interface ([54a2f8f](https://github.com/ReVanced/revanced-patcher/commit/54a2f8f16fddf2b2ed47eb23717ba3734c4a6c5d))
+
+
+### BREAKING CHANGES
+
+* The `MethodFingerprint#result` member can now only be set inside `MethodFingerprint`.
+* The `Fingerprint` interface is no longer present.
+* Some extension functions are now member functions.
+* This gets rid of data class members.
+* Some deprecated classes and members are not present anymore.
+* Classes and members have changed packages.
+
+# [18.0.0-dev.5](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.4...v18.0.0-dev.5) (2023-10-22)
+
+
+### Bug Fixes
+
+* Do not set patch fields if they are empty ([a76ac04](https://github.com/ReVanced/revanced-patcher/commit/a76ac04214a2ab91e3b2f9dddb13ed52816fe723))
+
+# [18.0.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.3...v18.0.0-dev.4) (2023-10-22)
+
+
+### Features
+
+* Use a map for `PatchOption#values` ([54ac139](https://github.com/ReVanced/revanced-patcher/commit/54ac1394a914d3eed7865ec697e8016834134911))
+
+# [18.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.2...v18.0.0-dev.3) (2023-10-22)
+
+
+### Features
+
+* Make `PatchOption#values` nullable ([56ce9ec](https://github.com/ReVanced/revanced-patcher/commit/56ce9ec2f98ff351c3d42df71b49e5c88f07e665))
+
+# [18.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v18.0.0-dev.1...v18.0.0-dev.2) (2023-10-22)
+
+
+### 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)
 
 

api/revanced-patcher.api

@@ -65,12 +65,10 @@ public final class app/revanced/patcher/PatcherException$CircularDependencyExcep
 }
 
 public final class app/revanced/patcher/PatcherOptions {
-	public fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;)V
-	public synthetic fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;Lapp/revanced/patcher/logging/Logger;)V
-	public synthetic fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;Lapp/revanced/patcher/logging/Logger;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public final fun copy (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;Lapp/revanced/patcher/logging/Logger;)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;Lapp/revanced/patcher/logging/Logger;ILjava/lang/Object;)Lapp/revanced/patcher/PatcherOptions;
+	public fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;Z)V
+	public synthetic fun <init> (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;ZILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun copy (Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;Z)Lapp/revanced/patcher/PatcherOptions;
+	public static synthetic fun copy$default (Lapp/revanced/patcher/PatcherOptions;Ljava/io/File;Ljava/io/File;Ljava/lang/String;Ljava/lang/String;ZILjava/lang/Object;)Lapp/revanced/patcher/PatcherOptions;
 	public fun equals (Ljava/lang/Object;)Z
 	public fun hashCode ()I
 	public final fun recreateResourceCacheDirectory ()Ljava/io/File;
@@ -169,150 +167,77 @@ public final class app/revanced/patcher/extensions/InstructionExtensions {
 
 public final class app/revanced/patcher/extensions/MethodFingerprintExtensions {
 	public static final field INSTANCE Lapp/revanced/patcher/extensions/MethodFingerprintExtensions;
-	public final fun getFuzzyPatternScanMethod (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint;)Lapp/revanced/patcher/fingerprint/method/annotation/FuzzyPatternScanMethod;
+	public final fun getFuzzyPatternScanMethod (Lapp/revanced/patcher/fingerprint/MethodFingerprint;)Lapp/revanced/patcher/fingerprint/annotation/FuzzyPatternScanMethod;
 }
 
-public abstract interface class app/revanced/patcher/fingerprint/Fingerprint {
-}
-
-public abstract interface annotation class app/revanced/patcher/fingerprint/method/annotation/FuzzyPatternScanMethod : java/lang/annotation/Annotation {
-	public abstract fun threshold ()I
-}
-
-public abstract class app/revanced/patcher/fingerprint/method/impl/MethodFingerprint : app/revanced/patcher/fingerprint/Fingerprint {
-	public static final field Companion Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint$Companion;
+public abstract class app/revanced/patcher/fingerprint/MethodFingerprint {
+	public static final field Companion Lapp/revanced/patcher/fingerprint/MethodFingerprint$Companion;
 	public fun <init> ()V
 	public fun <init> (Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/Iterable;Ljava/lang/Iterable;Ljava/lang/Iterable;Lkotlin/jvm/functions/Function2;)V
 	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/Iterable;Ljava/lang/Iterable;Ljava/lang/Iterable;Lkotlin/jvm/functions/Function2;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public final fun getResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;
-	public final fun setResult (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;)V
+	public final fun getResult ()Lapp/revanced/patcher/fingerprint/MethodFingerprintResult;
+	public final fun resolve (Lapp/revanced/patcher/data/BytecodeContext;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
+	public final fun resolve (Lapp/revanced/patcher/data/BytecodeContext;Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
 }
 
-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprint$Companion {
-	public final fun resolve (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint;Lapp/revanced/patcher/data/BytecodeContext;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
-	public final fun resolve (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprint;Lapp/revanced/patcher/data/BytecodeContext;Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;)Z
+public final class app/revanced/patcher/fingerprint/MethodFingerprint$Companion {
 	public final fun resolve (Ljava/lang/Iterable;Lapp/revanced/patcher/data/BytecodeContext;Ljava/lang/Iterable;)V
 }
 
-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult {
-	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;)V
-	public final fun component1 ()Lcom/android/tools/smali/dexlib2/iface/Method;
-	public final fun component2 ()Lcom/android/tools/smali/dexlib2/iface/ClassDef;
-	public final fun component3 ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
-	public final fun copy (Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult;
-	public fun equals (Ljava/lang/Object;)Z
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult {
+	public fun <init> (Lcom/android/tools/smali/dexlib2/iface/Method;Lcom/android/tools/smali/dexlib2/iface/ClassDef;Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/data/BytecodeContext;)V
 	public final fun getClassDef ()Lcom/android/tools/smali/dexlib2/iface/ClassDef;
 	public final fun getMethod ()Lcom/android/tools/smali/dexlib2/iface/Method;
 	public final fun getMutableClass ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass;
 	public final fun getMutableMethod ()Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;
-	public final fun getScanResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
+	public final fun getScanResult ()Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult;
 }
 
-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult {
-	public fun <init> (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;)V
-	public final fun component1 ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
-	public final fun component2 ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
-	public final fun copy (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getPatternScanResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
-	public final fun getStringsScanResult ()Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult {
+	public fun <init> (Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;)V
+	public final fun getPatternScanResult ()Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
+	public final fun getStringsScanResult ()Lapp/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
 }
 
-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult {
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult {
 	public fun <init> (IILjava/util/List;)V
 	public synthetic fun <init> (IILjava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public final fun component1 ()I
-	public final fun component2 ()I
-	public final fun component3 ()Ljava/util/List;
-	public final fun copy (IILjava/util/List;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;IILjava/util/List;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult;
-	public fun equals (Ljava/lang/Object;)Z
 	public final fun getEndIndex ()I
 	public final fun getStartIndex ()I
 	public final fun getWarnings ()Ljava/util/List;
-	public fun hashCode ()I
 	public final fun setWarnings (Ljava/util/List;)V
-	public fun toString ()Ljava/lang/String;
 }
 
-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning {
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning {
 	public fun <init> (Lcom/android/tools/smali/dexlib2/Opcode;Lcom/android/tools/smali/dexlib2/Opcode;II)V
-	public final fun component1 ()Lcom/android/tools/smali/dexlib2/Opcode;
-	public final fun component2 ()Lcom/android/tools/smali/dexlib2/Opcode;
-	public final fun component3 ()I
-	public final fun component4 ()I
-	public final fun copy (Lcom/android/tools/smali/dexlib2/Opcode;Lcom/android/tools/smali/dexlib2/Opcode;II)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning;Lcom/android/tools/smali/dexlib2/Opcode;Lcom/android/tools/smali/dexlib2/Opcode;IIILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$PatternScanResult$Warning;
-	public fun equals (Ljava/lang/Object;)Z
 	public final fun getCorrectOpcode ()Lcom/android/tools/smali/dexlib2/Opcode;
 	public final fun getInstructionIndex ()I
 	public final fun getPatternIndex ()I
 	public final fun getWrongOpcode ()Lcom/android/tools/smali/dexlib2/Opcode;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
 }
 
-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult {
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult {
 	public fun <init> (Ljava/util/List;)V
-	public final fun component1 ()Ljava/util/List;
-	public final fun copy (Ljava/util/List;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;Ljava/util/List;ILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult;
-	public fun equals (Ljava/lang/Object;)Z
 	public final fun getMatches ()Ljava/util/List;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
 }
 
-public final class app/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch {
+public final class app/revanced/patcher/fingerprint/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch {
 	public fun <init> (Ljava/lang/String;I)V
-	public final fun component1 ()Ljava/lang/String;
-	public final fun component2 ()I
-	public final fun copy (Ljava/lang/String;I)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch;
-	public static synthetic fun copy$default (Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch;Ljava/lang/String;IILjava/lang/Object;)Lapp/revanced/patcher/fingerprint/method/impl/MethodFingerprintResult$MethodFingerprintScanResult$StringsScanResult$StringMatch;
-	public fun equals (Ljava/lang/Object;)Z
 	public final fun getIndex ()I
 	public final fun getString ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
 }
 
-public abstract interface class app/revanced/patcher/logging/Logger {
-	public abstract fun error (Ljava/lang/String;)V
-	public abstract fun info (Ljava/lang/String;)V
-	public abstract fun trace (Ljava/lang/String;)V
-	public abstract fun warn (Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/logging/Logger$DefaultImpls {
-	public static fun error (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
-	public static fun info (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
-	public static fun trace (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
-	public static fun warn (Lapp/revanced/patcher/logging/Logger;Ljava/lang/String;)V
-}
-
-public final class app/revanced/patcher/logging/impl/NopLogger : app/revanced/patcher/logging/Logger {
-	public static final field INSTANCE Lapp/revanced/patcher/logging/impl/NopLogger;
-	public fun error (Ljava/lang/String;)V
-	public fun info (Ljava/lang/String;)V
-	public fun trace (Ljava/lang/String;)V
-	public fun warn (Ljava/lang/String;)V
+public abstract interface annotation class app/revanced/patcher/fingerprint/annotation/FuzzyPatternScanMethod : java/lang/annotation/Annotation {
+	public abstract fun threshold ()I
 }
 
 public abstract class app/revanced/patcher/patch/BytecodePatch : app/revanced/patcher/patch/Patch {
 	public fun <init> ()V
-	public fun <init> (Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZ)V
-	public synthetic fun <init> (Ljava/util/Set;Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun <init> (Ljava/util/Set;)V
+	public synthetic fun <init> (Ljava/util/Set;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 }
 
 public abstract class app/revanced/patcher/patch/Patch {
-	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZLkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public fun equals (Ljava/lang/Object;)Z
 	public abstract fun execute (Lapp/revanced/patcher/data/Context;)V
 	public final fun getCompatiblePackages ()Ljava/util/Set;
@@ -346,21 +271,61 @@ public final class app/revanced/patcher/patch/PatchResult {
 
 public abstract class app/revanced/patcher/patch/ResourcePatch : app/revanced/patcher/patch/Patch {
 	public fun <init> ()V
-	public fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZ)V
-	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/util/Set;Ljava/util/Set;ZZILkotlin/jvm/internal/DefaultConstructorMarker;)V
 }
 
-public abstract class app/revanced/patcher/patch/options/PatchOption {
-	public fun <init> (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)V
+public abstract interface annotation class app/revanced/patcher/patch/annotation/CompatiblePackage : java/lang/annotation/Annotation {
+	public abstract fun name ()Ljava/lang/String;
+	public abstract fun versions ()[Ljava/lang/String;
+}
+
+public abstract interface annotation class app/revanced/patcher/patch/annotation/Patch : java/lang/annotation/Annotation {
+	public abstract fun compatiblePackages ()[Lapp/revanced/patcher/patch/annotation/CompatiblePackage;
+	public abstract fun dependencies ()[Ljava/lang/Class;
+	public abstract fun description ()Ljava/lang/String;
+	public abstract fun name ()Ljava/lang/String;
+	public abstract fun requiresIntegrations ()Z
+	public abstract fun use ()Z
+}
+
+public class app/revanced/patcher/patch/options/PatchOption {
+	public static final field PatchExtensions Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;
+	public fun <init> (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;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 getValidate ()Lkotlin/jvm/functions/Function1;
+	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/Map;
+	public fun reset ()V
 	public final fun setValue (Ljava/lang/Object;)V
 	public final fun setValue (Ljava/lang/Object;Lkotlin/reflect/KProperty;Ljava/lang/Object;)V
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class app/revanced/patcher/patch/options/PatchOption$PatchExtensions {
+	public final fun booleanArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Boolean;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun booleanArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Boolean;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun booleanPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Boolean;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun booleanPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Boolean;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun floatArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Float;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun floatArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Float;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun floatPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Float;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun floatPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Float;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun intArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Integer;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun intArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Integer;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun intPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Integer;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun intPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Integer;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun longArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Long;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun longArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Long;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun longPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Long;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun longPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Long;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun stringArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/String;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun stringArrayPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/String;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public final fun stringPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;)Lapp/revanced/patcher/patch/options/PatchOption;
+	public static synthetic fun stringPatchOption$default (Lapp/revanced/patcher/patch/options/PatchOption$PatchExtensions;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/PatchOption;
 }
 
 public abstract class app/revanced/patcher/patch/options/PatchOptionException : java/lang/Exception {
@@ -371,15 +336,15 @@ public final class app/revanced/patcher/patch/options/PatchOptionException$Inval
 	public fun <init> (Ljava/lang/String;Ljava/lang/String;)V
 }
 
-public final class app/revanced/patcher/patch/options/PatchOptionException$PatchOptionNotFoundException : java/lang/Exception {
+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 : java/lang/Exception {
+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 : java/lang/Exception {
+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
 }
 
@@ -412,106 +377,6 @@ public final class app/revanced/patcher/patch/options/PatchOptions : java/util/M
 	public final fun values ()Ljava/util/Collection;
 }
 
-public final class app/revanced/patcher/patch/options/types/BooleanPatchOption : app/revanced/patcher/patch/options/PatchOption {
-	public static final field Companion Lapp/revanced/patcher/patch/options/types/BooleanPatchOption$Companion;
-	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Boolean;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/types/BooleanPatchOption$Companion {
-	public final fun booleanPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Boolean;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/options/types/BooleanPatchOption;
-	public static synthetic fun booleanPatchOption$default (Lapp/revanced/patcher/patch/options/types/BooleanPatchOption$Companion;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Boolean;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/types/BooleanPatchOption;
-}
-
-public final class app/revanced/patcher/patch/options/types/FloatPatchOption : app/revanced/patcher/patch/options/PatchOption {
-	public static final field Companion Lapp/revanced/patcher/patch/options/types/FloatPatchOption$Companion;
-	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Float;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/types/FloatPatchOption$Companion {
-	public final fun floatPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Float;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/options/types/FloatPatchOption;
-	public static synthetic fun floatPatchOption$default (Lapp/revanced/patcher/patch/options/types/FloatPatchOption$Companion;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Float;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/types/FloatPatchOption;
-}
-
-public final class app/revanced/patcher/patch/options/types/IntPatchOption : app/revanced/patcher/patch/options/PatchOption {
-	public static final field Companion Lapp/revanced/patcher/patch/options/types/IntPatchOption$Companion;
-	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/types/IntPatchOption$Companion {
-	public final fun intPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/options/types/IntPatchOption;
-	public static synthetic fun intPatchOption$default (Lapp/revanced/patcher/patch/options/types/IntPatchOption$Companion;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/types/IntPatchOption;
-}
-
-public final class app/revanced/patcher/patch/options/types/LongPatchOption : app/revanced/patcher/patch/options/PatchOption {
-	public static final field Companion Lapp/revanced/patcher/patch/options/types/LongPatchOption$Companion;
-	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Long;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/types/LongPatchOption$Companion {
-	public final fun longPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Long;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/options/types/LongPatchOption;
-	public static synthetic fun longPatchOption$default (Lapp/revanced/patcher/patch/options/types/LongPatchOption$Companion;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/Long;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/types/LongPatchOption;
-}
-
-public final class app/revanced/patcher/patch/options/types/StringPatchOption : app/revanced/patcher/patch/options/PatchOption {
-	public static final field Companion Lapp/revanced/patcher/patch/options/types/StringPatchOption$Companion;
-	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/types/StringPatchOption$Companion {
-	public final fun stringPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/options/types/StringPatchOption;
-	public static synthetic fun stringPatchOption$default (Lapp/revanced/patcher/patch/options/types/StringPatchOption$Companion;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/types/StringPatchOption;
-}
-
-public final class app/revanced/patcher/patch/options/types/array/BooleanArrayPatchOption : app/revanced/patcher/patch/options/PatchOption {
-	public static final field Companion Lapp/revanced/patcher/patch/options/types/array/BooleanArrayPatchOption$Companion;
-	public synthetic fun <init> (Ljava/lang/String;[Ljava/lang/Boolean;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/types/array/BooleanArrayPatchOption$Companion {
-	public final fun booleanArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Boolean;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/options/types/array/BooleanArrayPatchOption;
-	public static synthetic fun booleanArrayPatchOption$default (Lapp/revanced/patcher/patch/options/types/array/BooleanArrayPatchOption$Companion;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Boolean;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/types/array/BooleanArrayPatchOption;
-}
-
-public final class app/revanced/patcher/patch/options/types/array/FloatArrayPatchOption : app/revanced/patcher/patch/options/PatchOption {
-	public static final field Companion Lapp/revanced/patcher/patch/options/types/array/FloatArrayPatchOption$Companion;
-	public synthetic fun <init> (Ljava/lang/String;[Ljava/lang/Float;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/types/array/FloatArrayPatchOption$Companion {
-	public final fun floatArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Float;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/options/types/array/FloatArrayPatchOption;
-	public static synthetic fun floatArrayPatchOption$default (Lapp/revanced/patcher/patch/options/types/array/FloatArrayPatchOption$Companion;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Float;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/types/array/FloatArrayPatchOption;
-}
-
-public final class app/revanced/patcher/patch/options/types/array/IntArrayPatchOption : app/revanced/patcher/patch/options/PatchOption {
-	public static final field Companion Lapp/revanced/patcher/patch/options/types/array/IntArrayPatchOption$Companion;
-	public synthetic fun <init> (Ljava/lang/String;[Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/types/array/IntArrayPatchOption$Companion {
-	public final fun intArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/options/types/array/IntArrayPatchOption;
-	public static synthetic fun intArrayPatchOption$default (Lapp/revanced/patcher/patch/options/types/array/IntArrayPatchOption$Companion;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Integer;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/types/array/IntArrayPatchOption;
-}
-
-public final class app/revanced/patcher/patch/options/types/array/LongArrayPatchOption : app/revanced/patcher/patch/options/PatchOption {
-	public static final field Companion Lapp/revanced/patcher/patch/options/types/array/LongArrayPatchOption$Companion;
-	public synthetic fun <init> (Ljava/lang/String;[Ljava/lang/Long;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/types/array/LongArrayPatchOption$Companion {
-	public final fun longArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Long;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/options/types/array/LongArrayPatchOption;
-	public static synthetic fun longArrayPatchOption$default (Lapp/revanced/patcher/patch/options/types/array/LongArrayPatchOption$Companion;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/Long;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/types/array/LongArrayPatchOption;
-}
-
-public final class app/revanced/patcher/patch/options/types/array/StringArrayPatchOption : app/revanced/patcher/patch/options/PatchOption {
-	public static final field Companion Lapp/revanced/patcher/patch/options/types/array/StringArrayPatchOption$Companion;
-	public synthetic fun <init> (Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
-}
-
-public final class app/revanced/patcher/patch/options/types/array/StringArrayPatchOption$Companion {
-	public final fun stringArrayPatchOption (Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)Lapp/revanced/patcher/patch/options/types/array/StringArrayPatchOption;
-	public static synthetic fun stringArrayPatchOption$default (Lapp/revanced/patcher/patch/options/types/array/StringArrayPatchOption$Companion;Lapp/revanced/patcher/patch/Patch;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lapp/revanced/patcher/patch/options/types/array/StringArrayPatchOption;
-}
-
 public final class app/revanced/patcher/util/DomFileEditor : java/io/Closeable {
 	public fun <init> (Ljava/io/File;)V
 	public fun close ()V

build.gradle.kts

@@ -1,10 +1,86 @@
 plugins {
-    kotlin("jvm") version "1.9.0" apply false
+    kotlin("jvm") version "1.9.10"
     alias(libs.plugins.binary.compatibility.validator)
+    `maven-publish`
+    signing
+    java
 }
 
-allprojects {
-    apply(plugin = "maven-publish")
+group = "app.revanced"
 
-    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)
+    implementation(libs.smali)
+    implementation(libs.multidexlib2)
+    implementation(libs.apktool.lib)
+    implementation(libs.kotlin.reflect)
+
+    compileOnly(libs.android)
+
+    testImplementation(libs.kotlin.test)
+}
+
+java {
+    withJavadocJar()
+    withSourcesJar()
+}
+
+kotlin {
+    jvmToolchain(11)
+}
+
+publishing {
+    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"
+                }
+            }
+        }
+    }
 }

gradle.properties

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

gradle/libs.versions.toml

@@ -1,31 +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"
+kotlinx-coroutines-core = "1.7.3"
+multidexlib2 = "3.0.3.r3"
 smali = "3.0.3"
-symbol-processing-api = "1.9.0-1.0.11"
 xpp3 = "1.1.4c"
 binary-compatibility-validator = "0.13.2"
-kotlin-compile-testing-ksp = "1.5.0"
-kotlinpoet-ksp = "1.14.2"
-ksp = "1.9.0-1.0.11"
 
 [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" }
-symbol-processing-api = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "symbol-processing-api" }
 xpp3 = { module = "xpp3:xpp3", version.ref = "xpp3" }
-kotlin-compile-testing = { module = "com.github.tschuchortdev:kotlin-compile-testing-ksp", version.ref = "kotlin-compile-testing-ksp" }
-kotlinpoet-ksp = { module = "com.squareup:kotlinpoet-ksp", version.ref = "kotlinpoet-ksp" }
 
 [plugins]
 binary-compatibility-validator = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version.ref = "binary-compatibility-validator" }
-ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }

revanced-patch-annotation-processor/api/revanced-patch-annotation-processor.api

@@ -1,24 +0,0 @@
-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 final class app/revanced/patcher/patch/annotation/processor/PatchProcessor : com/google/devtools/ksp/processing/SymbolProcessor {
-	public fun process (Lcom/google/devtools/ksp/processing/Resolver;)Ljava/util/List;
-}
-
-public final class app/revanced/patcher/patch/annotation/processor/PatchProcessorProvider : com/google/devtools/ksp/processing/SymbolProcessorProvider {
-	public fun <init> ()V
-	public fun create (Lcom/google/devtools/ksp/processing/SymbolProcessorEnvironment;)Lapp/revanced/patcher/patch/annotation/processor/PatchProcessor;
-	public synthetic fun create (Lcom/google/devtools/ksp/processing/SymbolProcessorEnvironment;)Lcom/google/devtools/ksp/processing/SymbolProcessor;
-}
-

revanced-patch-annotation-processor/build.gradle.kts

@@ -1,74 +0,0 @@
-plugins {
-    kotlin("jvm") version "1.9.0"
-    alias(libs.plugins.ksp)
-}
-
-dependencies {
-    implementation(libs.symbol.processing.api)
-    implementation(libs.kotlinpoet.ksp)
-    implementation(project(":revanced-patcher"))
-
-    testImplementation(libs.kotlin.test)
-    testImplementation(libs.kotlin.compile.testing)
-}
-
-tasks {
-    test {
-        useJUnitPlatform()
-        testLogging {
-            events("PASSED", "SKIPPED", "FAILED")
-        }
-    }
-}
-
-kotlin { jvmToolchain(11) }
-
-java {
-    withSourcesJar()
-}
-
-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>("gpr") {
-            from(components["java"])
-
-            version = project.version.toString()
-
-            pom {
-                name = "ReVanced patch annotation processor"
-                description = "Annotation processor for patches."
-                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"
-                }
-            }
-        }
-    }
-}

revanced-patch-annotation-processor/settings.gradle.kts

@@ -1,2 +0,0 @@
-rootProject.name = "revanced-patch-annotation-processor"
-

revanced-patch-annotation-processor/src/main/kotlin/app/revanced/patcher/patch/annotation/processor/PatchProcessor.kt

@@ -1,207 +0,0 @@
-package app.revanced.patcher.patch.annotation.processor
-
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.ResourcePatch
-import app.revanced.patcher.patch.annotation.Patch
-import com.google.devtools.ksp.processing.CodeGenerator
-import com.google.devtools.ksp.processing.Dependencies
-import com.google.devtools.ksp.processing.Resolver
-import com.google.devtools.ksp.processing.SymbolProcessor
-import com.google.devtools.ksp.symbol.KSAnnotated
-import com.google.devtools.ksp.symbol.KSAnnotation
-import com.google.devtools.ksp.symbol.KSClassDeclaration
-import com.google.devtools.ksp.symbol.KSType
-import com.google.devtools.ksp.validate
-import com.squareup.kotlinpoet.*
-import com.squareup.kotlinpoet.ksp.toClassName
-import com.squareup.kotlinpoet.ksp.writeTo
-import kotlin.reflect.KClass
-
-class PatchProcessor internal constructor(
-    private val codeGenerator: CodeGenerator,
-) : SymbolProcessor {
-
-    private fun KSAnnotated.isSubclassOf(cls: KClass<*>): Boolean {
-        if (this !is KSClassDeclaration) return false
-
-        if (qualifiedName?.asString() == cls.qualifiedName) return true
-
-        return superTypes.any { it.resolve().declaration.isSubclassOf(cls) }
-    }
-
-    @Suppress("UNCHECKED_CAST")
-    override fun process(resolver: Resolver): List<KSAnnotated> {
-        val patches = buildMap {
-            resolver.getSymbolsWithAnnotation(Patch::class.qualifiedName!!).filter {
-                // Do not check here if Patch is super of the class, because it is expensive.
-                // Check it later when processing.
-                it.validate() && it.isSubclassOf(app.revanced.patcher.patch.Patch::class)
-            }.map {
-                it as KSClassDeclaration
-            }.forEach { patchDeclaration ->
-                patchDeclaration.annotations.find {
-                    it.annotationType.resolve().declaration.qualifiedName!!.asString() == Patch::class.qualifiedName!!
-                }?.let { annotation ->
-                    fun KSAnnotation.property(name: String) =
-                        arguments.find { it.name!!.asString() == name }?.value!!
-
-                    val name =
-                        annotation.property("name").toString().ifEmpty { null }
-
-                    val description =
-                        annotation.property("description").toString().ifEmpty { null }
-
-                    val dependencies =
-                        (annotation.property("dependencies") as List<KSType>).ifEmpty { null }
-
-                    val compatiblePackages =
-                        (annotation.property("compatiblePackages") as List<KSAnnotation>).ifEmpty { null }
-
-                    val use =
-                        annotation.property("use") as Boolean
-
-                    val requiresIntegrations =
-                        annotation.property("requiresIntegrations") as Boolean
-
-                    // Data class for KotlinPoet
-                    data class PatchData(
-                        val name: String?,
-                        val description: String?,
-                        val dependencies: List<ClassName>?,
-                        val compatiblePackages: List<CodeBlock>?,
-                        val use: Boolean,
-                        val requiresIntegrations: Boolean
-                    )
-
-                    this[patchDeclaration] = PatchData(
-                        name,
-                        description,
-                        dependencies?.map { dependency -> dependency.toClassName() },
-                        compatiblePackages?.map {
-                            val packageName = it.property("name")
-                            val packageVersions = (it.property("versions") as List<String>).ifEmpty { null }
-                                ?.joinToString(", ") { version -> "\"$version\"" }
-
-                            CodeBlock.of(
-                                "%T(%S, %L)",
-                                app.revanced.patcher.patch.Patch.CompatiblePackage::class,
-                                packageName,
-                                packageVersions?.let { "setOf($packageVersions)" },
-                            )
-                        },
-                        use,
-                        requiresIntegrations
-                    )
-                }
-            }
-        }
-
-        // If a patch depends on another, that is annotated, the dependency should be replaced with the generated patch,
-        // because the generated patch has all the necessary properties to invoke the super constructor with,
-        // unlike the annotated patch.
-        val dependencyResolutionMap = buildMap {
-            patches.values.filter { it.dependencies != null }.flatMap {
-                it.dependencies!!
-            }.distinct().forEach { dependency ->
-                patches.keys.find { it.qualifiedName?.asString() == dependency.toString() }
-                    ?.let { patch ->
-                        this[dependency] = ClassName(
-                            patch.packageName.asString(),
-                            patch.simpleName.asString() + "Generated"
-                        )
-                    }
-            }
-        }
-
-        patches.forEach { (patchDeclaration, patchAnnotation) ->
-            val isBytecodePatch = patchDeclaration.isSubclassOf(BytecodePatch::class)
-
-            val superClass = if (isBytecodePatch) {
-                BytecodePatch::class
-            } else {
-                ResourcePatch::class
-            }
-
-            val contextClass = if (isBytecodePatch) {
-                BytecodeContext::class
-            } else {
-                ResourceContext::class
-            }
-
-            val generatedPatchClassName = ClassName(
-                patchDeclaration.packageName.asString(),
-                patchDeclaration.simpleName.asString() + "Generated"
-            )
-
-            FileSpec.builder(generatedPatchClassName)
-                .addType(
-                    TypeSpec.objectBuilder(generatedPatchClassName)
-                        .superclass(superClass).apply {
-                            patchAnnotation.name?.let { name ->
-                                addSuperclassConstructorParameter("name = %S", name)
-                            }
-
-                            patchAnnotation.description?.let { description ->
-                                addSuperclassConstructorParameter("description = %S", description)
-                            }
-
-                            patchAnnotation.compatiblePackages?.let { compatiblePackages ->
-                                addSuperclassConstructorParameter(
-                                    "compatiblePackages = setOf(%L)",
-                                    compatiblePackages.joinToString(", ")
-                                )
-                            }
-
-                            // The generated patch always depends on the source patch.
-                            addSuperclassConstructorParameter(
-                                "dependencies = setOf(%L)",
-                                buildList {
-                                    patchAnnotation.dependencies?.forEach { dependency ->
-                                        add("${(dependencyResolutionMap[dependency] ?: dependency)}::class")
-                                    }
-
-                                    add("${patchDeclaration.toClassName()}::class")
-                                }.joinToString(", "),
-                            )
-
-                            addSuperclassConstructorParameter(
-                                "use = %L", patchAnnotation.use
-                            )
-
-                            addSuperclassConstructorParameter(
-                                "requiresIntegrations = %L",
-                                patchAnnotation.requiresIntegrations
-                            )
-                        }
-                        .addFunction(
-                            FunSpec.builder("execute")
-                                .addModifiers(KModifier.OVERRIDE)
-                                .addParameter("context", contextClass)
-                                .build()
-                        )
-                        .addInitializerBlock(
-                            CodeBlock.builder()
-                                .add(
-                                    "%T.options.forEach { (_, option) ->",
-                                    patchDeclaration.toClassName()
-                                )
-                                .addStatement(
-                                    "options.register(option)"
-                                )
-                                .add(
-                                    "}"
-                                )
-                                .build()
-                        )
-                        .build()
-                ).build().writeTo(
-                    codeGenerator,
-                    Dependencies(false, patchDeclaration.containingFile!!)
-                )
-        }
-
-        return emptyList()
-    }
-}

revanced-patch-annotation-processor/src/main/kotlin/app/revanced/patcher/patch/annotation/processor/PatchProcessorProvider.kt

@@ -1,9 +0,0 @@
-package app.revanced.patcher.patch.annotation.processor
-
-import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
-import com.google.devtools.ksp.processing.SymbolProcessorProvider
-
-class PatchProcessorProvider : SymbolProcessorProvider {
-    override fun create(environment: SymbolProcessorEnvironment) =
-        PatchProcessor(environment.codeGenerator)
-}

revanced-patch-annotation-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

@@ -1 +0,0 @@
-app.revanced.patcher.patch.annotation.processor.PatchProcessorProvider

revanced-patch-annotation-processor/src/test/kotlin/app/revanced/patcher/patch/annotation/processor/TestPatchAnnotationProcessor.kt

@@ -1,147 +0,0 @@
-package app.revanced.patcher.patch.annotation.processor
-
-import app.revanced.patcher.patch.Patch
-import com.tschuchort.compiletesting.KotlinCompilation
-import com.tschuchort.compiletesting.SourceFile
-import com.tschuchort.compiletesting.kspWithCompilation
-import com.tschuchort.compiletesting.symbolProcessorProviders
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNull
-
-class TestPatchAnnotationProcessor {
-    // region Processing
-
-    @Test
-    fun testProcessing() = assertEquals(
-        "Processable patch", compile(
-            getSourceFile(
-                "processing", "ProcessablePatch"
-            )
-        ).loadPatch("$SAMPLE_PACKAGE.processing.ProcessablePatchGenerated").name
-    )
-
-    @Test
-    fun generateNullProperties() = compile(
-        getSourceFile(
-            "null", "NullPropertiesPatch"
-        )
-    ).loadPatch("$SAMPLE_PACKAGE.null.NullPropertiesPatchGenerated").let {
-        assertNull(it.description) // Because no description was provided.
-        assertNull(it.compatiblePackages!!.first().versions) // Because no versions were provided.
-    }
-
-    // endregion
-
-    // region Dependencies
-
-    @Test
-    fun testDependencies() {
-        compile(
-            getSourceFile(
-                "dependencies", "DependentPatch"
-            ), getSourceFile(
-                "dependencies", "DependencyPatch"
-            )
-        ).let { result ->
-            result.loadPatch("$SAMPLE_PACKAGE.dependencies.DependentPatchGenerated").let {
-                // Dependency as well as the source class of the generated class.
-                assertEquals(
-                    2,
-                    it.dependencies!!.size
-                )
-
-                // The last dependency is always the source class of the generated class to respect
-                // order of dependencies.
-                assertEquals(
-                    result.loadPatch("$SAMPLE_PACKAGE.dependencies.DependentPatch")::class,
-                    it.dependencies!!.last()
-                )
-            }
-        }
-    }
-
-    // endregion
-
-    // region Options
-
-    @Test
-    fun testOptions() {
-        val patch = compile(
-            getSourceFile(
-                "options", "OptionsPatch"
-            )
-        ).loadPatch("$SAMPLE_PACKAGE.options.OptionsPatchGenerated")
-
-        assert(patch.options.isNotEmpty())
-        assertEquals(patch.options["print"].title, "Print message")
-    }
-
-    // endregion
-
-    // region Limitations
-
-    @Test
-    fun failingManualDependency() = assertEquals(
-        1, // Generated patch is always dependent on source class.
-        compile(
-            getSourceFile(
-                "limitations/manualdependency", "DependentPatch"
-            ), getSourceFile(
-                "limitations/manualdependency", "DependencyPatch"
-            )
-        ).loadPatch("$SAMPLE_PACKAGE.limitations.manualdependency.DependentPatchGenerated").dependencies!!.size
-    )
-
-    // endregion
-
-    private companion object Utils {
-        const val SAMPLE_PACKAGE = "app.revanced.patcher.patch.annotation.processor.samples"
-
-        /**
-         * Get a source file from the given sample and class name.
-         *
-         * @param sample The sample to get the source file from.
-         * @param className The name of the class to get the source file from.
-         * @return The source file.
-         */
-        fun getSourceFile(sample: String, className: String): SourceFile {
-            val resourceName = "app/revanced/patcher/patch/annotation/processor/samples/$sample/$className.kt"
-            return SourceFile.kotlin(
-                "$className.kt",
-                TestPatchAnnotationProcessor::class.java.classLoader.getResourceAsStream(resourceName)
-                    ?.readAllBytes()
-                    ?.toString(Charsets.UTF_8)
-                    ?: error("Could not find resource $resourceName")
-            )
-        }
-
-        /**
-         * Compile the given source files and return the result.
-         *
-         * @param sourceFiles The source files to compile.
-         * @return The result of the compilation.
-         */
-        fun compile(vararg sourceFiles: SourceFile) = KotlinCompilation().apply {
-            sources = sourceFiles.asList()
-
-            symbolProcessorProviders = listOf(PatchProcessorProvider())
-
-            // Required until https://github.com/tschuchortdev/kotlin-compile-testing/issues/312 closed.
-            kspWithCompilation = true
-
-            inheritClassPath = true
-            messageOutputStream = System.out
-        }.compile().also { result ->
-            assertEquals(KotlinCompilation.ExitCode.OK, result.exitCode)
-        }
-
-        // region Class loading
-
-        fun KotlinCompilation.Result.loadPatch(name: String) = classLoader.loadClass(name).loadPatch()
-
-        fun Class<*>.loadPatch() = this.getField("INSTANCE").get(null) as Patch<*>
-
-        // endregion
-    }
-}

revanced-patch-annotation-processor/src/test/resources/app/revanced/patcher/patch/annotation/processor/samples/dependencies/DependencyPatch.kt

@@ -1,10 +0,0 @@
-package app.revanced.patcher.patch.annotation.processor.samples.dependencies
-
-import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.patch.ResourcePatch
-import app.revanced.patcher.patch.annotation.Patch
-
-@Patch(name = "Dependency patch")
-object DependencyPatch : ResourcePatch() {
-    override fun execute(context: ResourceContext) {}
-}

revanced-patch-annotation-processor/src/test/resources/app/revanced/patcher/patch/annotation/processor/samples/dependencies/DependentPatch.kt

@@ -1,12 +0,0 @@
-package app.revanced.patcher.patch.annotation.processor.samples.dependencies
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.annotation.Patch
-
-@Patch(
-    name = "Dependent patch",
-    dependencies = [DependencyPatch::class],
-)
-object DependentPatch : BytecodePatch() {
-    override fun execute(context: BytecodeContext) {}
-}

revanced-patch-annotation-processor/src/test/resources/app/revanced/patcher/patch/annotation/processor/samples/limitations/manualdependency/DependencyPatch.kt

@@ -1,10 +0,0 @@
-package app.revanced.patcher.patch.annotation.processor.samples.limitations.manualdependency
-
-import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.patch.ResourcePatch
-import app.revanced.patcher.patch.annotation.Patch
-
-@Patch(name = "Dependency patch")
-object DependencyPatch : ResourcePatch() {
-    override fun execute(context: ResourceContext) { }
-}

revanced-patch-annotation-processor/src/test/resources/app/revanced/patcher/patch/annotation/processor/samples/limitations/manualdependency/DependentPatch.kt

@@ -1,17 +0,0 @@
-package app.revanced.patcher.patch.annotation.processor.samples.limitations.manualdependency
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.annotation.Patch
-
-@Patch(name = "Dependent patch")
-object DependentPatch : BytecodePatch(
-    // Dependency will not be executed correctly if it is manually specified.
-    // The reason for this is that the dependency patch is annotated too,
-    // so the processor will generate a new patch class for it embedding the annotated information.
-    // Because the dependency is manually specified,
-    // the processor will not be able to change this dependency to the generated class,
-    // which means that the dependency will lose the annotated information.
-    dependencies = setOf(DependencyPatch::class)
-) {
-    override fun execute(context: BytecodeContext) {}
-}

revanced-patch-annotation-processor/src/test/resources/app/revanced/patcher/patch/annotation/processor/samples/null/NullPropertiesPatch.kt

@@ -1,14 +0,0 @@
-package app.revanced.patcher.patch.annotation.processor.samples.`null`
-
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.annotation.CompatiblePackage
-import app.revanced.patcher.patch.annotation.Patch
-
-@Patch(
-    "Patch with null properties",
-    compatiblePackages = [CompatiblePackage("com.google.android.youtube")],
-)
-object NullPropertiesPatch : BytecodePatch() {
-    override fun execute(context: BytecodeContext) {}
-}

revanced-patch-annotation-processor/src/test/resources/app/revanced/patcher/patch/annotation/processor/samples/options/OptionsPatch.kt

@@ -1,19 +0,0 @@
-package app.revanced.patcher.patch.annotation.processor.samples.options
-
-import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.patch.ResourcePatch
-import app.revanced.patcher.patch.annotation.Patch
-import app.revanced.patcher.patch.options.types.StringPatchOption.Companion.stringPatchOption
-
-@Patch(name = "Options patch")
-object OptionsPatch : ResourcePatch() {
-    override fun execute(context: ResourceContext) {}
-
-    @Suppress("unused")
-    private val printOption by stringPatchOption(
-        "print",
-        null,
-        "Print message",
-        "The message to print."
-    )
-}

revanced-patch-annotation-processor/src/test/resources/app/revanced/patcher/patch/annotation/processor/samples/processing/ProcessablePatch.kt

@@ -1,10 +0,0 @@
-package app.revanced.patcher.patch.annotation.processor.samples.processing
-
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.annotation.Patch
-
-@Patch("Processable patch")
-object ProcessablePatch : BytecodePatch() {
-    override fun execute(context: BytecodeContext) {}
-}

revanced-patcher/build.gradle.kts

@@ -1,82 +0,0 @@
-plugins {
-    kotlin("jvm") version "1.9.0"
-}
-
-dependencies {
-    implementation(libs.kotlinx.coroutines.core)
-    implementation(libs.xpp3)
-    implementation(libs.smali)
-    implementation(libs.multidexlib2)
-    implementation(libs.apktool.lib)
-    implementation(libs.kotlin.reflect)
-
-    compileOnly(libs.android)
-
-    testImplementation(project(":revanced-patch-annotation-processor"))
-    testImplementation(libs.kotlin.test)
-}
-
-tasks {
-    test {
-        useJUnitPlatform()
-        testLogging {
-            events("PASSED", "SKIPPED", "FAILED")
-        }
-    }
-
-    processResources {
-        expand("projectVersion" to project.version)
-    }
-}
-
-kotlin { jvmToolchain(11) }
-
-java {
-    withSourcesJar()
-}
-
-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>("gpr") {
-            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"
-                }
-            }
-        }
-    }
-}

revanced-patcher/settings.gradle.kts

@@ -1 +0,0 @@
-rootProject.name = "revanced-patcher"

revanced-patcher/src/main/kotlin/app/revanced/patcher/fingerprint/Fingerprint.kt

@@ -1,9 +0,0 @@
-package app.revanced.patcher.fingerprint
-
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-
-/**
- * A ReVanced fingerprint.
- * Can be a [MethodFingerprint].
- */
-interface Fingerprint

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

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

revanced-patcher/src/main/kotlin/app/revanced/patcher/logging/Logger.kt

@@ -1,9 +0,0 @@
-package app.revanced.patcher.logging
-
-@Deprecated("This will be removed in a future release")
-interface Logger {
-    fun error(msg: String) {}
-    fun warn(msg: String) {}
-    fun info(msg: String) {}
-    fun trace(msg: String) {}
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/logging/impl/NopLogger.kt

@@ -1,6 +0,0 @@
-package app.revanced.patcher.logging.impl
-
-import app.revanced.patcher.logging.Logger
-
-@Deprecated("This will be removed in a future release")
-object NopLogger : Logger

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

@@ -1,27 +0,0 @@
-package app.revanced.patcher.patch
-
-import app.revanced.patcher.PatchClass
-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.
- * @param name The name of the patch.
- * @param description The description of the patch.
- * @param compatiblePackages The packages the patch is compatible with.
- * @param dependencies The names of patches this patch depends on.
- * @param use Weather or not the patch should be used.
- * @param requiresIntegrations Weather or not the patch requires integrations.
- */
-abstract class BytecodePatch(
-    internal val fingerprints: Set<MethodFingerprint> = emptySet(),
-    name: String? = null,
-    description: String? = null,
-    compatiblePackages: Set<CompatiblePackage>? = null,
-    dependencies: Set<PatchClass>? = null,
-    use: Boolean = true,
-    // TODO: Remove this property, once integrations are coupled with patches.
-    requiresIntegrations: Boolean = false,
-) : Patch<BytecodeContext>(name, description, compatiblePackages, dependencies, use, requiresIntegrations)

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

@@ -1,24 +0,0 @@
-package app.revanced.patcher.patch
-
-import app.revanced.patcher.PatchClass
-import app.revanced.patcher.data.ResourceContext
-
-/**
- * A ReVanced [Patch] that works on [ResourceContext].
- *
- * @param name The name of the patch.
- * @param description The description of the patch.
- * @param compatiblePackages The packages the patch is compatible with.
- * @param dependencies The names of patches this patch depends on.
- * @param use Weather or not the patch should be used.
- * @param requiresIntegrations Weather or not the patch requires integrations.
- */
-abstract class ResourcePatch(
-    name: String? = null,
-    description: String? = null,
-    compatiblePackages: Set<CompatiblePackage>? = null,
-    dependencies: Set<PatchClass>? = null,
-    use: Boolean = true,
-    // TODO: Remove this property, once integrations are coupled with patches.
-    requiresIntegrations: Boolean = false,
-) : Patch<ResourceContext>(name, description, compatiblePackages, dependencies, use, requiresIntegrations)

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

@@ -1,40 +0,0 @@
-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 title The title.
- * @param description A description.
- * @param required Whether the option is required.
- * @param validate The function to validate values of the option.
- * @param T The value type of the option.
- */
-abstract class PatchOption<T>(
-    val key: String,
-    default: T?,
-    val title: String?,
-    val description: String?,
-    val required: Boolean,
-    val validate: (T?) -> Boolean
-) {
-    /**
-     * The value of the [PatchOption].
-     */
-    var value: T? = default
-        set(value) {
-            if (required && value == null) throw PatchOptionException.ValueRequiredException(this)
-            if (!validate(value)) throw PatchOptionException.ValueValidationException(value, this)
-
-            field = value
-        }
-
-    operator fun getValue(thisRef: Any?, property: KProperty<*>) = value
-
-    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T?) {
-        this.value = value
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/options/types/BooleanPatchOption.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.patch.options.types
-
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
-
-/**
- * A [PatchOption] representing a [Boolean].
- *
- * @param key The identifier.
- * @param default The default value.
- * @param title The title.
- * @param description A description.
- * @param required Whether the option is required.
- *
- * @see PatchOption
- */
-class BooleanPatchOption private constructor(
-    key: String,
-    default: Boolean?,
-    title: String?,
-    description: String?,
-    required: Boolean,
-    validator: (Boolean?) -> Boolean
-) : PatchOption<Boolean>(key, default, title, description, required, validator) {
-    companion object {
-        /**
-         * Create a new [BooleanPatchOption] and add it to the current [Patch].
-         *
-         * @param key The identifier.
-         * @param default The default value.
-         * @param title The title.
-         * @param description A description.
-         * @param required Whether the option is required.
-         * @return The created [BooleanPatchOption].
-         *
-         * @see BooleanPatchOption
-         * @see PatchOption
-         */
-        fun <T : Patch<*>> T.booleanPatchOption(
-            key: String,
-            default: Boolean? = null,
-            title: String? = null,
-            description: String? = null,
-            required: Boolean = false,
-            validator: (Boolean?) -> Boolean = { true }
-        ) = BooleanPatchOption(key, default, title, description, required, validator).also  { options.register(it) }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/options/types/FloatPatchOption.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.patch.options.types
-
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
-
-/**
- * A [PatchOption] representing a [Float].
- *
- * @param key The identifier.
- * @param default The default value.
- * @param title The title.
- * @param description A description.
- * @param required Whether the option is required.
- *
- * @see PatchOption
- */
-class FloatPatchOption private constructor(
-    key: String,
-    default: Float?,
-    title: String?,
-    description: String?,
-    required: Boolean,
-    validator: (Float?) -> Boolean
-) : PatchOption<Float>(key, default, title, description, required, validator) {
-    companion object {
-        /**
-         * Create a new [FloatPatchOption] and add it to the current [Patch].
-         *
-         * @param key The identifier.
-         * @param default The default value.
-         * @param title The title.
-         * @param description A description.
-         * @param required Whether the option is required.
-         * @return The created [FloatPatchOption].
-         *
-         * @see FloatPatchOption
-         * @see PatchOption
-         */
-        fun <T : Patch<*>> T.floatPatchOption(
-            key: String,
-            default: Float? = null,
-            title: String? = null,
-            description: String? = null,
-            required: Boolean = false,
-            validator: (Float?) -> Boolean = { true }
-        ) = FloatPatchOption(key, default, title, description, required, validator).also  { options.register(it) }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/options/types/IntPatchOption.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.patch.options.types
-
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
-
-/**
- * A [PatchOption] representing an [Integer].
- *
- * @param key The identifier.
- * @param default The default value.
- * @param title The title.
- * @param description A description.
- * @param required Whether the option is required.
- *
- * @see PatchOption
- */
-class IntPatchOption private constructor(
-    key: String,
-    default: Int?,
-    title: String?,
-    description: String?,
-    required: Boolean,
-    validator: (Int?) -> Boolean
-) : PatchOption<Int>(key, default, title, description, required, validator) {
-    companion object {
-        /**
-         * Create a new [IntPatchOption] and add it to the current [Patch].
-         *
-         * @param key The identifier.
-         * @param default The default value.
-         * @param title The title.
-         * @param description A description.
-         * @param required Whether the option is required.
-         * @return The created [IntPatchOption].
-         *
-         * @see IntPatchOption
-         * @see PatchOption
-         */
-        fun <T : Patch<*>> T.intPatchOption(
-            key: String,
-            default: Int? = null,
-            title: String? = null,
-            description: String? = null,
-            required: Boolean = false,
-            validator: (Int?) -> Boolean = { true }
-        ) = IntPatchOption(key, default, title, description, required, validator).also  { options.register(it) }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/options/types/LongPatchOption.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.patch.options.types
-
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
-
-/**
- * A [PatchOption] representing a [Long].
- *
- * @param key The identifier.
- * @param default The default value.
- * @param title The title.
- * @param description A description.
- * @param required Whether the option is required.
- *
- * @see PatchOption
- */
-class LongPatchOption private constructor(
-    key: String,
-    default: Long?,
-    title: String?,
-    description: String?,
-    required: Boolean,
-    validator: (Long?) -> Boolean
-) : PatchOption<Long>(key, default, title, description, required, validator) {
-    companion object {
-        /**
-         * Create a new [LongPatchOption] and add it to the current [Patch].
-         *
-         * @param key The identifier.
-         * @param default The default value.
-         * @param title The title.
-         * @param description A description.
-         * @param required Whether the option is required.
-         * @return The created [LongPatchOption].
-         *
-         * @see LongPatchOption
-         * @see PatchOption
-         */
-        fun <T : Patch<*>> T.longPatchOption(
-            key: String,
-            default: Long? = null,
-            title: String? = null,
-            description: String? = null,
-            required: Boolean = false,
-            validator: (Long?) -> Boolean = { true }
-        ) = LongPatchOption(key, default, title, description, required, validator).also { options.register(it) }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/options/types/StringPatchOption.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.patch.options.types
-
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
-
-/**
- * A [PatchOption] representing a [String].
- *
- * @param key The identifier.
- * @param default The default value.
- * @param title The title.
- * @param description A description.
- * @param required Whether the option is required.
- *
- * @see PatchOption
- */
-class StringPatchOption private constructor(
-    key: String,
-    default: String?,
-    title: String?,
-    description: String?,
-    required: Boolean,
-    validator: (String?) -> Boolean
-) : PatchOption<String>(key, default, title, description, required, validator) {
-    companion object {
-        /**
-         * Create a new [StringPatchOption] and add it to the current [Patch].
-         *
-         * @param key The identifier.
-         * @param default The default value.
-         * @param title The title.
-         * @param description A description.
-         * @param required Whether the option is required.
-         * @return The created [StringPatchOption].
-         *
-         * @see StringPatchOption
-         * @see PatchOption
-         */
-        fun <T : Patch<*>> T.stringPatchOption(
-            key: String,
-            default: String? = null,
-            title: String? = null,
-            description: String? = null,
-            required: Boolean = false,
-            validator: (String?) -> Boolean = { true }
-        ) = StringPatchOption(key, default, title, description, required, validator).also  { options.register(it) }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/options/types/array/BooleanArrayPatchOption.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.patch.options.types.array
-
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
-
-/**
- * A [PatchOption] representing a [Boolean] array.
- *
- * @param key The identifier.
- * @param default The default value.
- * @param title The title.
- * @param description A description.
- * @param required Whether the option is required.
- *
- * @see PatchOption
- */
-class BooleanArrayPatchOption private constructor(
-    key: String,
-    default: Array<Boolean>?,
-    title: String?,
-    description: String?,
-    required: Boolean,
-    validator: (Array<Boolean>?) -> Boolean
-) : PatchOption<Array<Boolean>>(key, default, title, description, required, validator) {
-    companion object {
-        /**
-         * Create a new [BooleanArrayPatchOption] and add it to the current [Patch].
-         *
-         * @param key The identifier.
-         * @param default The default value.
-         * @param title The title.
-         * @param description A description.
-         * @param required Whether the option is required.
-         * @return The created [BooleanArrayPatchOption].
-         *
-         * @see BooleanArrayPatchOption
-         * @see PatchOption
-         */
-        fun <T : Patch<*>> T.booleanArrayPatchOption(
-            key: String,
-            default: Array<Boolean>? = null,
-            title: String? = null,
-            description: String? = null,
-            required: Boolean = false,
-            validator: (Array<Boolean>?) -> Boolean = { true }
-        ) = BooleanArrayPatchOption(key, default, title, description, required, validator).also  { options.register(it) }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/options/types/array/FloatArrayPatchOption.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.patch.options.types.array
-
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
-
-/**
- * A [PatchOption] representing a [Float] array.
- *
- * @param key The identifier.
- * @param default The default value.
- * @param title The title.
- * @param description A description.
- * @param required Whether the option is required.
- *
- * @see PatchOption
- */
-class FloatArrayPatchOption private constructor(
-    key: String,
-    default: Array<Float>?,
-    title: String?,
-    description: String?,
-    required: Boolean,
-    validator: (Array<Float>?) -> Boolean
-) : PatchOption<Array<Float>>(key, default, title, description, required, validator) {
-    companion object {
-        /**
-         * Create a new [FloatArrayPatchOption] and add it to the current [Patch].
-         *
-         * @param key The identifier.
-         * @param default The default value.
-         * @param title The title.
-         * @param description A description.
-         * @param required Whether the option is required.
-         * @return The created [FloatArrayPatchOption].
-         *
-         * @see FloatArrayPatchOption
-         * @see PatchOption
-         */
-        fun <T : Patch<*>> T.floatArrayPatchOption(
-            key: String,
-            default: Array<Float>? = null,
-            title: String? = null,
-            description: String? = null,
-            required: Boolean = false,
-            validator: (Array<Float>?) -> Boolean = { true }
-        ) = FloatArrayPatchOption(key, default, title, description, required, validator).also  { options.register(it) }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/options/types/array/IntArrayPatchOption.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.patch.options.types.array
-
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
-
-/**
- * A [PatchOption] representing an [Integer] array.
- *
- * @param key The identifier.
- * @param default The default value.
- * @param title The title.
- * @param description A description.
- * @param required Whether the option is required.
- *
- * @see PatchOption
- */
-class IntArrayPatchOption private constructor(
-    key: String,
-    default: Array<Int>?,
-    title: String?,
-    description: String?,
-    required: Boolean,
-    validator: (Array<Int>?) -> Boolean
-) : PatchOption<Array<Int>>(key, default, title, description, required, validator) {
-    companion object {
-        /**
-         * Create a new [IntArrayPatchOption] and add it to the current [Patch].
-         *
-         * @param key The identifier.
-         * @param default The default value.
-         * @param title The title.
-         * @param description A description.
-         * @param required Whether the option is required.
-         * @return The created [IntArrayPatchOption].
-         *
-         * @see IntArrayPatchOption
-         * @see PatchOption
-         */
-        fun <T : Patch<*>> T.intArrayPatchOption(
-            key: String,
-            default: Array<Int>? = null,
-            title: String? = null,
-            description: String? = null,
-            required: Boolean = false,
-            validator: (Array<Int>?) -> Boolean = { true }
-        ) = IntArrayPatchOption(key, default, title, description, required, validator).also { options.register(it) }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/options/types/array/LongArrayPatchOption.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.patch.options.types.array
-
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
-
-/**
- * A [PatchOption] representing a [Long] array.
- *
- * @param key The identifier.
- * @param default The default value.
- * @param title The title.
- * @param description A description.
- * @param required Whether the option is required.
- *
- * @see PatchOption
- */
-class LongArrayPatchOption private constructor(
-    key: String,
-    default: Array<Long>?,
-    title: String?,
-    description: String?,
-    required: Boolean,
-    validator: (Array<Long>?) -> Boolean
-) : PatchOption<Array<Long>>(key, default, title, description, required, validator) {
-    companion object {
-        /**
-         * Create a new [LongArrayPatchOption] and add it to the current [Patch].
-         *
-         * @param key The identifier.
-         * @param default The default value.
-         * @param title The title.
-         * @param description A description.
-         * @param required Whether the option is required.
-         * @return The created [LongArrayPatchOption].
-         *
-         * @see LongArrayPatchOption
-         * @see PatchOption
-         */
-        fun <T : Patch<*>> T.longArrayPatchOption(
-            key: String,
-            default: Array<Long>? = null,
-            title: String? = null,
-            description: String? = null,
-            required: Boolean = false,
-            validator: (Array<Long>?) -> Boolean = { true }
-        ) = LongArrayPatchOption(key, default, title, description, required, validator).also  { options.register(it) }
-    }
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/options/types/array/StringArrayPatchOption.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.patch.options.types.array
-
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
-
-/**
- * A [PatchOption] representing a [String] array.
- *
- * @param key The identifier.
- * @param default The default value.
- * @param title The title.
- * @param description A description.
- * @param required Whether the option is required.
- *
- * @see PatchOption
- */
-class StringArrayPatchOption private constructor(
-    key: String,
-    default: Array<String>?,
-    title: String?,
-    description: String?,
-    required: Boolean,
-    validator: (Array<String>?) -> Boolean
-) : PatchOption<Array<String>>(key, default, title, description, required, validator) {
-    companion object {
-        /**
-         * Create a new [StringArrayPatchOption] and add it to the current [Patch].
-         *
-         * @param key The identifier.
-         * @param default The default value.
-         * @param title The title.
-         * @param description A description.
-         * @param required Whether the option is required.
-         * @return The created [StringArrayPatchOption].
-         *
-         * @see StringArrayPatchOption
-         * @see PatchOption
-         */
-        fun <T : Patch<*>> T.stringArrayPatchOption(
-            key: String,
-            default: Array<String>? = null,
-            title: String? = null,
-            description: String? = null,
-            required: Boolean = false,
-            validator: (Array<String>?) -> Boolean = { true }
-        ) = StringArrayPatchOption(key, default, title, description, required, validator).also { options.register(it) }
-    }
-}

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

@@ -1,59 +0,0 @@
-package app.revanced.patcher.patch.options
-
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.options.types.BooleanPatchOption.Companion.booleanPatchOption
-import app.revanced.patcher.patch.options.types.StringPatchOption.Companion.stringPatchOption
-import app.revanced.patcher.patch.options.types.array.StringArrayPatchOption.Companion.stringArrayPatchOption
-import org.junit.jupiter.api.assertDoesNotThrow
-import org.junit.jupiter.api.assertThrows
-import kotlin.test.Test
-
-internal class PatchOptionsTest {
-    @Test
-    fun `should not fail because default value is unvalidated`() {
-        assertDoesNotThrow {
-            OptionsTestPatch.options["required"].value
-        }
-    }
-
-    @Test
-    fun `should throw due to incorrect type`() {
-        assertThrows<PatchOptionException.InvalidValueTypeException> {
-            OptionsTestPatch.options["bool"] = 0
-        }
-    }
-
-    @Test
-    fun `should be nullable`() {
-        OptionsTestPatch.options["bool"] = 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)
-        }
-    }
-
-    private object OptionsTestPatch : BytecodePatch() {
-        private var stringOption by stringPatchOption("string", "default")
-        private var booleanOption by booleanPatchOption("bool", true)
-        private var requiredStringOption by stringPatchOption("required", "default", required = true)
-        private var nullDefaultRequiredOption by stringPatchOption("null", null, required = true)
-
-        val stringArrayOption = stringArrayPatchOption("array", arrayOf("1", "2"))
-
-        override fun execute(context: BytecodeContext) {}
-    }
-}

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
-                }
-            }
-        }
-    }
-}
-
-include("revanced-patch-annotation-processor", "revanced-patcher")
+rootProject.name = "revanced-patcher"

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

@@ -2,15 +2,14 @@ package app.revanced.patcher
 
 import app.revanced.patcher.PatchBundleLoader.Utils.getInstance
 import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolveUsingLookupMap
+import app.revanced.patcher.fingerprint.LookupMap.Maps.clearLookupMaps
+import app.revanced.patcher.fingerprint.LookupMap.Maps.initializeLookupMaps
+import app.revanced.patcher.fingerprint.MethodFingerprint.Companion.resolveUsingLookupMap
 import app.revanced.patcher.patch.*
 import kotlinx.coroutines.flow.flow
 import java.io.Closeable
 import java.io.File
 import java.util.function.Supplier
-import java.util.logging.Level
-import java.util.logging.LogManager
 import java.util.logging.Logger
 
 /**
@@ -30,18 +29,6 @@ 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)
     }
 
@@ -118,7 +105,7 @@ class Patcher(
 
             // Determine, if merging integrations is required.
             for (patch in patches)
-                if (!patch.anyRecursively { it.requiresIntegrations }) {
+                if (patch.anyRecursively { it.requiresIntegrations }) {
                     context.bytecodeContext.integrations.merge = true
                     break
                 }
@@ -201,7 +188,7 @@ class Patcher(
 
         if (context.bytecodeContext.integrations.merge) context.bytecodeContext.integrations.flush()
 
-        MethodFingerprint.initializeFingerprintResolutionLookupMaps(context.bytecodeContext)
+        initializeLookupMaps(context.bytecodeContext)
 
         // Prevent from decoding the app manifest twice if it is not needed.
         if (options.resourceDecodingMode == ResourceContext.ResourceDecodingMode.FULL)
@@ -263,7 +250,7 @@ class Patcher(
             }
     }
 
-    override fun close() = MethodFingerprint.clearFingerprintResolutionLookupMaps()
+    override fun close() = clearLookupMaps()
 
     /**
      * Compile and save the patched APK file.

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

@@ -37,4 +37,5 @@ class PatcherContext internal constructor(options: PatcherOptions) {
      * The [BytecodeContext] of this [PatcherContext].
      * This holds the current state of the bytecode.
      */
-    internal val bytecodeContext = BytecodeContext(options) }
+    internal val bytecodeContext = BytecodeContext(options)
+}

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)
 
@@ -40,26 +38,6 @@ constructor(
         frameworkDirectory = frameworkFileDirectory
     }
 
-    /**
-     * Options for ReVanced [Patcher].
-     * @param inputFile The input file to patch.
-     * @param resourceCachePath The path to the directory to use for caching resources.
-     * @param aaptBinaryPath The path to a custom aapt binary.
-     * @param frameworkFileDirectory The path to the directory to cache the framework file in.
-     */
-    constructor(
-        inputFile: File,
-        resourceCachePath: File = File("revanced-resource-cache"),
-        aaptBinaryPath: String? = null,
-        frameworkFileDirectory: String? = null,
-    ) : this(
-        inputFile,
-        resourceCachePath,
-        aaptBinaryPath,
-        frameworkFileDirectory,
-        NopLogger
-    )
-
     fun recreateResourceCacheDirectory() = resourceCachePath.also {
         if (it.exists()) {
             logger.info("Deleting existing resource cache directory")

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

@@ -12,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
 
@@ -90,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
 
@@ -108,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,
@@ -116,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
                     }
@@ -131,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

@@ -1,8 +1,8 @@
 package app.revanced.patcher.extensions
 
 import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
-import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.fingerprint.annotation.FuzzyPatternScanMethod
+import app.revanced.patcher.fingerprint.MethodFingerprint
 
 object MethodFingerprintExtensions {
     // TODO: Make this a property.

src/main/kotlin/app/revanced/patcher/fingerprint/LookupMap.kt

@@ -0,0 +1,125 @@
+package app.revanced.patcher.fingerprint
+
+import app.revanced.patcher.data.BytecodeContext
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
+import com.android.tools.smali.dexlib2.iface.reference.StringReference
+import java.util.*
+
+internal typealias MethodClassPair = Pair<Method, ClassDef>
+
+/**
+ * Lookup map for methods.
+ */
+internal class LookupMap : MutableMap<String, LookupMap.MethodClassList> by mutableMapOf() {
+    /**
+     * Adds a [MethodClassPair] to the list associated with the given key.
+     * If the key does not exist, a new list is created and the [MethodClassPair] is added to it.
+     */
+    fun add(
+        key: String,
+        methodClassPair: MethodClassPair
+    ) {
+        getOrPut(key) { MethodClassList() }.add(methodClassPair)
+    }
+
+    /**
+     * List of methods and the class they are a member of.
+     */
+    internal class MethodClassList : LinkedList<MethodClassPair>()
+
+    companion object Maps {
+        /**
+         * A list of methods and the class they are a member of.
+         */
+        internal val methods = MethodClassList()
+
+        /**
+         * Lookup map for methods keyed to the methods access flags, return type and parameter.
+         */
+        internal val methodSignatureLookupMap = LookupMap()
+
+        /**
+         * Lookup map for methods associated by strings referenced in the method.
+         */
+        internal val methodStringsLookupMap = LookupMap()
+
+        /**
+         * Initializes lookup maps for [MethodFingerprint] resolution
+         * using attributes of methods such as the method signature or strings.
+         *
+         * @param context The [BytecodeContext] containing the classes to initialize the lookup maps with.
+         */
+        internal fun initializeLookupMaps(context: BytecodeContext) {
+            if (methods.isNotEmpty()) clearLookupMaps()
+
+            context.classes.forEach { classDef ->
+                classDef.methods.forEach { method ->
+                    val methodClassPair = method to classDef
+
+                    // For fingerprints with no access or return type specified.
+                    methods += methodClassPair
+
+                    val accessFlagsReturnKey = method.accessFlags.toString() + method.returnType.first()
+
+                    // Add <access><returnType> as the key.
+                    methodSignatureLookupMap.add(accessFlagsReturnKey, methodClassPair)
+
+                    // Add <access><returnType>[parameters] as the key.
+                    methodSignatureLookupMap.add(
+                        buildString {
+                            append(accessFlagsReturnKey)
+                            appendParameters(method.parameterTypes)
+                        },
+                        methodClassPair
+                    )
+
+                    // Add strings contained in the method as the key.
+                    method.implementation?.instructions?.forEach instructions@{ instruction ->
+                        if (instruction.opcode != Opcode.CONST_STRING && instruction.opcode != Opcode.CONST_STRING_JUMBO)
+                            return@instructions
+
+                        val string = ((instruction as ReferenceInstruction).reference as StringReference).string
+
+                        methodStringsLookupMap.add(string, methodClassPair)
+                    }
+
+                    // In the future, the class type could be added to the lookup map.
+                    // This would require MethodFingerprint to be changed to include the class type.
+                }
+            }
+        }
+
+        /**
+         * Clears the internal lookup maps created in [initializeLookupMaps]
+         */
+        internal fun clearLookupMaps() {
+            methods.clear()
+            methodSignatureLookupMap.clear()
+            methodStringsLookupMap.clear()
+        }
+
+        /**
+         * Appends a string based on the parameter reference types of this method.
+         */
+        internal fun StringBuilder.appendParameters(parameters: Iterable<CharSequence>) {
+            // Maximum parameters to use in the signature key.
+            // Some apps have methods with an incredible number of parameters (over 100 parameters have been seen).
+            // To keep the signature map from becoming needlessly bloated,
+            // group together in the same map entry all methods with the same access/return and 5 or more parameters.
+            // The value of 5 was chosen based on local performance testing and is not set in stone.
+            val maxSignatureParameters = 5
+            // Must append a unique value before the parameters to distinguish this key includes the parameters.
+            // If this is not appended, then methods with no parameters
+            // will collide with different keys that specify access/return but omit the parameters.
+            append("p:")
+            parameters.forEachIndexed { index, parameter ->
+                if (index >= maxSignatureParameters) return
+                append(parameter.first())
+            }
+        }
+
+    }
+}

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

@@ -0,0 +1,320 @@
+package app.revanced.patcher.fingerprint
+
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.extensions.MethodFingerprintExtensions.fuzzyPatternScanMethod
+import app.revanced.patcher.fingerprint.LookupMap.Maps.appendParameters
+import app.revanced.patcher.fingerprint.LookupMap.Maps.initializeLookupMaps
+import app.revanced.patcher.fingerprint.LookupMap.Maps.methodSignatureLookupMap
+import app.revanced.patcher.fingerprint.LookupMap.Maps.methodStringsLookupMap
+import app.revanced.patcher.fingerprint.LookupMap.Maps.methods
+import app.revanced.patcher.fingerprint.MethodFingerprintResult.MethodFingerprintScanResult.StringsScanResult
+import app.revanced.patcher.fingerprint.annotation.FuzzyPatternScanMethod
+import app.revanced.patcher.patch.PatchException
+import com.android.tools.smali.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.iface.instruction.Instruction
+import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
+import com.android.tools.smali.dexlib2.iface.reference.StringReference
+
+/**
+ * A fingerprint to resolve methods.
+ *
+ * @param returnType The method's return type compared using [String.startsWith].
+ * @param accessFlags The method's exact access flags using values of [AccessFlags].
+ * @param parameters The parameters of the method. Partial matches allowed and follow the same rules as [returnType].
+ * @param opcodes An opcode pattern of the method's instructions. Wildcard or unknown opcodes can be specified by `null`.
+ * @param strings A list of the method's strings compared each using [String.contains].
+ * @param customFingerprint A custom condition for this fingerprint.
+ */
+abstract class MethodFingerprint(
+    internal val returnType: String? = null,
+    internal val accessFlags: Int? = null,
+    internal val parameters: Iterable<String>? = null,
+    internal val opcodes: Iterable<Opcode?>? = null,
+    internal val strings: Iterable<String>? = null,
+    internal val customFingerprint: ((methodDef: Method, classDef: ClassDef) -> Boolean)? = null
+) {
+    /**
+     * The result of the [MethodFingerprint].
+     */
+    var result: MethodFingerprintResult? = null
+        private set
+
+    /**
+     * Resolve a [MethodFingerprint] using the lookup map built by [initializeLookupMaps].
+     *
+     * [MethodFingerprint] resolution is fast, but if many are present they can consume a noticeable
+     * amount of time because they are resolved in sequence.
+     *
+     * For apps with many fingerprints, resolving performance can be improved by:
+     * - Slowest: Specify [opcodes] and nothing else.
+     * - Fast: Specify [accessFlags], [returnType].
+     * - Faster: Specify [accessFlags], [returnType] and [parameters].
+     * - Fastest: Specify [strings], with at least one string being an exact (non-partial) match.
+     */
+    internal fun resolveUsingLookupMap(context: BytecodeContext): Boolean {
+        /**
+         * Lookup [MethodClassPair]s that match the methods strings present in a [MethodFingerprint].
+         *
+         * @return A list of [MethodClassPair]s that match the methods strings present in a [MethodFingerprint].
+         */
+        fun MethodFingerprint.methodStringsLookup(): LookupMap.MethodClassList? {
+            strings?.forEach {
+                val methods = methodStringsLookupMap[it]
+                if (methods != null) return methods
+            }
+            return null
+        }
+
+        /**
+         * Lookup [MethodClassPair]s that match the method signature present in a [MethodFingerprint].
+         *
+         * @return A list of [MethodClassPair]s that match the method signature present in a [MethodFingerprint].
+         */
+        fun MethodFingerprint.methodSignatureLookup(): LookupMap.MethodClassList {
+            if (accessFlags == null) return methods
+
+            var returnTypeValue = returnType
+            if (returnTypeValue == null) {
+                if (AccessFlags.CONSTRUCTOR.isSet(accessFlags)) {
+                    // Constructors always have void return type
+                    returnTypeValue = "V"
+                } else {
+                    return methods
+                }
+            }
+
+            val key = buildString {
+                append(accessFlags)
+                append(returnTypeValue.first())
+                if (parameters != null) appendParameters(parameters)
+            }
+            return methodSignatureLookupMap[key] ?: return LookupMap.MethodClassList()
+        }
+
+        /**
+         * Resolve a [MethodFingerprint] using a list of [MethodClassPair].
+         *
+         * @return True if the resolution was successful, false otherwise.
+         */
+        fun MethodFingerprint.resolveUsingMethodClassPair(methodClasses: LookupMap.MethodClassList): Boolean {
+            methodClasses.forEach { classAndMethod ->
+                if (resolve(context, classAndMethod.first, classAndMethod.second)) return true
+            }
+            return false
+        }
+
+        val methodsWithSameStrings = methodStringsLookup()
+        if (methodsWithSameStrings != null) if (resolveUsingMethodClassPair(methodsWithSameStrings)) return true
+
+        // No strings declared or none matched (partial matches are allowed).
+        // Use signature matching.
+        return resolveUsingMethodClassPair(methodSignatureLookup())
+    }
+
+    /**
+     * Resolve a [MethodFingerprint] against a [ClassDef].
+     *
+     * @param forClass The class on which to resolve the [MethodFingerprint] in.
+     * @param context The [BytecodeContext] to host proxies.
+     * @return True if the resolution was successful, false otherwise.
+     */
+    fun resolve(context: BytecodeContext, forClass: ClassDef): Boolean {
+        for (method in forClass.methods)
+            if (resolve(context, method, forClass))
+                return true
+        return false
+    }
+
+    /**
+     * Resolve a [MethodFingerprint] against a [Method].
+     *
+     * @param method The class on which to resolve the [MethodFingerprint] in.
+     * @param forClass The class on which to resolve the [MethodFingerprint].
+     * @param context The [BytecodeContext] to host proxies.
+     * @return True if the resolution was successful or if the fingerprint is already resolved, false otherwise.
+     */
+    fun resolve(context: BytecodeContext, method: Method, forClass: ClassDef): Boolean {
+        val methodFingerprint = this
+
+        if (methodFingerprint.result != null) return true
+
+        if (methodFingerprint.returnType != null && !method.returnType.startsWith(methodFingerprint.returnType))
+            return false
+
+        if (methodFingerprint.accessFlags != null && methodFingerprint.accessFlags != method.accessFlags)
+            return false
+
+
+        fun parametersEqual(
+            parameters1: Iterable<CharSequence>, parameters2: Iterable<CharSequence>
+        ): Boolean {
+            if (parameters1.count() != parameters2.count()) return false
+            val iterator1 = parameters1.iterator()
+            parameters2.forEach {
+                if (!it.startsWith(iterator1.next())) return false
+            }
+            return true
+        }
+
+        if (methodFingerprint.parameters != null && !parametersEqual(
+                methodFingerprint.parameters, // TODO: parseParameters()
+                method.parameterTypes
+            )
+        ) return false
+
+        @Suppress("UNNECESSARY_NOT_NULL_ASSERTION")
+        if (methodFingerprint.customFingerprint != null && !methodFingerprint.customFingerprint!!(method, forClass))
+            return false
+
+        val stringsScanResult: StringsScanResult? =
+            if (methodFingerprint.strings != null) {
+                StringsScanResult(
+                    buildList {
+                        val implementation = method.implementation ?: return false
+
+                        val stringsList = methodFingerprint.strings.toMutableList()
+
+                        implementation.instructions.forEachIndexed { instructionIndex, instruction ->
+                            if (
+                                instruction.opcode != Opcode.CONST_STRING &&
+                                instruction.opcode != Opcode.CONST_STRING_JUMBO
+                            ) return@forEachIndexed
+
+                            val string = ((instruction as ReferenceInstruction).reference as StringReference).string
+                            val index = stringsList.indexOfFirst(string::contains)
+                            if (index == -1) return@forEachIndexed
+
+                            add(StringsScanResult.StringMatch(string, instructionIndex))
+                            stringsList.removeAt(index)
+                        }
+
+                        if (stringsList.isNotEmpty()) return false
+                    }
+                )
+            } else null
+
+        val patternScanResult = if (methodFingerprint.opcodes != null) {
+            method.implementation?.instructions ?: return false
+
+            fun MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.newWarnings(
+                pattern: Iterable<Opcode?>, instructions: Iterable<Instruction>
+            ) = buildList {
+                for ((patternIndex, instructionIndex) in (this@newWarnings.startIndex until this@newWarnings.endIndex).withIndex()) {
+                    val originalOpcode = instructions.elementAt(instructionIndex).opcode
+                    val patternOpcode = pattern.elementAt(patternIndex)
+
+                    if (patternOpcode == null || patternOpcode.ordinal == originalOpcode.ordinal) continue
+
+                    this.add(
+                        MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.Warning(
+                            originalOpcode,
+                            patternOpcode,
+                            instructionIndex,
+                            patternIndex
+                        )
+                    )
+                }
+            }
+
+            fun Method.patternScan(
+                fingerprint: MethodFingerprint
+            ): MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult? {
+                val instructions = this.implementation!!.instructions
+                val fingerprintFuzzyPatternScanThreshold = fingerprint.fuzzyPatternScanMethod?.threshold ?: 0
+
+                val pattern = fingerprint.opcodes!!
+                val instructionLength = instructions.count()
+                val patternLength = pattern.count()
+
+                for (index in 0 until instructionLength) {
+                    var patternIndex = 0
+                    var threshold = fingerprintFuzzyPatternScanThreshold
+
+                    while (index + patternIndex < instructionLength) {
+                        val originalOpcode = instructions.elementAt(index + patternIndex).opcode
+                        val patternOpcode = pattern.elementAt(patternIndex)
+
+                        if (patternOpcode != null && patternOpcode.ordinal != originalOpcode.ordinal) {
+                            // reaching maximum threshold (0) means,
+                            // the pattern does not match to the current instructions
+                            if (threshold-- == 0) break
+                        }
+
+                        if (patternIndex < patternLength - 1) {
+                            // if the entire pattern has not been scanned yet
+                            // continue the scan
+                            patternIndex++
+                            continue
+                        }
+                        // the pattern is valid, generate warnings if fuzzyPatternScanMethod is FuzzyPatternScanMethod
+                        val result =
+                            MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult(
+                                index,
+                                index + patternIndex
+                            )
+                        if (fingerprint.fuzzyPatternScanMethod !is FuzzyPatternScanMethod) return result
+                        result.warnings = result.newWarnings(pattern, instructions)
+
+                        return result
+                    }
+                }
+
+                return null
+            }
+
+            method.patternScan(methodFingerprint) ?: return false
+        } else null
+
+        methodFingerprint.result = MethodFingerprintResult(
+            method,
+            forClass,
+            MethodFingerprintResult.MethodFingerprintScanResult(
+                patternScanResult,
+                stringsScanResult
+            ),
+            context
+        )
+
+        return true
+    }
+
+    companion object {
+        /**
+         * Resolve a list of [MethodFingerprint] using the lookup map built by [initializeLookupMaps].
+         *
+         * [MethodFingerprint] resolution is fast, but if many are present they can consume a noticeable
+         * amount of time because they are resolved in sequence.
+         *
+         * For apps with many fingerprints, resolving performance can be improved by:
+         * - Slowest: Specify [opcodes] and nothing else.
+         * - Fast: Specify [accessFlags], [returnType].
+         * - Faster: Specify [accessFlags], [returnType] and [parameters].
+         * - Fastest: Specify [strings], with at least one string being an exact (non-partial) match.
+         */
+        internal fun Set<MethodFingerprint>.resolveUsingLookupMap(context: BytecodeContext) {
+            if (methods.isEmpty()) throw PatchException("lookup map not initialized")
+
+            forEach { fingerprint ->
+                fingerprint.resolveUsingLookupMap(context)
+            }
+        }
+
+        /**
+         * Resolve a list of [MethodFingerprint] against a list of [ClassDef].
+         *
+         * @param classes The classes on which to resolve the [MethodFingerprint] in.
+         * @param context The [BytecodeContext] to host proxies.
+         * @return True if the resolution was successful, false otherwise.
+         */
+        fun Iterable<MethodFingerprint>.resolve(context: BytecodeContext, classes: Iterable<ClassDef>) =
+            forEach { fingerprint ->
+                for (classDef in classes) {
+                    if (fingerprint.resolve(context, classDef)) break
+                }
+            }
+    }
+}
+

src/main/kotlin/app/revanced/patcher/fingerprint/MethodFingerprintResult.kt

@@ -0,0 +1,94 @@
+package app.revanced.patcher.fingerprint
+
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.util.proxy.ClassProxy
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.util.MethodUtil
+
+/**
+ * Represents the result of a [MethodFingerprintResult].
+ *
+ * @param method The matching method.
+ * @param classDef The [ClassDef] that contains the matching [method].
+ * @param scanResult The result of scanning for the [MethodFingerprint].
+ * @param context The [BytecodeContext] this [MethodFingerprintResult] is attached to, to create proxies.
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+class MethodFingerprintResult(
+    val method: Method,
+    val classDef: ClassDef,
+    val scanResult: MethodFingerprintScanResult,
+    internal val context: BytecodeContext
+) {
+    /**
+     * Returns a mutable clone of [classDef]
+     *
+     * Please note, this method allocates a [ClassProxy].
+     * Use [classDef] where possible.
+     */
+    @Suppress("MemberVisibilityCanBePrivate")
+    val mutableClass by lazy { context.proxy(classDef).mutableClass }
+
+    /**
+     * Returns a mutable clone of [method]
+     *
+     * Please note, this method allocates a [ClassProxy].
+     * Use [method] where possible.
+     */
+    val mutableMethod by lazy {
+        mutableClass.methods.first {
+            MethodUtil.methodSignaturesMatch(it, this.method)
+        }
+    }
+
+    /**
+     * The result of scanning on the [MethodFingerprint].
+     * @param patternScanResult The result of the pattern scan.
+     * @param stringsScanResult The result of the string scan.
+     */
+    class MethodFingerprintScanResult(
+        val patternScanResult: PatternScanResult?,
+        val stringsScanResult: StringsScanResult?
+    ) {
+        /**
+         * The result of scanning strings on the [MethodFingerprint].
+         * @param matches The list of strings that were matched.
+         */
+        class StringsScanResult(val matches: List<StringMatch>) {
+            /**
+             * Represents a match for a string at an index.
+             * @param string The string that was matched.
+             * @param index The index of the string.
+             */
+            class StringMatch(val string: String, val index: Int)
+        }
+
+        /**
+         * The result of a pattern scan.
+         * @param startIndex The start index of the instructions where to which this pattern matches.
+         * @param endIndex The end index of the instructions where to which this pattern matches.
+         * @param warnings A list of warnings considering this [PatternScanResult].
+         */
+        class PatternScanResult(
+            val startIndex: Int,
+            val endIndex: Int,
+            var warnings: List<Warning>? = null
+        ) {
+            /**
+             * Represents warnings of the pattern scan.
+             * @param correctOpcode The opcode the instruction list has.
+             * @param wrongOpcode The opcode the pattern list of the signature currently has.
+             * @param instructionIndex The index of the opcode relative to the instruction list.
+             * @param patternIndex The index of the opcode relative to the pattern list from the signature.
+             */
+            class Warning(
+                val correctOpcode: Opcode,
+                val wrongOpcode: Opcode,
+                val instructionIndex: Int,
+                val patternIndex: Int,
+            )
+        }
+    }
+}

src/main/kotlin/app/revanced/patcher/fingerprint/annotation/MethodFingerprintAnnotations.kt

@@ -1,6 +1,6 @@
-package app.revanced.patcher.fingerprint.method.annotation
+package app.revanced.patcher.fingerprint.annotation
 
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.fingerprint.MethodFingerprint
 
 /**
  * Annotations to scan a pattern [MethodFingerprint] with fuzzy algorithm.

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.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/Patch.kt

@@ -1,4 +1,4 @@
-@file:Suppress("MemberVisibilityCanBePrivate", "UNUSED_PARAMETER")
+@file:Suppress("MemberVisibilityCanBePrivate")
 
 package app.revanced.patcher.patch
 
@@ -7,35 +7,72 @@ import app.revanced.patcher.Patcher
 import app.revanced.patcher.data.Context
 import app.revanced.patcher.patch.options.PatchOptions
 import java.io.Closeable
+import kotlin.reflect.full.findAnnotation
 
 /**
  * A ReVanced patch.
- *
  * If an implementation of [Patch] also implements [Closeable]
  * it will be closed in reverse execution order of patches executed by ReVanced [Patcher].
  *
- * @param name The name of the patch.
- * @param description The description of the patch.
- * @param compatiblePackages The packages the patch is compatible with.
- * @param dependencies The names of patches this patch depends on.
- * @param use Weather or not the patch should be used.
- * @param requiresIntegrations Weather or not the patch requires integrations.
  * @param T The [Context] type this patch will work on.
  */
-sealed class Patch<out T : Context<*>>(
-    val name: String? = null,
-    val description: String? = null,
-    val compatiblePackages: Set<CompatiblePackage>? = null,
-    val dependencies: Set<PatchClass>? = null,
-    val use: Boolean = true,
+sealed class Patch<out T : Context<*>> {
+    /**
+     * 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.
-    val requiresIntegrations: Boolean = false,
-) {
+    /**
+     * 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().ifEmpty { null }) }
+                .toSet().ifEmpty { null }
+            dependencies = annotation.dependencies.toSet().ifEmpty { null }
+            use = annotation.use
+            requiresIntegrations = annotation.requiresIntegrations
+        }
+    }
+
     /**
      * The execution function of the patch.
      *
@@ -67,5 +104,4 @@ sealed class Patch<out T : Context<*>>(
         val name: String,
         val versions: Set<String>? = null,
     )
-}
-
+}

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

@@ -6,5 +6,4 @@ package app.revanced.patcher.patch
  * @param patch The [Patch] that was executed.
  * @param exception The [PatchException] thrown, if any.
  */
-@Suppress("MemberVisibilityCanBePrivate")
 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

@@ -13,7 +13,6 @@ import kotlin.reflect.KClass
  * @param use Whether this patch should be used.
  * @param requiresIntegrations Whether this patch requires integrations.
  */
-@Retention(AnnotationRetention.SOURCE)
 @Target(AnnotationTarget.CLASS)
 @Inherited
 annotation class Patch(

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 identified by their string representation.
+ * @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: Map<String, 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: Map<String, String?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<String>.(String?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * 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: Map<String, Int?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Int?>.(Int?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * 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: Map<String, Boolean?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Boolean?>.(Boolean?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * 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: Map<String, Float?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Float?>.(Float?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * 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: Map<String, Long?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Long?>.(Long?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * 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: Map<String, Array<String>?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Array<String>?>.(Array<String>?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * 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: Map<String, Array<Int>?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Array<Int>?>.(Array<Int>?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * 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: Map<String, Array<Boolean>?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Array<Boolean>?>.(Array<Boolean>?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * 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: Map<String, Array<Float>?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Array<Float>?>.(Array<Float>?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        /**
+         * 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: Map<String, Array<Long>?>? = null,
+            title: String? = null,
+            description: String? = null,
+            required: Boolean = false,
+            validator: PatchOption<Array<Long>?>.(Array<Long>?) -> Boolean = { true }
+        ) = PatchOption(key, default, values, title, description, required, validator).also { registerOption(it) }
+
+        private fun <P : Patch<*>> P.registerOption(option: PatchOption<*>) = option.also { options.register(it) }
+    }
+}

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

@@ -21,7 +21,7 @@ sealed class PatchOptionException(errorMessage: String) : Exception(errorMessage
      * @param value The value that failed validation.
      */
     class ValueValidationException(value: Any?, option: PatchOption<*>) :
-        Exception("The option value \"$value\" failed validation for ${option.key}")
+        PatchOptionException("The option value \"$value\" failed validation for ${option.key}")
 
     /**
      * An exception thrown when a value is required but null was passed.
@@ -29,7 +29,7 @@ sealed class PatchOptionException(errorMessage: String) : Exception(errorMessage
      * @param option The [PatchOption] that requires a value.
      */
     class ValueRequiredException(option: PatchOption<*>) :
-        Exception("The option ${option.key} requires a value, but null was passed")
+        PatchOptionException("The option ${option.key} requires a value, but null was passed")
 
     /**
      * An exception thrown when a [PatchOption] is not found.
@@ -37,5 +37,5 @@ sealed class PatchOptionException(errorMessage: String) : Exception(errorMessage
      * @param key The key of the [PatchOption].
      */
     class PatchOptionNotFoundException(key: String)
-        : Exception("No option with key $key")
+        : PatchOptionException("No option with key $key")
 }