@futpib/parser 1.0.2 → 1.0.3

package/build/dalvikExecutableParser.test.js

@@ -3,13 +3,9 @@ import { runParser } from './parser.js';
 import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { dalvikExecutableParser, dalvikExecutableWithRawInstructionsParser } from './dalvikExecutableParser.js';
 import { fetchCid } from './fetchCid.js';
-for (const [dexCid, shouldSnapshot] of [
-    ['bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true],
-    ['bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false],
-    ['bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false],
-    ['bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false],
-]) {
-    test.serial('dex (with instructions as bytes) ' + dexCid, async (t) => {
+const dexWithRawInstructionsMacro = test.macro({
+    title: (providedTitle, dexCid) => providedTitle ?? `dex (with instructions as bytes) ${dexCid}`,
+    async exec(t, dexCid, shouldSnapshot) {
         const dexStream = await fetchCid(dexCid);
         const actual = await runParser(dalvikExecutableWithRawInstructionsParser, dexStream, uint8ArrayParserInputCompanion, {
             errorJoinMode: 'all',
@@ -18,11 +14,15 @@ for (const [dexCid, shouldSnapshot] of [
             t.snapshot(actual);
         }
         else {
-            //console.dir(actual, { depth: null });
+            // Console.dir(actual, { depth: null });
             t.pass();
         }
-    });
-}
+    },
+});
+test.serial(dexWithRawInstructionsMacro, 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true);
+test.serial(dexWithRawInstructionsMacro, 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false);
+test.serial(dexWithRawInstructionsMacro, 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false);
+test.serial(dexWithRawInstructionsMacro, 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false);
 function objectWalk(object, f, initialPath = []) {
     f(initialPath, object);
     if (!object
@@ -40,31 +40,33 @@ function objectWalk(object, f, initialPath = []) {
         }
     }
 }
-for (const [dexCid, shouldSnapshot] of [
-    ['bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true],
-    // [ 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false ],
-    // [ 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false ],
-    // [ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false ],
-]) {
-    test.serial('dex (with parsed instructions) ' + dexCid, async (t) => {
+const dexWithParsedInstructionsMacro = test.macro({
+    title: (providedTitle, dexCid) => providedTitle ?? `dex (with parsed instructions) ${dexCid}`,
+    async exec(t, dexCid, shouldSnapshot) {
         const dexStream = await fetchCid(dexCid);
+        debugger;
         const actual = await runParser(dalvikExecutableParser, dexStream, uint8ArrayParserInputCompanion, {
             errorJoinMode: 'all',
         });
-        objectWalk(actual, (path) => {
+        debugger;
+        objectWalk(actual, path => {
             const key = path.at(-1);
             if (typeof key !== 'string') {
                 return;
             }
-            t.false(key.endsWith('Offset'), 'All offsets should be resolved: ' + path.join('.'));
+            t.false(key.endsWith('Offset') && key !== 'branchOffset', 'All offsets should be resolved: ' + path.join('.'));
             t.false(key.endsWith('Index'), 'All indexes should be resolved: ' + path.join('.'));
         });
         if (shouldSnapshot) {
             t.snapshot(actual);
         }
         else {
-            //console.dir(actual, { depth: null });
+            // Console.dir(actual, { depth: null });
             t.pass();
         }
-    });
-}
+    },
+});
+test.serial.only(dexWithParsedInstructionsMacro, 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true);
+test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false);
+test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false);
+test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false);

package/build/dalvikExecutableParserAgainstSmaliParser.test.js

@@ -4,7 +4,7 @@ import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './pa
 import { dalvikExecutableParser } from './dalvikExecutableParser.js';
 import { fetchCid } from './fetchCid.js';
 import { hasExecutable } from './hasExecutable.js';
-import { baksmaliClass } from './backsmali.js';
+import { backsmaliSmaliIsolateClass, baksmaliClass, baksmaliListClasses } from './backsmali.js';
 import { smaliParser } from './smaliParser.js';
 import { smaliClass } from './smali.js';
 const hasBaksmaliPromise = hasExecutable('baksmali');
@@ -26,253 +26,235 @@ function objectWalk(object, f, initialPath = []) {
         }
     }
 }
-for (const [dexCid, smaliFilePaths] of [
-    [
-        'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4',
-        [
-            'pl/czak/minimal/MainActivity',
-        ],
-    ],
-    // [
-    // 	'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq',
-    // 	[
-    // 		'd/m',
-    // 	],
-    // ],
-    // [ 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq' ],
-    // [
-    // 	'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy',
-    // 	[
-    // 		'com/journeyapps/barcodescanner/CaptureActivity',
-    // 	],
-    // ],
-    // [ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda' ],
-]) {
-    for (const smaliFilePath of smaliFilePaths) {
-        test.serial('parse(dex) against parse(smali(dex))' + dexCid + ' ' + smaliFilePath, async (t) => {
-            const hasBaksmali = await hasBaksmaliPromise;
-            if (!hasBaksmali) {
-                t.pass('skipping test because baksmali is not available');
-                return;
+function normalizeSmaliFilePath(smaliFilePath) {
+    if (typeof smaliFilePath === 'string') {
+        return {
+            smaliFilePath,
+            isolate: false,
+        };
+    }
+    return {
+        smaliFilePath: smaliFilePath.smaliFilePath,
+        isolate: smaliFilePath.isolate ?? false,
+    };
+}
+function normalizeClassDefinition(classDefinition) {
+    objectWalk(classDefinition, (_path, value) => {
+        if (value
+            && typeof value === 'object'
+            && 'debugInfo' in value) {
+            value.debugInfo = undefined;
+        }
+    });
+}
+const parseDexAgainstSmaliMacro = test.macro({
+    title(providedTitle, dexCid, smaliFilePathInput) {
+        const { smaliFilePath, isolate } = normalizeSmaliFilePath(smaliFilePathInput);
+        return providedTitle ?? `parse(dex) against parse(smali(dex)) ${dexCid} ${smaliFilePath}${isolate ? ' isolated' : ''}`;
+    },
+    async exec(t, dexCid, smaliFilePathInput) {
+        const { smaliFilePath, isolate } = normalizeSmaliFilePath(smaliFilePathInput);
+        const hasBaksmali = await hasBaksmaliPromise;
+        if (!hasBaksmali) {
+            t.pass('skipping test because baksmali is not available');
+            return;
+        }
+        const dexStream = await fetchCid(dexCid);
+        const smali_ = await baksmaliClass(dexStream, smaliFilePath);
+        const smali = (smali_
+            .replaceAll(/^\s+# getter for:.*$/gm, '')
+            .replaceAll(/^\s+# setter for:.*$/gm, '')
+            .replaceAll(/^\s+# invokes:.*$/gm, '')
+            .replaceAll(/\n{3,}/g, '\n\n'));
+        // Console.log(smali);
+        const classDefinitionFromSmali = await runParser(smaliParser, smali, stringParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        let dexStream2 = await fetchCid(dexCid);
+        if (isolate) {
+            dexStream2 = await backsmaliSmaliIsolateClass(dexStream2, smaliFilePath);
+        }
+        const executableFromDex = await runParser(dalvikExecutableParser, dexStream2, uint8ArrayParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        const classDefinitionFromDex = executableFromDex.classDefinitions.find(classDefinition => classDefinition.class === classDefinitionFromSmali.class);
+        // Normalize both DEX and Smali by removing debug info
+        normalizeClassDefinition(classDefinitionFromDex);
+        normalizeClassDefinition(classDefinitionFromSmali);
+        // Console.dir({
+        // 	classDefinitionFromSmali,
+        // 	classDefinitionFromDex,
+        // }, {
+        // 	depth: null,
+        // });
+        t.deepEqual(classDefinitionFromDex, classDefinitionFromSmali);
+    },
+});
+const parseAllClassesInDexAgainstSmaliMacro = test.macro({
+    title(providedTitle, dexCid, options) {
+        return providedTitle ?? `parse all classes from dex ${dexCid} against smali${options?.skipUntilClassPath ? ` (skip until ${options.skipUntilClassPath})` : ''}`;
+    },
+    async exec(t, dexCid, options) {
+        const hasBaksmali = await hasBaksmaliPromise;
+        if (!hasBaksmali) {
+            t.pass('skipping test because baksmali is not available');
+            return;
+        }
+        const dexStream = await fetchCid(dexCid);
+        const classes = ((await baksmaliListClasses(dexStream))
+            .map(smaliFilePath => ({ smaliFilePath, sort: Math.random() }))
+            .sort((a, b) => a.sort - b.sort)
+            .map(({ smaliFilePath }) => smaliFilePath));
+        const failures = [];
+        let shouldProcess = options?.skipUntilClassPath === undefined;
+        let processedCount = 0;
+        for (const smaliFilePath of classes) {
+            if (options?.skipUntilClassPath && smaliFilePath === options.skipUntilClassPath) {
+                shouldProcess = true;
             }
-            const dexStream = await fetchCid(dexCid);
-            const smali = await baksmaliClass(dexStream, smaliFilePath);
-            const classDefinitionFromSmali = await runParser(smaliParser, smali, stringParserInputCompanion, {
-                errorJoinMode: 'all',
-            });
-            const dexStream2 = await fetchCid(dexCid);
-            const executableFromDex = await runParser(dalvikExecutableParser, dexStream2, uint8ArrayParserInputCompanion, {
-                errorJoinMode: 'all',
+            if (!shouldProcess) {
+                continue;
+            }
+            processedCount++;
+            const result = await t.try(parseDexAgainstSmaliMacro, dexCid, {
+                smaliFilePath,
+                isolate: true,
             });
-            const classDefinitionFromDex = executableFromDex.classDefinitions.find(classDefinition => classDefinition.class === classDefinitionFromSmali.class);
-            // console.log(smali);
-            // console.dir({
-            // 	classDefinitionFromDex,
-            // 	classDefinitionFromSmali,
-            // }, {
-            // 	depth: null,
-            // });
-            objectWalk(classDefinitionFromDex, (_path, value) => {
-                if (value
-                    && typeof value === 'object'
-                    && 'debugInfo' in value) {
-                    value.debugInfo = undefined;
+            if (result.passed) {
+                result.commit();
+                console.log(`ok ${processedCount}/${classes.length}`, smaliFilePath);
+                continue;
+            }
+            function consoleLogFailure(failure) {
+                const [error] = failure.errors;
+                console.log(error.formattedDetails.at(0).formatted ?? error);
+            }
+            console.log(smaliFilePath);
+            consoleLogFailure(result);
+            failures.push(result);
+            if (failures.length >= (options?.maxFailures ?? 1)) {
+                for (const failure of failures) {
+                    consoleLogFailure(failure);
                 }
-            });
-            t.deepEqual(classDefinitionFromDex, classDefinitionFromSmali);
-        });
+                for (const failure of failures) {
+                    failure.commit();
+                }
+            }
+        }
+        for (const failure of failures) {
+            failure.commit();
+        }
+        t.pass('completed all classes');
+    },
+});
+const testCasesByCid = {
+    bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda: [
+        { smaliFilePath: 'androidx/activity/ComponentActivity$1', isolate: true },
+        { smaliFilePath: 'androidx/activity/R$id', isolate: true },
+        { smaliFilePath: 'androidx/activity/ComponentActivity$NonConfigurationInstances', isolate: true },
+        { smaliFilePath: 'androidx/appcompat/R$styleable', isolate: true },
+        { smaliFilePath: 'androidx/core/content/FileProvider', isolate: true },
+        { smaliFilePath: 'androidx/core/view/KeyEventDispatcher', isolate: true },
+        { smaliFilePath: 'com/google/android/exoplayer2/audio/Sonic', isolate: true },
+        { smaliFilePath: 'com/google/android/exoplayer2/ext/opus/OpusDecoder', isolate: true },
+        { smaliFilePath: 'com/google/android/exoplayer2/extractor/ts/H262Reader', isolate: true },
+        { smaliFilePath: 'com/google/android/gms/internal/common/zzg', isolate: true },
+        { smaliFilePath: 'com/google/android/gms/internal/mlkit_vision_label/zzcm', isolate: true },
+        { smaliFilePath: 'com/google/android/play/core/integrity/model/StandardIntegrityErrorCode', isolate: true },
+        { smaliFilePath: 'com/google/common/math/IntMath', isolate: true },
+        { smaliFilePath: 'com/google/gson/internal/bind/CollectionTypeAdapterFactory', isolate: true },
+    ],
+    bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4: [
+        'pl/czak/minimal/MainActivity',
+        'pl/czak/minimal/R',
+    ],
+    bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy: [
+        { smaliFilePath: 'com/journeyapps/barcodescanner/CaptureActivity', isolate: true },
+        { smaliFilePath: '_COROUTINE/ArtificialStackFrames', isolate: true },
+        { smaliFilePath: 'androidx/appcompat/widget/AppCompatTextHelper', isolate: true },
+        { smaliFilePath: '_COROUTINE/CoroutineDebuggingKt', isolate: true },
+        { smaliFilePath: 'androidx/compose/ui/text/android/style/LineHeightSpan', isolate: true },
+        { smaliFilePath: 'androidx/compose/ui/layout/LayoutIdElement', isolate: true },
+        { smaliFilePath: 'androidx/compose/ui/text/EmojiSupportMatch', isolate: true },
+        { smaliFilePath: 'androidx/compose/ui/focus/FocusTransactionsKt', isolate: true },
+        { smaliFilePath: 'androidx/compose/animation/core/SpringSimulationKt', isolate: true },
+        { smaliFilePath: 'androidx/constraintlayout/core/widgets/ConstraintWidget', isolate: true },
+        { smaliFilePath: 'ch/qos/logback/core/CoreConstants', isolate: true },
+        { smaliFilePath: 'ch/qos/logback/classic/spi/ClassPackagingData', isolate: true },
+        { smaliFilePath: 'kotlin/coroutines/jvm/internal/DebugMetadata', isolate: true },
+    ],
+    bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq: [
+        { smaliFilePath: 'androidx/viewpager2/adapter/FragmentStateAdapter$5', isolate: true },
+        { smaliFilePath: 'androidx/lifecycle/b0', isolate: true },
+        { smaliFilePath: 'androidx/activity/b', isolate: true },
+        { smaliFilePath: 'androidx/activity/result/a$a', isolate: true },
+        { smaliFilePath: 'androidx/annotation/Keep', isolate: true },
+        { smaliFilePath: 'androidx/activity/result/e', isolate: true },
+        { smaliFilePath: 'androidx/appcompat/widget/ActionBarContextView$a', isolate: true },
+        { smaliFilePath: 'androidx/appcompat/widget/b0', isolate: true },
+        { smaliFilePath: 'androidx/appcompat/widget/b1', isolate: true },
+        { smaliFilePath: 'androidx/appcompat/widget/e', isolate: true },
+        { smaliFilePath: 'androidx/appcompat/widget/m0', isolate: true },
+        { smaliFilePath: 'androidx/appcompat/widget/r1', isolate: true },
+        { smaliFilePath: 'androidx/recyclerview/widget/RecyclerView$a0', isolate: true },
+        { smaliFilePath: 'androidx/constraintlayout/widget/ConstraintLayout$a', isolate: true },
+        { smaliFilePath: 'l4/a', isolate: true },
+        { smaliFilePath: 'n4/o', isolate: true },
+        { smaliFilePath: 'o6/f', isolate: true },
+        { smaliFilePath: 'a', isolate: true },
+        { smaliFilePath: 'a/b', isolate: true },
+        { smaliFilePath: 'f/b', isolate: true },
+        { smaliFilePath: 'h1/j', isolate: true },
+        { smaliFilePath: 'android/app/AppComponentFactory', isolate: true },
+        { smaliFilePath: 'android/app/job/JobInfo$TriggerContentUri', isolate: true },
+        { smaliFilePath: 'android/graphics/BlendModeColorFilter', isolate: true },
+        { smaliFilePath: 'android/graphics/fonts/Font$Builder', isolate: true },
+        { smaliFilePath: 'android/os/LocaleList', isolate: true },
+        { smaliFilePath: 'a0/i', isolate: true },
+        { smaliFilePath: 'a0/l', isolate: true },
+        { smaliFilePath: 'a0/n', isolate: true },
+        { smaliFilePath: 'a0/p', isolate: true },
+        { smaliFilePath: 'a0/v', isolate: true },
+        { smaliFilePath: 'a0/v$a', isolate: true },
+        { smaliFilePath: 'a3/a', isolate: true },
+        { smaliFilePath: 'a3/b', isolate: true },
+        { smaliFilePath: 'a3/d', isolate: true },
+        { smaliFilePath: 'a4/b', isolate: true },
+        { smaliFilePath: 'b4/v', isolate: true },
+        { smaliFilePath: 'd6/a', isolate: true },
+        { smaliFilePath: 'q2/d$a', isolate: true },
+        { smaliFilePath: 'y4/t1', isolate: true },
+        { smaliFilePath: 'com/google/android/material/textfield/b', isolate: true },
+        { smaliFilePath: 'm/g', isolate: true },
+    ],
+};
+for (const [dexCid, smaliFilePaths] of Object.entries(testCasesByCid)) {
+    for (const smaliFilePath of smaliFilePaths) {
+        test.serial(parseDexAgainstSmaliMacro, dexCid, smaliFilePath);
     }
 }
+for (const dexCid of Object.keys(testCasesByCid)) {
+    test.serial.skip(parseAllClassesInDexAgainstSmaliMacro, dexCid);
+}
 const smali = `
-.class public Lcom/journeyapps/barcodescanner/CaptureActivity;
-.super Landroid/app/Activity;
-.source "CaptureActivity.java"
-
-
-# instance fields
-.field private barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
-
-.field private capture:Lcom/journeyapps/barcodescanner/CaptureManager;
-
+.class public final La0/l;
+.super Ljava/lang/Object;
+.source "SourceFile"
 
 # direct methods
-.method public constructor <init>()V
-    .registers 1
-
-    .line 13
-    invoke-direct {p0}, Landroid/app/Activity;-><init>()V
+.method public static final a(Lh1/p;ZJ)F
+    .registers 6
 
-    return-void
-.end method
-
-
-# virtual methods
-.method protected initializeContent()Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
-    .registers 2
-
-    sget v0, Lcom/google/zxing/client/android/R$layout;->zxing_capture:I
-
-    .line 34
-    invoke-virtual {p0, v0}, Landroid/app/Activity;->setContentView(I)V
-
-    sget v0, Lcom/google/zxing/client/android/R$id;->zxing_barcode_scanner:I
-
-    .line 35
-    invoke-virtual {p0, v0}, Landroid/app/Activity;->findViewById(I)Landroid/view/View;
-
-    move-result-object v0
-
-    check-cast v0, Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
-
-    return-object v0
-.end method
-
-.method protected onCreate(Landroid/os/Bundle;)V
-    .registers 4
-
-    .line 19
-    invoke-super {p0, p1}, Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V
-
-    .line 21
-    invoke-virtual {p0}, Lcom/journeyapps/barcodescanner/CaptureActivity;->initializeContent()Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
-
-    move-result-object v0
-
-    iput-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
-
-    .line 23
-    new-instance v0, Lcom/journeyapps/barcodescanner/CaptureManager;
-
-    iget-object v1, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
-
-    invoke-direct {v0, p0, v1}, Lcom/journeyapps/barcodescanner/CaptureManager;-><init>(Landroid/app/Activity;Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;)V
-
-    iput-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
-
-    .line 24
-    invoke-virtual {p0}, Landroid/app/Activity;->getIntent()Landroid/content/Intent;
-
-    move-result-object v1
-
-    invoke-virtual {v0, v1, p1}, Lcom/journeyapps/barcodescanner/CaptureManager;->initializeFromIntent(Landroid/content/Intent;Landroid/os/Bundle;)V
-
-    iget-object p1, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
-
-    .line 25
-    invoke-virtual {p1}, Lcom/journeyapps/barcodescanner/CaptureManager;->decode()V
-
-    return-void
-.end method
-
-.method protected onDestroy()V
-    .registers 2
-
-    .line 52
-    invoke-super {p0}, Landroid/app/Activity;->onDestroy()V
-
-    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
-
-    .line 53
-    invoke-virtual {v0}, Lcom/journeyapps/barcodescanner/CaptureManager;->onDestroy()V
-
-    return-void
-.end method
-
-.method public onKeyDown(ILandroid/view/KeyEvent;)Z
-    .registers 4
-
-    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
-
-    .line 69
-    invoke-virtual {v0, p1, p2}, Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;->onKeyDown(ILandroid/view/KeyEvent;)Z
-
-    move-result v0
-
-    if-nez v0, :cond_11
-
-    invoke-super {p0, p1, p2}, Landroid/app/Activity;->onKeyDown(ILandroid/view/KeyEvent;)Z
-
-    move-result p1
-
-    if-eqz p1, :cond_f
-
-    goto :goto_11
-
-    :cond_f
-    const/4 p1, 0x0
-
-    goto :goto_12
-
-    :cond_11
-    :goto_11
-    const/4 p1, 0x1
-
-    :goto_12
-    return p1
-.end method
-
-.method protected onPause()V
-    .registers 2
-
-    .line 46
-    invoke-super {p0}, Landroid/app/Activity;->onPause()V
-
-    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
-
-    .line 47
-    invoke-virtual {v0}, Lcom/journeyapps/barcodescanner/CaptureManager;->onPause()V
-
-    return-void
-.end method
-
-.method public onRequestPermissionsResult(I[Ljava/lang/String;[I)V
-    .registers 5
-
-    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
-
-    .line 64
-    invoke-virtual {v0, p1, p2, p3}, Lcom/journeyapps/barcodescanner/CaptureManager;->onRequestPermissionsResult(I[Ljava/lang/String;[I)V
-
-    return-void
-.end method
-
-.method protected onResume()V
-    .registers 2
-
-    .line 40
-    invoke-super {p0}, Landroid/app/Activity;->onResume()V
-
-    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
-
-    .line 41
-    invoke-virtual {v0}, Lcom/journeyapps/barcodescanner/CaptureManager;->onResume()V
-
-    return-void
-.end method
-
-.method protected onSaveInstanceState(Landroid/os/Bundle;)V
-    .registers 3
-
-    .line 58
-    invoke-super {p0, p1}, Landroid/app/Activity;->onSaveInstanceState(Landroid/os/Bundle;)V
-
-    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
-
-    .line 59
-    invoke-virtual {v0, p1}, Lcom/journeyapps/barcodescanner/CaptureManager;->onSaveInstanceState(Landroid/os/Bundle;)V
-
-    return-void
+    return v0
 .end method
 `;
-test.serial.skip('parse(dex(smali)) againts parse(smali)', async (t) => {
+test.serial('parse(dex(smali)) againts parse(smali)', async (t) => {
     const hasSmali = await hasSmaliPromise;
     if (!hasSmali) {
         t.pass('skipping test because smali is not available');
         return;
     }
-    const dexBuffer = await smaliClass(async function* () {
-        yield smali;
-    }());
+    const dexBuffer = await smaliClass(smali);
     const classDefinitionFromSmali = await runParser(smaliParser, smali, stringParserInputCompanion, {
         errorJoinMode: 'all',
     });
@@ -280,19 +262,14 @@ test.serial.skip('parse(dex(smali)) againts parse(smali)', async (t) => {
         errorJoinMode: 'all',
     });
     const classDefinitionFromDex = executableFromDex.classDefinitions.find(classDefinition => classDefinition.class === classDefinitionFromSmali.class);
-    // console.log(smali);
-    console.dir({
-        classDefinitionFromDex,
-        classDefinitionFromSmali,
-    }, {
-        depth: null,
-    });
-    objectWalk(classDefinitionFromDex, (_path, value) => {
-        if (value
-            && typeof value === 'object'
-            && 'debugInfo' in value) {
-            value.debugInfo = undefined;
-        }
-    });
+    // Normalize both DEX and Smali by removing debug info
+    normalizeClassDefinition(classDefinitionFromDex);
+    normalizeClassDefinition(classDefinitionFromSmali);
+    // Console.dir({
+    // 	classDefinitionFromDex,
+    // 	classDefinitionFromSmali,
+    // }, {
+    // 	depth: null,
+    // });
     t.deepEqual(classDefinitionFromDex, classDefinitionFromSmali);
 });

package/build/dalvikExecutableUnparser/annotationUnparsers.d.ts

@@ -0,0 +1,14 @@
+import { type Unparser } from '../unparser.js';
+import { type DalvikExecutableAnnotation, type DalvikExecutableClassAnnotations, type DalvikExecutableEncodedValue, type DalvikExecutableField, type DalvikExecutableMethod } from '../dalvikExecutable.js';
+import { WriteLater } from '../unparserContext.js';
+export declare function createAnnotationUnparsers(getStringIndex: (str: string | undefined) => number, getTypeIndex: (typeDescriptor: string | undefined) => number, getFieldIndex: (field: DalvikExecutableField) => number, getMethodIndex: (method: DalvikExecutableMethod) => number, encodedValueUnparser: Unparser<DalvikExecutableEncodedValue, Uint8Array>): {
+    annotationItemUnparser: Unparser<DalvikExecutableAnnotation, Uint8Array<ArrayBufferLike>>;
+    annotationSetItemUnparser: (annotationItemOffsetWriteLaters: Array<WriteLater<Uint8Array, number>>) => Unparser<DalvikExecutableAnnotation[], Uint8Array>;
+    annotationSetRefListUnparser: (annotationSetOffsetWriteLaters: Array<WriteLater<Uint8Array, number> | null>) => Unparser<DalvikExecutableAnnotation[][], Uint8Array>;
+    annotationsDirectoryItemUnparser: (annotationOffsetWriteLaters: {
+        classAnnotationsOffsetWriteLater?: WriteLater<Uint8Array, number>;
+        fieldAnnotationsOffsetWriteLaters?: Array<WriteLater<Uint8Array, number> | null>;
+        methodAnnotationsOffsetWriteLaters?: Array<WriteLater<Uint8Array, number>>;
+        parameterAnnotationsOffsetWriteLaters?: Array<WriteLater<Uint8Array, number>>;
+    }) => Unparser<DalvikExecutableClassAnnotations, Uint8Array>;
+};