@futpib/parser 1.0.1 → 1.0.3

package/build/dalvikExecutableParser.test.js

@@ -0,0 +1,72 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { dalvikExecutableParser, dalvikExecutableWithRawInstructionsParser } from './dalvikExecutableParser.js';
+import { fetchCid } from './fetchCid.js';
+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',
+        });
+        if (shouldSnapshot) {
+            t.snapshot(actual);
+        }
+        else {
+            // 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
+        || typeof object !== 'object') {
+        return;
+    }
+    if (Array.isArray(object)) {
+        for (const [index, value] of object.entries()) {
+            objectWalk(value, f, [...initialPath, index]);
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(object)) {
+            objectWalk(value, f, [...initialPath, key]);
+        }
+    }
+}
+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',
+        });
+        debugger;
+        objectWalk(actual, path => {
+            const key = path.at(-1);
+            if (typeof key !== 'string') {
+                return;
+            }
+            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 });
+            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

@@ -0,0 +1,275 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { dalvikExecutableParser } from './dalvikExecutableParser.js';
+import { fetchCid } from './fetchCid.js';
+import { hasExecutable } from './hasExecutable.js';
+import { backsmaliSmaliIsolateClass, baksmaliClass, baksmaliListClasses } from './backsmali.js';
+import { smaliParser } from './smaliParser.js';
+import { smaliClass } from './smali.js';
+const hasBaksmaliPromise = hasExecutable('baksmali');
+const hasSmaliPromise = hasExecutable('smali');
+function objectWalk(object, f, initialPath = []) {
+    f(initialPath, object);
+    if (!object
+        || typeof object !== 'object') {
+        return;
+    }
+    if (Array.isArray(object)) {
+        for (const [index, value] of object.entries()) {
+            objectWalk(value, f, [...initialPath, index]);
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(object)) {
+            objectWalk(value, f, [...initialPath, key]);
+        }
+    }
+}
+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;
+            }
+            if (!shouldProcess) {
+                continue;
+            }
+            processedCount++;
+            const result = await t.try(parseDexAgainstSmaliMacro, dexCid, {
+                smaliFilePath,
+                isolate: true,
+            });
+            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);
+                }
+                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 final La0/l;
+.super Ljava/lang/Object;
+.source "SourceFile"
+
+# direct methods
+.method public static final a(Lh1/p;ZJ)F
+    .registers 6
+
+    return v0
+.end method
+`;
+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(smali);
+    const classDefinitionFromSmali = await runParser(smaliParser, smali, stringParserInputCompanion, {
+        errorJoinMode: 'all',
+    });
+    const executableFromDex = await runParser(dalvikExecutableParser, dexBuffer, 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({
+    // 	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>;
+};

package/build/dalvikExecutableUnparser/annotationUnparsers.js

@@ -0,0 +1,97 @@
+async function* yieldAndCapture(gen) {
+    let value;
+    for await (value of gen) {
+        yield value;
+    }
+    return value;
+}
+import { ubyteUnparser, uintUnparser } from '../dalvikBytecodeUnparser/formatUnparsers.js';
+import { alignmentUnparser, uleb128Unparser } from './utils.js';
+export function createAnnotationUnparsers(getStringIndex, getTypeIndex, getFieldIndex, getMethodIndex, encodedValueUnparser) {
+    const annotationItemUnparser = async function* (input, unparserContext) {
+        const visibilityByte = input.visibility === 'build' ? 0x00 : input.visibility === 'runtime' ? 0x01 : 0x02;
+        yield* ubyteUnparser(visibilityByte, unparserContext);
+        const typeIndex = getTypeIndex(input.type);
+        yield* uleb128Unparser(typeIndex, unparserContext);
+        yield* uleb128Unparser(input.elements.length, unparserContext);
+        for (const element of input.elements) {
+            const nameIndex = getStringIndex(element.name);
+            yield* uleb128Unparser(nameIndex, unparserContext);
+            yield* encodedValueUnparser(element.value, unparserContext);
+        }
+    };
+    const annotationSetItemUnparser = (annotationItemOffsetWriteLaters) => {
+        return async function* (input, unparserContext) {
+            yield* alignmentUnparser(4)(undefined, unparserContext);
+            yield* uintUnparser(input.length, unparserContext);
+            for (const annotation of input) {
+                const annotationOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                annotationItemOffsetWriteLaters.push(annotationOffsetWriteLater);
+            }
+        };
+    };
+    const annotationSetRefListUnparser = (annotationSetOffsetWriteLaters) => {
+        return async function* (input, unparserContext) {
+            yield* alignmentUnparser(4)(undefined, unparserContext);
+            yield* uintUnparser(input.length, unparserContext);
+            for (const annotationSet of input) {
+                if (annotationSet.length > 0) {
+                    const annotationSetOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                    annotationSetOffsetWriteLaters.push(annotationSetOffsetWriteLater);
+                }
+                else {
+                    annotationSetOffsetWriteLaters.push(null);
+                    yield* uintUnparser(0, unparserContext);
+                }
+            }
+        };
+    };
+    const annotationsDirectoryItemUnparser = (annotationOffsetWriteLaters) => {
+        return async function* (input, unparserContext) {
+            yield* alignmentUnparser(4)(undefined, unparserContext);
+            if (input.classAnnotations.length > 0) {
+                const classAnnotationsOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                annotationOffsetWriteLaters.classAnnotationsOffsetWriteLater = classAnnotationsOffsetWriteLater;
+            }
+            else {
+                yield* uintUnparser(0, unparserContext);
+            }
+            yield* uintUnparser(input.fieldAnnotations.length, unparserContext);
+            yield* uintUnparser(input.methodAnnotations.length, unparserContext);
+            yield* uintUnparser(input.parameterAnnotations.length, unparserContext);
+            annotationOffsetWriteLaters.fieldAnnotationsOffsetWriteLaters = [];
+            for (const fieldAnnotation of input.fieldAnnotations) {
+                const fieldIndex = getFieldIndex(fieldAnnotation.field);
+                yield* uintUnparser(fieldIndex, unparserContext);
+                if (fieldAnnotation.annotations && fieldAnnotation.annotations.length > 0) {
+                    const annotationsOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                    annotationOffsetWriteLaters.fieldAnnotationsOffsetWriteLaters.push(annotationsOffsetWriteLater);
+                }
+                else {
+                    annotationOffsetWriteLaters.fieldAnnotationsOffsetWriteLaters.push(null);
+                    yield* uintUnparser(0, unparserContext);
+                }
+            }
+            annotationOffsetWriteLaters.methodAnnotationsOffsetWriteLaters = [];
+            for (const methodAnnotation of input.methodAnnotations) {
+                const methodIndex = getMethodIndex(methodAnnotation.method);
+                yield* uintUnparser(methodIndex, unparserContext);
+                const annotationsOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                annotationOffsetWriteLaters.methodAnnotationsOffsetWriteLaters.push(annotationsOffsetWriteLater);
+            }
+            annotationOffsetWriteLaters.parameterAnnotationsOffsetWriteLaters = [];
+            for (const paramAnnotation of input.parameterAnnotations) {
+                const methodIndex = getMethodIndex(paramAnnotation.method);
+                yield* uintUnparser(methodIndex, unparserContext);
+                const annotationsOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                annotationOffsetWriteLaters.parameterAnnotationsOffsetWriteLaters.push(annotationsOffsetWriteLater);
+            }
+        };
+    };
+    return {
+        annotationItemUnparser,
+        annotationSetItemUnparser,
+        annotationSetRefListUnparser,
+        annotationsDirectoryItemUnparser,
+    };
+}

package/build/dalvikExecutableUnparser/poolBuilders.d.ts

@@ -0,0 +1,49 @@
+import { type DalvikExecutableField, type DalvikExecutableMethod, type DalvikExecutablePrototype } from '../dalvikExecutable.js';
+export declare class StringPoolBuilder {
+    private strings;
+    private stringToIndex;
+    add(str: string): number;
+    getIndex(str: string): number | undefined;
+    getStrings(): string[];
+    size(): number;
+}
+export declare class TypePoolBuilder {
+    private types;
+    private typeToIndex;
+    add(typeDescriptor: string): number;
+    getIndex(typeDescriptor: string): number | undefined;
+    getTypes(): string[];
+    size(): number;
+}
+export declare class ProtoPoolBuilder {
+    private protos;
+    private protoToIndex;
+    add(proto: DalvikExecutablePrototype): number;
+    getIndex(proto: DalvikExecutablePrototype): number | undefined;
+    getProtos(): DalvikExecutablePrototype[];
+    size(): number;
+}
+export declare class FieldPoolBuilder {
+    private fields;
+    private fieldToIndex;
+    add(field: DalvikExecutableField): number;
+    getIndex(field: DalvikExecutableField): number | undefined;
+    getFields(): DalvikExecutableField[];
+    size(): number;
+}
+export declare class MethodPoolBuilder {
+    private methods;
+    private methodToIndex;
+    add(method: DalvikExecutableMethod): number;
+    getIndex(method: DalvikExecutableMethod): number | undefined;
+    getMethods(): DalvikExecutableMethod[];
+    size(): number;
+}
+export interface PoolBuilders {
+    stringPool: StringPoolBuilder;
+    typePool: TypePoolBuilder;
+    protoPool: ProtoPoolBuilder;
+    fieldPool: FieldPoolBuilder;
+    methodPool: MethodPoolBuilder;
+}
+export declare function createPoolBuilders(): PoolBuilders;

package/build/dalvikExecutableUnparser/poolBuilders.js

@@ -0,0 +1,140 @@
+export class StringPoolBuilder {
+    strings = [];
+    stringToIndex = new Map();
+    add(str) {
+        const existing = this.stringToIndex.get(str);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.strings.length;
+        this.strings.push(str);
+        this.stringToIndex.set(str, index);
+        return index;
+    }
+    getIndex(str) {
+        return this.stringToIndex.get(str);
+    }
+    getStrings() {
+        return this.strings;
+    }
+    size() {
+        return this.strings.length;
+    }
+}
+export class TypePoolBuilder {
+    types = [];
+    typeToIndex = new Map();
+    add(typeDescriptor) {
+        const existing = this.typeToIndex.get(typeDescriptor);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.types.length;
+        this.types.push(typeDescriptor);
+        this.typeToIndex.set(typeDescriptor, index);
+        return index;
+    }
+    getIndex(typeDescriptor) {
+        return this.typeToIndex.get(typeDescriptor);
+    }
+    getTypes() {
+        return this.types;
+    }
+    size() {
+        return this.types.length;
+    }
+}
+function prototypeKey(proto) {
+    return `${proto.shorty}:${proto.returnType}:(${proto.parameters.join(',')})`;
+}
+export class ProtoPoolBuilder {
+    protos = [];
+    protoToIndex = new Map();
+    add(proto) {
+        const key = prototypeKey(proto);
+        const existing = this.protoToIndex.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.protos.length;
+        this.protos.push(proto);
+        this.protoToIndex.set(key, index);
+        return index;
+    }
+    getIndex(proto) {
+        const key = prototypeKey(proto);
+        return this.protoToIndex.get(key);
+    }
+    getProtos() {
+        return this.protos;
+    }
+    size() {
+        return this.protos.length;
+    }
+}
+function fieldKey(field) {
+    return `${field.class}:${field.type}:${field.name}`;
+}
+export class FieldPoolBuilder {
+    fields = [];
+    fieldToIndex = new Map();
+    add(field) {
+        const key = fieldKey(field);
+        const existing = this.fieldToIndex.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.fields.length;
+        this.fields.push(field);
+        this.fieldToIndex.set(key, index);
+        return index;
+    }
+    getIndex(field) {
+        const key = fieldKey(field);
+        return this.fieldToIndex.get(key);
+    }
+    getFields() {
+        return this.fields;
+    }
+    size() {
+        return this.fields.length;
+    }
+}
+function methodKey(method) {
+    const protoKey = prototypeKey(method.prototype);
+    return `${method.class}:${protoKey}:${method.name}`;
+}
+export class MethodPoolBuilder {
+    methods = [];
+    methodToIndex = new Map();
+    add(method) {
+        const key = methodKey(method);
+        const existing = this.methodToIndex.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.methods.length;
+        this.methods.push(method);
+        this.methodToIndex.set(key, index);
+        return index;
+    }
+    getIndex(method) {
+        const key = methodKey(method);
+        return this.methodToIndex.get(key);
+    }
+    getMethods() {
+        return this.methods;
+    }
+    size() {
+        return this.methods.length;
+    }
+}
+export function createPoolBuilders() {
+    return {
+        stringPool: new StringPoolBuilder(),
+        typePool: new TypePoolBuilder(),
+        protoPool: new ProtoPoolBuilder(),
+        fieldPool: new FieldPoolBuilder(),
+        methodPool: new MethodPoolBuilder(),
+    };
+}

package/build/dalvikExecutableUnparser/poolScanners.d.ts

@@ -0,0 +1,4 @@
+import { type DalvikExecutable } from '../dalvikExecutable.js';
+import { type DalvikBytecode } from '../dalvikBytecodeParser.js';
+import { type PoolBuilders } from './poolBuilders.js';
+export declare function scanForPoolReferences(dalvikExecutable: DalvikExecutable<DalvikBytecode>, poolBuilders: PoolBuilders): void;