@futpib/parser 1.0.2 → 1.0.4

package/build/dalvikExecutableParser.js

@@ -1,5 +1,5 @@
 import invariant from 'invariant';
-import { MUtf8Decoder } from "mutf-8";
+import { MUtf8Decoder } from 'mutf-8';
 import { createExactElementParser } from './exactElementParser.js';
 import { createExactSequenceParser } from './exactSequenceParser.js';
 import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
@@ -11,13 +11,13 @@ import { createTupleParser } from './tupleParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
 import { createSkipToParser } from './skipToParser.js';
 import { createLookaheadParser } from './lookaheadParser.js';
-import { getIsoTypedNumberArray, isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoPrototypeIds, isoIndexIntoStringIds, isoIndexIntoTypeIds, isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler, isoOffsetToAnnotationItem, isoOffsetToAnnotationsDirectoryItem, isoOffsetToAnnotationSetItem, isoOffsetToAnnotationSetRefListItem, isoOffsetToClassDataItem, isoOffsetToCodeItem, isoOffsetToDebugInfoItem, isoOffsetToEncodedArrayItem, isoOffsetToStringDataItem, isoOffsetToTypeList } from './dalvikExecutableParser/typedNumbers.js';
+import { getIsoTypedNumberArray, isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoPrototypeIds, isoIndexIntoStringIds, isoIndexIntoTypeIds, isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler, isoOffsetToAnnotationItem, isoOffsetToAnnotationsDirectoryItem, isoOffsetToAnnotationSetItem, isoOffsetToAnnotationSetRefListItem, isoOffsetToClassDataItem, isoOffsetToCodeItem, isoOffsetToDebugInfoItem, isoOffsetToEncodedArrayItem, isoOffsetToStringDataItem, isoOffsetToTypeList, } from './dalvikExecutableParser/typedNumbers.js';
 import { sleb128NumberParser, uleb128NumberParser } from './leb128Parser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
 import { createElementTerminatedSequenceParser } from './elementTerminatedSequenceParser.js';
 import { createElementTerminatedArrayParserUnsafe } from './elementTerminatedArrayParser.js';
-import { createDalvikBytecodeParser, resolveDalvikBytecodeOperation } from './dalvikBytecodeParser.js';
-import { ubyteParser, uintParser, uleb128p1NumberParser, ushortParser } from './dalvikExecutableParser/typeParsers.js';
+import { createDalvikBytecodeParser, resolveDalvikBytecodeOperation, } from './dalvikBytecodeParser.js';
+import { byteParser, ubyteParser, uintParser, uleb128p1NumberParser, ushortParser, } from './dalvikExecutableParser/typeParsers.js';
 // https://source.android.com/docs/core/runtime/dex-format
 const createByteAlignParser = (byteAlignment) => async (parserContext) => {
     const toSkip = (byteAlignment - (parserContext.position % byteAlignment)) % byteAlignment;
@@ -71,7 +71,7 @@ const dalvikExecutableHeaderItemParser = promiseCompose(createTupleParser([
     classDefinitions,
     data,
 }));
-const dalvikExecutableStringIdItemParser = promiseCompose(cloneParser(uintParser), (offset) => isoOffsetToStringDataItem.wrap(offset));
+const dalvikExecutableStringIdItemParser = promiseCompose(cloneParser(uintParser), offset => isoOffsetToStringDataItem.wrap(offset));
 const isoDalvikExecutableStringIdItems = getIsoTypedNumberArray();
 const createSkipToThenStringIdItemsParser = ({ size, offset }) => (size === 0
     ? (() => isoDalvikExecutableStringIdItems.wrap([]))
@@ -79,7 +79,7 @@ const createSkipToThenStringIdItemsParser = ({ size, offset }) => (size === 0
         createSkipToParser(offset),
         createQuantifierParser(dalvikExecutableStringIdItemParser, size),
     ]), ([_, stringIds]) => isoDalvikExecutableStringIdItems.wrap(stringIds)));
-const dalvikExecutableTypeIdItemParser = promiseCompose(cloneParser(uintParser), (index) => isoIndexIntoStringIds.wrap(index));
+const dalvikExecutableTypeIdItemParser = promiseCompose(cloneParser(uintParser), index => isoIndexIntoStringIds.wrap(index));
 const isoDalvikExecutableTypeIdItems = getIsoTypedNumberArray();
 const createSkipToThenTypeIdItemsParser = ({ size, offset }) => (size === 0
     ? (() => isoDalvikExecutableTypeIdItems.wrap([]))
@@ -156,49 +156,45 @@ const createSkipToThenMethodIdItemsParser = ({ size, offset }) => (size === 0
         createSkipToParser(offset),
         createQuantifierParser(dalvikExecutableMethodIdItemParser, size),
     ]), ([_, methodIds]) => isoDalvikExecutableMethodIdItems.wrap(methodIds)));
-const uintAccessFlagsParser = promiseCompose(uintParser, (flags) => ({
-    public: Boolean(flags & 0b00000001),
-    private: Boolean(flags & 0b00000010),
-    protected: Boolean(flags & 0b00000100),
-    static: Boolean(flags & 0b00001000),
-    final: Boolean(flags & 0b00010000),
-    synchronized: Boolean(flags & 0b00100000),
-    volatile: Boolean(flags & 0b01000000),
-    bridge: Boolean(flags & 0b01000000),
-    transient: Boolean(flags & 0b10000000),
-    varargs: Boolean(flags & 0b10000000),
-    native: false,
-    interface: false,
-    abstract: false,
-    strict: false,
-    synthetic: false,
-    annotation: false,
-    enum: false,
-    constructor: false,
-    declaredSynchronized: false,
-}));
-const uleb128AccessFlagsParser = promiseCompose(uleb128NumberParser, flags => ({
-    public: Boolean(flags & 0b00000001),
-    private: Boolean(flags & 0b00000010),
-    protected: Boolean(flags & 0b00000100),
-    static: Boolean(flags & 0b00001000),
-    final: Boolean(flags & 0b00010000),
-    synchronized: Boolean(flags & 0b00100000),
-    volatile: Boolean(flags & 0b01000000),
-    bridge: Boolean(flags & 0b01000000),
-    transient: Boolean(flags & 0b10000000),
-    varargs: Boolean(flags & 0b10000000),
-    native: Boolean(flags & 0b00000001_00000000),
-    interface: Boolean(flags & 0b00000010_00000000),
-    abstract: Boolean(flags & 0b00000100_00000000),
-    strict: Boolean(flags & 0b00001000_00000000),
-    synthetic: Boolean(flags & 0b00010000_00000000),
-    annotation: Boolean(flags & 0b00100000_00000000),
-    enum: Boolean(flags & 0b01000000_00000000),
-    constructor: Boolean(flags & 0b00000001_00000000_00000000),
-    declaredSynchronized: Boolean(flags & 0b00000010_00000000_00000000),
-}));
-const DEX_CLASS_DEFINITION_ITEM_SOURCE_FILE_NO_INDEX = 0xffffffff;
+const parseAccessFlagsCommon = (flags) => ({
+    public: Boolean(flags & 0b0000_0001),
+    private: Boolean(flags & 0b0000_0010),
+    protected: Boolean(flags & 0b0000_0100),
+    static: Boolean(flags & 0b0000_1000),
+    final: Boolean(flags & 0b0001_0000),
+    synchronized: Boolean(flags & 0b0010_0000),
+    volatile: false,
+    bridge: false,
+    transient: Boolean(flags & 0b1000_0000),
+    varargs: Boolean(flags & 0b1000_0000),
+    native: Boolean(flags & 0b0000_0001_0000_0000),
+    interface: Boolean(flags & 0b0000_0010_0000_0000),
+    abstract: Boolean(flags & 0b0000_0100_0000_0000),
+    strict: Boolean(flags & 0b0000_1000_0000_0000),
+    synthetic: Boolean(flags & 0b0001_0000_0000_0000),
+    annotation: Boolean(flags & 0b0010_0000_0000_0000),
+    enum: Boolean(flags & 0b0100_0000_0000_0000),
+    constructor: Boolean(flags & 0b0000_0001_0000_0000_0000_0000),
+    declaredSynchronized: Boolean(flags & 0b0000_0010_0000_0000_0000_0000),
+});
+const parseAccessFlags = (flags) => parseAccessFlagsCommon(flags);
+const parseFieldAccessFlags = (flags) => ({
+    ...parseAccessFlagsCommon(flags),
+    volatile: Boolean(flags & 0b0100_0000),
+    varargs: false, // Varargs is only for methods, not fields
+    bridge: false,
+});
+const parseMethodAccessFlags = (flags) => ({
+    ...parseAccessFlagsCommon(flags),
+    volatile: false,
+    transient: false, // Transient is only for fields, not methods
+    bridge: Boolean(flags & 0b0100_0000),
+});
+const uintAccessFlagsParser = promiseCompose(uintParser, parseAccessFlags);
+const uleb128AccessFlagsParser = promiseCompose(uleb128NumberParser, parseAccessFlags);
+const uleb128FieldAccessFlagsParser = promiseCompose(uleb128NumberParser, parseFieldAccessFlags);
+const uleb128MethodAccessFlagsParser = promiseCompose(uleb128NumberParser, parseMethodAccessFlags);
+const DEX_CLASS_DEFINITION_ITEM_SOURCE_FILE_NO_INDEX = 0xFF_FF_FF_FF;
 const createSkipToThenClassDefinitionItemsParser = ({ size, offset }) => (size === 0
     ? (() => [])
     : promiseCompose(createTupleParser([
@@ -251,12 +247,12 @@ const createSkipToThenStringsParser = (sizeOffset) => createSkipToThenItemByOffs
     isoOffset: isoOffsetToStringDataItem,
     parserName: 'skipToThenStringsParser',
 });
-const dalvikExecutableTypeItemParser = promiseCompose(cloneParser(ushortParser), (index) => isoIndexIntoTypeIds.wrap(index));
+const dalvikExecutableTypeItemParser = promiseCompose(cloneParser(ushortParser), index => isoIndexIntoTypeIds.wrap(index));
 const isoDalvikExecutableTypeList = getIsoTypedNumberArray();
 const dalvikExecutableTypeListParser = parserCreatorCompose(() => createTupleParser([
     byteAlign4Parser,
     uintParser,
-]), ([_, size]) => promiseCompose(createQuantifierParser(dalvikExecutableTypeItemParser, size), (typeItems) => isoDalvikExecutableTypeList.wrap(typeItems)))();
+]), ([_, size]) => promiseCompose(createQuantifierParser(dalvikExecutableTypeItemParser, size), typeItems => isoDalvikExecutableTypeList.wrap(typeItems)))();
 const createSkipToThenTypeListByOffsetParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
     sizeOffset,
     itemParser: dalvikExecutableTypeListParser,
@@ -314,9 +310,9 @@ const createSkipToThenAnnotationsDirectoryItemsParser = (sizeOffset) => createSk
 });
 const encodedFieldParser = promiseCompose(createTupleParser([
     uleb128NumberParser,
-    uleb128AccessFlagsParser,
+    uleb128FieldAccessFlagsParser,
 ]), ([fieldIndexDiff, accessFlags]) => ({ fieldIndexDiff, accessFlags }));
-const createEncodedFieldsParser = (fieldsSize) => promiseCompose(createQuantifierParser(encodedFieldParser, fieldsSize), (encodedFields) => {
+const createEncodedFieldsParser = (fieldsSize) => promiseCompose(createQuantifierParser(encodedFieldParser, fieldsSize), encodedFields => {
     let previousFieldIndex = 0;
     return encodedFields.map(({ fieldIndexDiff, accessFlags }) => {
         previousFieldIndex += fieldIndexDiff;
@@ -328,14 +324,14 @@ const createEncodedFieldsParser = (fieldsSize) => promiseCompose(createQuantifie
 });
 const encodedMethodParser = promiseCompose(createTupleParser([
     uleb128NumberParser,
-    uleb128AccessFlagsParser,
+    uleb128MethodAccessFlagsParser,
     uleb128NumberParser,
 ]), ([methodIndexDiff, accessFlags, codeOffset,]) => ({
     methodIndexDiff,
     accessFlags,
     codeOffset: isoOffsetToCodeItem.wrap(codeOffset),
 }));
-const createEncodedMethodsParser = (methodsSize) => promiseCompose(createQuantifierParser(encodedMethodParser, methodsSize), (encodedMethods) => {
+const createEncodedMethodsParser = (methodsSize) => promiseCompose(createQuantifierParser(encodedMethodParser, methodsSize), encodedMethods => {
     let previousMethodIndex = 0;
     return encodedMethods.map(({ methodIndexDiff, accessFlags, codeOffset }) => {
         previousMethodIndex += methodIndexDiff;
@@ -372,326 +368,374 @@ const createSkipToThenClassDataItemsParser = (sizeOffset) => createSkipToThenIte
 const createByteWith5LeastSignificantBitsEqualParser = (leastSignificant5) => {
     const byteWith5LeastSignificantBitsEqualParser = async (parserContext) => {
         const byte = await parserContext.read(0);
-        parserContext.invariant((byte & 0b00011111) === leastSignificant5, 'Expected byte with 5 least significant bits equal to %s, but got %s', leastSignificant5.toString(2).padStart(8, '0'), byte.toString(2).padStart(8, '0'));
+        parserContext.invariant((byte & 0b0001_1111) === leastSignificant5, 'Expected byte with 5 least significant bits equal to %s, but got %s', leastSignificant5.toString(2).padStart(8, '0'), byte.toString(2).padStart(8, '0'));
         return byte;
     };
     setParserName(byteWith5LeastSignificantBitsEqualParser, `createByteWith5LeastSignificantBitsEqualParser(${leastSignificant5.toString(2).padStart(5, '0')})`);
     return byteWith5LeastSignificantBitsEqualParser;
 };
-const createEncodedValueArgParser = (valueType) => promiseCompose(createByteWith5LeastSignificantBitsEqualParser(valueType), (byte) => byte >> 5);
+const createEncodedValueArgParser = (valueType) => promiseCompose(createByteWith5LeastSignificantBitsEqualParser(valueType), byte => byte >> 5);
 const encodedValueByteParser = promiseCompose(createTupleParser([
     createExactElementParser(0),
-    ubyteParser,
-]), ([_, value]) => value);
+    byteParser,
+]), ([_, value]) => ({ type: 'byte', value }));
 setParserName(encodedValueByteParser, 'encodedValueByteParser');
 const encodedValueShortParser = parserCreatorCompose(() => createEncodedValueArgParser(0x02), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readInt8(0);
+            return { type: 'short', value: buffer.readInt8(0) };
         });
     }
     invariant(size === 2, '(encodedValueShortParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readInt16LE(0);
+        return { type: 'short', value: buffer.readInt16LE(0) };
     });
 })();
 setParserName(encodedValueShortParser, 'encodedValueShortParser');
 const encodedValueCharParser = parserCreatorCompose(() => createEncodedValueArgParser(0x03), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size == 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
-            const buffer = Buffer.from([0, ...uint8Array]);
-            return buffer.readUInt16LE(0);
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([...uint8Array, 0]);
+            return { type: 'char', value: buffer.readUInt16LE(0) };
         });
     }
     invariant(size === 2, '(encodedValueCharParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readUInt16LE(0);
+        return { type: 'char', value: buffer.readUInt16LE(0) };
     });
 })();
 setParserName(encodedValueCharParser, 'encodedValueCharParser');
 const encodedValueIntParser = parserCreatorCompose(() => createEncodedValueArgParser(0x04), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readInt8(0);
+            return { type: 'int', value: buffer.readInt8(0) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readInt16LE(0);
+            return { type: 'int', value: buffer.readInt16LE(0) };
         });
     }
     if (size === 3) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
-            const firstByte = uint8Array[0];
-            const firstBit = (firstByte & 0b10000000) >> 7;
-            const extensionByte = firstBit === 1 ? 0xff : 0x00;
-            const buffer = Buffer.from([extensionByte, ...uint8Array]);
-            return buffer.readInt32LE(0);
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const lastByte = uint8Array[uint8Array.length - 1];
+            const signBit = (lastByte & 0b1000_0000) >> 7;
+            const extensionByte = signBit === 1 ? 0xFF : 0x00;
+            const buffer = Buffer.from([...uint8Array, extensionByte]);
+            return { type: 'int', value: buffer.readInt32LE(0) };
         });
     }
     invariant(size === 4, '(encodedValueIntParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readInt32LE(0);
+        return { type: 'int', value: buffer.readInt32LE(0) };
     });
 })();
 setParserName(encodedValueIntParser, 'encodedValueIntParser');
 const encodedValueLongParser = parserCreatorCompose(() => createEncodedValueArgParser(0x06), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return BigInt(buffer.readInt8(0));
+            return { type: 'long', value: BigInt(buffer.readInt8(0)) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return BigInt(buffer.readInt16LE(0));
+            return { type: 'long', value: BigInt(buffer.readInt16LE(0)) };
         });
     }
     if (size === 3) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
-            const firstByte = uint8Array[0];
-            const firstBit = (firstByte & 0b10000000) >> 7;
-            const extensionByte = firstBit === 1 ? 0xff : 0x00;
-            const buffer = Buffer.from([extensionByte, ...uint8Array]);
-            return BigInt(buffer.readInt32LE(0));
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const lastByte = uint8Array[size - 1];
+            const firstBit = (lastByte & 0b1000_0000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xFF : 0x00;
+            const buffer = Buffer.from([...uint8Array, extensionByte]);
+            return { type: 'long', value: BigInt(buffer.readInt32LE(0)) };
         });
     }
     if (size === 4) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return BigInt(buffer.readInt32LE(0));
+            return { type: 'long', value: BigInt(buffer.readInt32LE(0)) };
         });
     }
     if (size === 5) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
-            const firstByte = uint8Array[0];
-            const firstBit = (firstByte & 0b10000000) >> 7;
-            const extensionByte = firstBit === 1 ? 0xff : 0x00;
-            const buffer = Buffer.from([extensionByte, extensionByte, extensionByte, ...uint8Array]);
-            return BigInt(buffer.readBigInt64LE(0));
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const lastByte = uint8Array[size - 1];
+            const firstBit = (lastByte & 0b1000_0000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xFF : 0x00;
+            const buffer = Buffer.from([...uint8Array, extensionByte, extensionByte, extensionByte]);
+            return { type: 'long', value: BigInt(buffer.readBigInt64LE(0)) };
+        });
+    }
+    if (size === 6) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const lastByte = uint8Array[size - 1];
+            const firstBit = (lastByte & 0b1000_0000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xFF : 0x00;
+            const buffer = Buffer.from([...uint8Array, extensionByte, extensionByte]);
+            return { type: 'long', value: BigInt(buffer.readBigInt64LE(0)) };
+        });
+    }
+    if (size === 7) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const lastByte = uint8Array[size - 1];
+            const firstBit = (lastByte & 0b1000_0000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xFF : 0x00;
+            const buffer = Buffer.from([...uint8Array, extensionByte]);
+            return { type: 'long', value: BigInt(buffer.readBigInt64LE(0)) };
         });
     }
     invariant(size === 8, '(encodedValueLongParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readBigInt64LE(0);
+        return { type: 'long', value: buffer.readBigInt64LE(0) };
     });
 })();
 setParserName(encodedValueLongParser, 'encodedValueLongParser');
 const encodedValueFloatParser = parserCreatorCompose(() => createEncodedValueArgParser(0x10), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
-            const buffer = Buffer.from([...uint8Array, 0, 0, 0]);
-            return buffer.readFloatLE(0);
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, ...uint8Array]);
+            return { type: 'float', value: buffer.readFloatLE(0) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
-            const buffer = Buffer.from([...uint8Array, 0, 0]);
-            return buffer.readFloatLE(0);
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, ...uint8Array]);
+            return { type: 'float', value: buffer.readFloatLE(0) };
+        });
+    }
+    if (size === 3) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, ...uint8Array]);
+            return { type: 'float', value: buffer.readFloatLE(0) };
         });
     }
     invariant(size === 4, '(encodedValueFloatParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readFloatLE(0);
+        return { type: 'float', value: buffer.readFloatLE(0) };
     });
 })();
 setParserName(encodedValueFloatParser, 'encodedValueFloatParser');
 const encodedValueDoubleParser = parserCreatorCompose(() => createEncodedValueArgParser(0x11), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
-            const buffer = Buffer.from([...uint8Array, 0, 0, 0, 0, 0, 0, 0]);
-            return buffer.readDoubleLE(0);
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, 0, 0, 0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
-            const buffer = Buffer.from([...uint8Array, 0, 0, 0, 0, 0, 0]);
-            return buffer.readDoubleLE(0);
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, 0, 0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    if (size === 3) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, 0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
         });
     }
     if (size === 4) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
-            const buffer = Buffer.from([...uint8Array, 0, 0, 0, 0]);
-            return buffer.readDoubleLE(0);
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    if (size === 5) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    if (size === 6) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    if (size === 7) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
         });
     }
     invariant(size === 8, '(encodedValueDoubleParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readDoubleLE(0);
+        return { type: 'double', value: buffer.readDoubleLE(0) };
     });
 })();
 setParserName(encodedValueDoubleParser, 'encodedValueDoubleParser');
 const encodedValueMethodTypeParser = parserCreatorCompose(() => createEncodedValueArgParser(0x15), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUint8(0);
+            return { type: 'methodType', value: isoIndexIntoPrototypeIds.wrap(buffer.readUint8(0)) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt16LE(0);
+            return { type: 'methodType', value: isoIndexIntoPrototypeIds.wrap(buffer.readUInt16LE(0)) };
         });
     }
     invariant(size === 4, '(encodedValueMethodTypeParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readUInt32LE(0);
+        return { type: 'methodType', value: isoIndexIntoPrototypeIds.wrap(buffer.readUInt32LE(0)) };
     });
 })();
 setParserName(encodedValueMethodTypeParser, 'encodedValueMethodTypeParser');
 const encodedValueMethodHandleParser = parserCreatorCompose(() => createEncodedValueArgParser(0x16), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt8(0);
+            return { type: 'methodHandle', value: buffer.readUInt8(0) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt16LE(0);
+            return { type: 'methodHandle', value: buffer.readUInt16LE(0) };
         });
     }
     invariant(size === 4, '(encodedValueMethodHandleParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readUInt32LE(0);
+        return { type: 'methodHandle', value: buffer.readUInt32LE(0) };
     });
 })();
 setParserName(encodedValueMethodHandleParser, 'encodedValueMethodHandleParser');
 const encodedValueStringParser = parserCreatorCompose(() => createEncodedValueArgParser(0x17), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt8(0);
+            return { type: 'string', value: isoIndexIntoStringIds.wrap(buffer.readUInt8(0)) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt16LE(0);
+            return { type: 'string', value: isoIndexIntoStringIds.wrap(buffer.readUInt16LE(0)) };
         });
     }
     invariant(size === 4, '(encodedValueStringParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readUInt32LE(0);
+        return { type: 'string', value: isoIndexIntoStringIds.wrap(buffer.readUInt32LE(0)) };
     });
 })();
 setParserName(encodedValueStringParser, 'encodedValueStringParser');
 const encodedValueTypeParser = parserCreatorCompose(() => createEncodedValueArgParser(0x18), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt8(0);
+            return { type: 'type', value: isoIndexIntoTypeIds.wrap(buffer.readUInt8(0)) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt16LE(0);
+            return { type: 'type', value: isoIndexIntoTypeIds.wrap(buffer.readUInt16LE(0)) };
         });
     }
     invariant(size === 4, '(encodedValueTypeParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readUInt32LE(0);
+        return { type: 'type', value: isoIndexIntoTypeIds.wrap(buffer.readUInt32LE(0)) };
     });
 })();
 setParserName(encodedValueTypeParser, 'encodedValueTypeParser');
 const encodedValueFieldParser = parserCreatorCompose(() => createEncodedValueArgParser(0x19), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt8(0);
+            return { type: 'field', value: isoIndexIntoFieldIds.wrap(buffer.readUInt8(0)) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt16LE(0);
+            return { type: 'field', value: isoIndexIntoFieldIds.wrap(buffer.readUInt16LE(0)) };
         });
     }
     invariant(size === 4, '(encodedValueFieldParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readUInt32LE(0);
+        return { type: 'field', value: isoIndexIntoFieldIds.wrap(buffer.readUInt32LE(0)) };
     });
 })();
 setParserName(encodedValueFieldParser, 'encodedValueFieldParser');
-const encodedValueMethodParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1a), sizeSubOne => {
+const encodedValueMethodParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1A), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt8(0);
+            return { type: 'method', value: isoIndexIntoMethodIds.wrap(buffer.readUInt8(0)) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt16LE(0);
+            return { type: 'method', value: isoIndexIntoMethodIds.wrap(buffer.readUInt16LE(0)) };
         });
     }
     invariant(size === 4, '(encodedValueMethodParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readUInt32LE(0);
+        return { type: 'method', value: isoIndexIntoMethodIds.wrap(buffer.readUInt32LE(0)) };
     });
 })();
 setParserName(encodedValueMethodParser, 'encodedValueMethodParser');
-const encodedValueEnumParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1b), sizeSubOne => {
+const encodedValueEnumParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1B), sizeSubOne => {
     const size = sizeSubOne + 1;
     if (size === 1) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt8(0);
+            return { type: 'enum', value: isoIndexIntoFieldIds.wrap(buffer.readUInt8(0)) };
         });
     }
     if (size === 2) {
-        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
             const buffer = Buffer.from(uint8Array);
-            return buffer.readUInt16LE(0);
+            return { type: 'enum', value: isoIndexIntoFieldIds.wrap(buffer.readUInt16LE(0)) };
         });
     }
     invariant(size === 4, '(encodedValueEnumParser) Unexpected size: %s', size);
-    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
         const buffer = Buffer.from(uint8Array);
-        return buffer.readUInt32LE(0);
+        return { type: 'enum', value: isoIndexIntoFieldIds.wrap(buffer.readUInt32LE(0)) };
     });
 })();
 setParserName(encodedValueEnumParser, 'encodedValueEnumParser');
-const encodedArrayParser = parserCreatorCompose(() => uleb128NumberParser, (size) => createQuantifierParser(encodedValueParser, size))();
+const encodedArrayParser = parserCreatorCompose(() => uleb128NumberParser, size => createQuantifierParser(encodedValueParser, size))();
 setParserName(encodedArrayParser, 'encodedArrayParser');
 const encodedValueArrayParser = promiseCompose(createTupleParser([
-    parserCreatorCompose(() => createEncodedValueArgParser(0x1c), valueArg => parserContext => {
+    parserCreatorCompose(() => createEncodedValueArgParser(0x1C), valueArg => parserContext => {
         parserContext.invariant(valueArg === 0, '(encodedValueArrayParser) valueArg: %s', valueArg);
     })(),
     encodedArrayParser,
-]), ([_, array]) => array);
+]), ([_, array]) => ({ type: 'array', value: array }));
 setParserName(encodedValueArrayParser, 'encodedValueArrayParser');
 const annotationElementParser = promiseCompose(createTupleParser([
     uleb128NumberParser,
@@ -713,18 +757,18 @@ const encodedAnnotationParser = promiseCompose(parserCreatorCompose(() => create
 }));
 setParserName(encodedAnnotationParser, 'encodedAnnotationParser');
 const encodedValueAnnotationParser = promiseCompose(createTupleParser([
-    parserCreatorCompose(() => createEncodedValueArgParser(0x1d), valueArg => parserContext => {
+    parserCreatorCompose(() => createEncodedValueArgParser(0x1D), valueArg => parserContext => {
         parserContext.invariant(valueArg === 0, '(encodedValueAnnotationParser) valueArg: %s', valueArg);
     })(),
     encodedAnnotationParser,
-]), ([_, annotation]) => annotation);
+]), ([_, annotation]) => ({ type: 'annotation', value: annotation }));
 setParserName(encodedValueAnnotationParser, 'encodedValueAnnotationParser');
-const encodedValueNullParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1e), valueArg => parserContext => {
+const encodedValueNullParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1E), valueArg => parserContext => {
     parserContext.invariant(valueArg === 0, '(encodedValueNullParser) valueArg: %s', valueArg);
-    return null;
+    return ({ type: 'null', value: null });
 })();
 setParserName(encodedValueNullParser, 'encodedValueNullParser');
-const encodedValueBooleanParser = promiseCompose(createEncodedValueArgParser(0x1f), (value) => Boolean(value));
+const encodedValueBooleanParser = promiseCompose(createEncodedValueArgParser(0x1F), valueArg => ({ type: 'boolean', value: Boolean(valueArg) }));
 setParserName(encodedValueBooleanParser, 'encodedValueBooleanParser');
 const encodedValueParser = createDisjunctionParser([
     encodedValueByteParser,
@@ -794,32 +838,28 @@ const createDalvikExecutableCodeItemParser = ({ createInstructionsParser, }) =>
         ushortParser,
         uintParser,
         uintParser,
-    ]), ([_, registersSize, insSize, outsSize, triesSize, debugInfoOffset, instructionsSize,]) => {
-        return promiseCompose(createTupleParser([
-            createInstructionsParser(instructionsSize * 2),
-            ((triesSize !== 0
-                && instructionsSize % 2 === 1)
-                ? byteAlign4Parser
-                : () => undefined),
-            (triesSize !== 0
-                ? createQuantifierParser(tryItemParser, triesSize)
-                : () => []),
-            (triesSize !== 0
-                ? encodedCatchHandlerListParser
-                : () => new Map()),
-        ]), ([instructions, _padding, tryItems, handlers,]) => {
-            return {
-                registersSize,
-                insSize,
-                outsSize,
-                triesSize,
-                debugInfoOffset: isoOffsetToDebugInfoItem.wrap(debugInfoOffset),
-                instructions,
-                tryItems,
-                handlers,
-            };
-        });
-    })();
+    ]), ([_, registersSize, insSize, outsSize, triesSize, debugInfoOffset, instructionsSize,]) => promiseCompose(createTupleParser([
+        createInstructionsParser(instructionsSize * 2),
+        ((triesSize !== 0
+            && instructionsSize % 2 === 1)
+            ? byteAlign4Parser
+            : () => undefined),
+        (triesSize === 0
+            ? () => []
+            : createQuantifierParser(tryItemParser, triesSize)),
+        (triesSize === 0
+            ? () => new Map()
+            : encodedCatchHandlerListParser),
+    ]), ([instructions, _padding, tryItems, handlers,]) => ({
+        registersSize,
+        insSize,
+        outsSize,
+        triesSize,
+        debugInfoOffset: isoOffsetToDebugInfoItem.wrap(debugInfoOffset),
+        instructions,
+        tryItems,
+        handlers,
+    })))();
     setParserName(dalvikExecutableCodeItemParser, 'dalvikExecutableCodeItemParser');
     return dalvikExecutableCodeItemParser;
 };
@@ -834,39 +874,59 @@ const createSkipToThenCodeItemsParser = ({ sizeOffset, createInstructionsParser,
 });
 const dalvikExecutableDebugByteCodeValueParser = parserCreatorCompose(() => ubyteParser, (value) => {
     switch (value) {
-        case 0x01: return promiseCompose(uleb128NumberParser, (addressDiff) => ({ type: 'advancePc', addressDiff }));
-        case 0x02: return promiseCompose(sleb128NumberParser, (lineDiff) => ({ type: 'advanceLine', lineDiff }));
-        case 0x03: return promiseCompose(createTupleParser([
-            uleb128NumberParser,
-            uleb128NumberParser,
-            uleb128NumberParser,
-        ]), ([registerNum, nameIndex, typeIndex]) => ({
-            type: 'startLocal',
-            registerNum,
-            nameIndex: isoIndexIntoStringIds.wrap(nameIndex),
-            typeIndex: isoIndexIntoTypeIds.wrap(typeIndex),
-        }));
-        case 0x04: return promiseCompose(createTupleParser([
-            uleb128NumberParser,
-            uleb128NumberParser,
-            uleb128NumberParser,
-            uleb128NumberParser,
-        ]), ([registerNum, nameIndex, typeIndex, signatureIndex]) => ({
-            type: 'startLocalExtended',
-            registerNum,
-            nameIndex: isoIndexIntoStringIds.wrap(nameIndex),
-            typeIndex: isoIndexIntoTypeIds.wrap(typeIndex),
-            signatureIndex: isoIndexIntoStringIds.wrap(signatureIndex),
-        }));
-        case 0x05: return promiseCompose(uleb128NumberParser, (registerNum) => ({ type: 'endLocal', registerNum }));
-        case 0x06: return promiseCompose(uleb128NumberParser, (registerNum) => ({ type: 'restartLocal', registerNum }));
-        case 0x07: return () => ({ type: 'setPrologueEnd' });
-        case 0x08: return () => ({ type: 'setEpilogueBegin' });
-        case 0x09: return promiseCompose(uleb128NumberParser, (nameIndex) => ({ type: 'setFile', nameIndex: isoIndexIntoStringIds.wrap(nameIndex) }));
-        default: return parserContext => {
-            parserContext.invariant(value >= 0x0a, 'Unexpected special value: %s', value);
-            return { type: 'special', value };
-        };
+        case 0x01: {
+            return promiseCompose(uleb128NumberParser, addressDiff => ({ type: 'advancePc', addressDiff }));
+        }
+        case 0x02: {
+            return promiseCompose(sleb128NumberParser, lineDiff => ({ type: 'advanceLine', lineDiff }));
+        }
+        case 0x03: {
+            return promiseCompose(createTupleParser([
+                uleb128NumberParser,
+                uleb128p1NumberParser,
+                uleb128p1NumberParser,
+            ]), ([registerNumber, nameIndex, typeIndex]) => ({
+                type: 'startLocal',
+                registerNum: registerNumber,
+                nameIndex: nameIndex === -1 ? undefined : isoIndexIntoStringIds.wrap(nameIndex),
+                typeIndex: typeIndex === -1 ? undefined : isoIndexIntoTypeIds.wrap(typeIndex),
+            }));
+        }
+        case 0x04: {
+            return promiseCompose(createTupleParser([
+                uleb128NumberParser,
+                uleb128p1NumberParser,
+                uleb128p1NumberParser,
+                uleb128p1NumberParser,
+            ]), ([registerNumber, nameIndex, typeIndex, signatureIndex]) => ({
+                type: 'startLocalExtended',
+                registerNum: registerNumber,
+                nameIndex: nameIndex === -1 ? undefined : isoIndexIntoStringIds.wrap(nameIndex),
+                typeIndex: typeIndex === -1 ? undefined : isoIndexIntoTypeIds.wrap(typeIndex),
+                signatureIndex: signatureIndex === -1 ? undefined : isoIndexIntoStringIds.wrap(signatureIndex),
+            }));
+        }
+        case 0x05: {
+            return promiseCompose(uleb128NumberParser, registerNumber => ({ type: 'endLocal', registerNum: registerNumber }));
+        }
+        case 0x06: {
+            return promiseCompose(uleb128NumberParser, registerNumber => ({ type: 'restartLocal', registerNum: registerNumber }));
+        }
+        case 0x07: {
+            return () => ({ type: 'setPrologueEnd' });
+        }
+        case 0x08: {
+            return () => ({ type: 'setEpilogueBegin' });
+        }
+        case 0x09: {
+            return promiseCompose(uleb128p1NumberParser, nameIndex => ({ type: 'setFile', nameIndex: nameIndex === -1 ? undefined : isoIndexIntoStringIds.wrap(nameIndex) }));
+        }
+        default: {
+            return parserContext => {
+                parserContext.invariant(value >= 0x0A, 'Unexpected special value: %s', value);
+                return { type: 'special', value };
+            };
+        }
     }
 })();
 setParserName(dalvikExecutableDebugByteCodeValueParser, 'dalvikExecutableDebugByteCodeValueParser');
@@ -892,12 +952,20 @@ const createSkipToThenDebugInfoItemsParser = (sizeOffset) => createSkipToThenIte
     isoOffset: isoOffsetToDebugInfoItem,
     parserName: 'skipToThenDebugInfoItemsParser',
 });
-const dalvikExecutableAnnotationItemVisibilityParser = promiseCompose(ubyteParser, (visibility) => {
+const dalvikExecutableAnnotationItemVisibilityParser = promiseCompose(ubyteParser, visibility => {
     switch (visibility) {
-        case 0x00: return 'build';
-        case 0x01: return 'runtime';
-        case 0x02: return 'system';
-        default: invariant(false, 'Unexpected visibility: %s', visibility);
+        case 0x00: {
+            return 'build';
+        }
+        case 0x01: {
+            return 'runtime';
+        }
+        case 0x02: {
+            return 'system';
+        }
+        default: {
+            invariant(false, 'Unexpected visibility: %s', visibility);
+        }
     }
 });
 setParserName(dalvikExecutableAnnotationItemVisibilityParser, 'dalvikExecutableAnnotationItemVisibilityParser');
@@ -913,14 +981,14 @@ const createSkipToThenAnnotationItemsParser = (sizeOffset) => createSkipToThenIt
     isoOffset: isoOffsetToAnnotationItem,
     parserName: 'skipToThenAnnotationItemsParser',
 });
-const dalvikExecutableHeaderAndMapParser = parserCreatorCompose(() => dalvikExecutableHeaderItemParser, (headerItem) => promiseCompose(createLookaheadParser(createDalvikExecutableMapListParser(headerItem.mapOffset)), (mapList) => ({ headerItem, mapList })))();
-const dalvikExecutableAnnotationOffsetItemParser = promiseCompose(uintParser, (annotationOffset) => ({
+const dalvikExecutableHeaderAndMapParser = parserCreatorCompose(() => dalvikExecutableHeaderItemParser, headerItem => promiseCompose(createLookaheadParser(createDalvikExecutableMapListParser(headerItem.mapOffset)), mapList => ({ headerItem, mapList })))();
+const dalvikExecutableAnnotationOffsetItemParser = promiseCompose(uintParser, annotationOffset => ({
     annotationOffset: isoOffsetToAnnotationItem.wrap(annotationOffset),
 }));
 const dalvikExecutableAnnotationSetItemParser = parserCreatorCompose(() => createTupleParser([
     byteAlign4Parser,
     uintParser,
-]), ([_, size]) => promiseCompose(createQuantifierParser(dalvikExecutableAnnotationOffsetItemParser, size), (entries) => ({ entries })))();
+]), ([_, size]) => promiseCompose(createQuantifierParser(dalvikExecutableAnnotationOffsetItemParser, size), entries => ({ entries })))();
 const createSkipToThenAnnotationSetItemsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
     sizeOffset,
     itemParser: dalvikExecutableAnnotationSetItemParser,
@@ -928,11 +996,11 @@ const createSkipToThenAnnotationSetItemsParser = (sizeOffset) => createSkipToThe
     isoOffset: isoOffsetToAnnotationSetItem,
     parserName: 'skipToThenAnnotationSetItemsParser',
 });
-const dalvikExecutableAnnotationSetRefItemParser = promiseCompose(uintParser, (annotationsOffset) => isoOffsetToAnnotationSetItem.wrap(annotationsOffset));
+const dalvikExecutableAnnotationSetRefItemParser = promiseCompose(uintParser, annotationsOffset => isoOffsetToAnnotationSetItem.wrap(annotationsOffset));
 const dalvikExecutableAnnotationSetRefListParser = parserCreatorCompose(() => createTupleParser([
     byteAlign4Parser,
     uintParser,
-]), ([_, size]) => promiseCompose(createQuantifierParser(dalvikExecutableAnnotationSetRefItemParser, size), (list) => ({ list })))();
+]), ([_, size]) => promiseCompose(createQuantifierParser(dalvikExecutableAnnotationSetRefItemParser, size), list => ({ list })))();
 const createSkipToThenAnnotationSetRefListsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
     sizeOffset,
     itemParser: dalvikExecutableAnnotationSetRefListParser,
@@ -940,30 +1008,74 @@ const createSkipToThenAnnotationSetRefListsParser = (sizeOffset) => createSkipTo
     isoOffset: isoOffsetToAnnotationSetRefListItem,
     parserName: 'skipToThenAnnotationSetRefListsParser',
 });
-const dalvikExecutableMapItemTypeParser = promiseCompose(ushortParser, (type) => {
+const dalvikExecutableMapItemTypeParser = promiseCompose(ushortParser, type => {
     switch (type) {
-        case 0x0000: return 'headerItem';
-        case 0x0001: return 'stringIdItem';
-        case 0x0002: return 'typeIdItem';
-        case 0x0003: return 'prototypeIdItem';
-        case 0x0004: return 'fieldIdItem';
-        case 0x0005: return 'methodIdItem';
-        case 0x0006: return 'classDefinitionItem';
-        case 0x0007: return 'callSiteIdItem';
-        case 0x0008: return 'methodHandleItem';
-        case 0x1000: return 'mapList';
-        case 0x1001: return 'typeList';
-        case 0x1002: return 'annotationSetRefList';
-        case 0x1003: return 'annotationSetItem';
-        case 0x2000: return 'classDataItem';
-        case 0x2001: return 'codeItem';
-        case 0x2002: return 'stringDataItem';
-        case 0x2003: return 'debugInfoItem';
-        case 0x2004: return 'annotationItem';
-        case 0x2005: return 'encodedArrayItem';
-        case 0x2006: return 'annotationsDirectoryItem';
-        case 0xF000: return 'hiddenApiClassDataItem';
-        default: invariant(false, 'Unexpected map item type: %s', type);
+        case 0x00_00: {
+            return 'headerItem';
+        }
+        case 0x00_01: {
+            return 'stringIdItem';
+        }
+        case 0x00_02: {
+            return 'typeIdItem';
+        }
+        case 0x00_03: {
+            return 'prototypeIdItem';
+        }
+        case 0x00_04: {
+            return 'fieldIdItem';
+        }
+        case 0x00_05: {
+            return 'methodIdItem';
+        }
+        case 0x00_06: {
+            return 'classDefinitionItem';
+        }
+        case 0x00_07: {
+            return 'callSiteIdItem';
+        }
+        case 0x00_08: {
+            return 'methodHandleItem';
+        }
+        case 0x10_00: {
+            return 'mapList';
+        }
+        case 0x10_01: {
+            return 'typeList';
+        }
+        case 0x10_02: {
+            return 'annotationSetRefList';
+        }
+        case 0x10_03: {
+            return 'annotationSetItem';
+        }
+        case 0x20_00: {
+            return 'classDataItem';
+        }
+        case 0x20_01: {
+            return 'codeItem';
+        }
+        case 0x20_02: {
+            return 'stringDataItem';
+        }
+        case 0x20_03: {
+            return 'debugInfoItem';
+        }
+        case 0x20_04: {
+            return 'annotationItem';
+        }
+        case 0x20_05: {
+            return 'encodedArrayItem';
+        }
+        case 0x20_06: {
+            return 'annotationsDirectoryItem';
+        }
+        case 0xF0_00: {
+            return 'hiddenApiClassDataItem';
+        }
+        default: {
+            invariant(false, 'Unexpected map item type: %s', type);
+        }
     }
 });
 const dalvikExecutableMapItemParser = promiseCompose(createTupleParser([
@@ -972,9 +1084,7 @@ const dalvikExecutableMapItemParser = promiseCompose(createTupleParser([
     uintParser,
     uintParser,
 ]), ([type, _unused, size, offset]) => ({ type, size, offset }));
-const dalvikExecutableMapListParser = parserCreatorCompose(() => uintParser, size => {
-    return createQuantifierParser(dalvikExecutableMapItemParser, size);
-})();
+const dalvikExecutableMapListParser = parserCreatorCompose(() => uintParser, size => createQuantifierParser(dalvikExecutableMapItemParser, size))();
 setParserName(dalvikExecutableMapListParser, 'dalvikExecutableMapListParser');
 const createDalvikExecutableMapListParser = (mapOffset) => {
     const dalvikExecutableMapParser = promiseCompose(createTupleParser([
@@ -999,8 +1109,8 @@ const createDalvikExecutableDataParser = ({ headerItem, mapList, createInstructi
         let fieldIdItems = isoDalvikExecutableFieldIdItems.wrap([]);
         let methodIdItems = isoDalvikExecutableMethodIdItems.wrap([]);
         let classDefinitionItems = [];
-        let callSiteIdItems = [];
-        let methodHandleItems = [];
+        const callSiteIdItems = [];
+        const methodHandleItems = [];
         let typeListByOffset = new Map();
         let annotationSetRefListItemByOffset = new Map();
         let annotationSetItemByOffset = new Map();
@@ -1011,8 +1121,17 @@ const createDalvikExecutableDataParser = ({ headerItem, mapList, createInstructi
         let annotationItemByOffset = new Map();
         let encodedArrayItemByOffset = new Map();
         let annotationsDirectoryItemByOffset = new Map();
-        let hiddenApiClassDataItems = [];
+        const hiddenApiClassDataItems = [];
+        // Track if link has been parsed
+        let link = undefined;
+        let linkParsed = false;
         for (const dexMapItem of mapList) {
+            // Parse link data before any map item that comes after it in the file
+            // Link data is not included in the map items, but is referenced in the header
+            if (!linkParsed && headerItem.link.size > 0 && headerItem.link.offset < dexMapItem.offset) {
+                link = await createRawDataParser(headerItem.link)(parserContext);
+                linkParsed = true;
+            }
             if (dexMapItem.type === 'headerItem') {
                 continue;
             }
@@ -1047,6 +1166,7 @@ const createDalvikExecutableDataParser = ({ headerItem, mapList, createInstructi
                 // TODO
             }
             if (dexMapItem.type === 'mapList') {
+                // Re-parse the map itself to consume it from the input
                 await createDalvikExecutableMapListParser(dexMapItem.offset)(parserContext);
                 continue;
             }
@@ -1098,6 +1218,11 @@ const createDalvikExecutableDataParser = ({ headerItem, mapList, createInstructi
             }
             invariant(false, 'Unexpected map item type: %s', dexMapItem.type);
         }
+        // Parse link data after the loop if it hasn't been parsed yet
+        // This handles the case where link comes after all map items
+        if (!linkParsed && headerItem.link.size > 0) {
+            link = await createRawDataParser(headerItem.link)(parserContext);
+        }
         return {
             headerItem,
             stringIdItems,
@@ -1120,31 +1245,29 @@ const createDalvikExecutableDataParser = ({ headerItem, mapList, createInstructi
             encodedArrayItemByOffset,
             annotationsDirectoryItemByOffset,
             hiddenApiClassDataItems,
+            link,
         };
     };
     setParserName(dalvikExecutableDataParser, 'dalvikExecutableDataParser');
     return dalvikExecutableDataParser;
 };
-const createDalvikExecutableParser = ({ createInstructionsParser, }) => parserCreatorCompose(() => dalvikExecutableHeaderAndMapParser, ({ headerItem, mapList, }) => promiseCompose(createTupleParser([
-    createDalvikExecutableDataParser({
-        headerItem,
-        mapList,
-        createInstructionsParser,
-    }),
-    createRawDataParser(headerItem.link),
-]), async ([{ headerItem: _headerItem, stringIdItems, typeIdItems, prototypeIdItems, fieldIdItems, methodIdItems, classDefinitionItems, 
-// callSiteIdItems,
+const createDalvikExecutableParser = ({ createInstructionsParser, }) => parserCreatorCompose(() => dalvikExecutableHeaderAndMapParser, ({ headerItem, mapList, }) => promiseCompose(createDalvikExecutableDataParser({
+    headerItem,
+    mapList,
+    createInstructionsParser,
+}), async ({ headerItem: _headerItem, stringIdItems, typeIdItems, prototypeIdItems, fieldIdItems, methodIdItems, classDefinitionItems, 
+// CallSiteIdItems,
 // methodHandleItems,
-mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotationSetItemByOffset, classDataItemByOffset, codeItemByOffset, stringDataItemStringByOffset, debugInfoItemByOffset, annotationItemByOffset, encodedArrayItemByOffset, annotationsDirectoryItemByOffset,
-// hiddenApiClassDataItems,
- }, link,]) => {
-    const strings = stringIdItems.map((stringId) => {
+mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotationSetItemByOffset, classDataItemByOffset, codeItemByOffset, stringDataItemStringByOffset, debugInfoItemByOffset, annotationItemByOffset, encodedArrayItemByOffset, annotationsDirectoryItemByOffset, 
+// HiddenApiClassDataItems,
+link, }) => {
+    const strings = stringIdItems.map(stringId => {
         const stringOffset = stringId;
         const string = stringDataItemStringByOffset.get(stringOffset);
         invariant(string !== undefined, 'String must be there. String offset: %s', stringOffset);
         return string;
     });
-    const types = typeIdItems.map((typeId) => {
+    const types = typeIdItems.map(typeId => {
         const type = strings.at(typeId);
         invariant(type, 'Type string must be there. Type id: %s', typeId);
         return type;
@@ -1153,14 +1276,14 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
         [isoOffsetToTypeList.wrap(0), []],
     ]);
     for (const [offset, typeIndexes] of typeListByOffset) {
-        const typeNames = isoDalvikExecutableTypeList.unwrap(typeIndexes).map((typeIndex) => {
+        const typeNames = isoDalvikExecutableTypeList.unwrap(typeIndexes).map(typeIndex => {
             const type = types.at(typeIndex);
             invariant(type, 'Type must be there. Type id: %s', typeIndex);
             return type;
         });
         resolvedTypeListByOffset.set(offset, typeNames);
     }
-    const prototypes = prototypeIdItems.map((prototypeId) => {
+    const prototypes = prototypeIdItems.map(prototypeId => {
         const shorty = strings.at(prototypeId.shortyIndex);
         invariant(shorty, 'Shorty must be there. Shorty id: %s', prototypeId.shortyIndex);
         const returnType = types.at(prototypeId.returnTypeIndex);
@@ -1169,7 +1292,7 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
         invariant(parameters !== undefined, 'Parameters must be there. Parameters offset: %s', prototypeId.parametersOffset);
         return { shorty, returnType, parameters };
     });
-    const fields = fieldIdItems.map((fieldId) => {
+    const fields = fieldIdItems.map(fieldId => {
         const class_ = types.at(fieldId.classIndex);
         invariant(class_, 'Class must be there. Class id: %s', fieldId.classIndex);
         const type = types.at(fieldId.typeIndex);
@@ -1178,7 +1301,7 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
         invariant(name, 'Name string must be there. String offset: %s', fieldId.nameIndex);
         return { class: class_, type, name };
     });
-    const methods = methodIdItems.map((methodId) => {
+    const methods = methodIdItems.map(methodId => {
         const class_ = types.at(methodId.classIndex);
         invariant(class_, 'Class must be there. Class id: %s', methodId.classIndex);
         const prototype = prototypes.at(methodId.prototypeIndex);
@@ -1193,7 +1316,7 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
     for (const [offset, debugInfoItem] of debugInfoItemByOffset) {
         debugInfoByOffset.set(offset, {
             lineStart: debugInfoItem.lineStart,
-            parameterNames: debugInfoItem.parameterNames.map((index) => {
+            parameterNames: debugInfoItem.parameterNames.map(index => {
                 if (index === undefined) {
                     return undefined;
                 }
@@ -1201,23 +1324,31 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
                 invariant(string !== undefined, 'String must be there. String id: %s', index);
                 return string;
             }),
-            bytecode: debugInfoItem.bytecode.map((value) => {
+            bytecode: debugInfoItem.bytecode.map(value => {
                 switch (value.type) {
-                    case 'startLocal': return {
-                        type: 'startLocal',
-                        registerNum: value.registerNum,
-                        name: value.nameIndex === undefined ? undefined : strings.at(value.nameIndex),
-                        type_: value.typeIndex === undefined ? undefined : types.at(value.typeIndex),
-                    };
-                    case 'startLocalExtended': return {
-                        type: 'startLocalExtended',
-                        registerNum: value.registerNum,
-                        name: value.nameIndex === undefined ? undefined : strings.at(value.nameIndex),
-                        type_: value.typeIndex === undefined ? undefined : types.at(value.typeIndex),
-                        signature: value.signatureIndex === undefined ? undefined : strings.at(value.signatureIndex),
-                    };
-                    case 'setFile': return { type: 'setFile', name: strings.at(value.nameIndex) };
-                    default: return value;
+                    case 'startLocal': {
+                        return {
+                            type: 'startLocal',
+                            registerNum: value.registerNum,
+                            name: value.nameIndex === undefined ? undefined : strings.at(value.nameIndex),
+                            type_: value.typeIndex === undefined ? undefined : types.at(value.typeIndex),
+                        };
+                    }
+                    case 'startLocalExtended': {
+                        return {
+                            type: 'startLocalExtended',
+                            registerNum: value.registerNum,
+                            name: value.nameIndex === undefined ? undefined : strings.at(value.nameIndex),
+                            type_: value.typeIndex === undefined ? undefined : types.at(value.typeIndex),
+                            signature: value.signatureIndex === undefined ? undefined : strings.at(value.signatureIndex),
+                        };
+                    }
+                    case 'setFile': {
+                        return { type: 'setFile', name: value.nameIndex === undefined ? undefined : strings.at(value.nameIndex) };
+                    }
+                    default: {
+                        return value;
+                    }
                 }
             }),
         });
@@ -1231,14 +1362,13 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
             registersSize: codeItem.registersSize,
             insSize: codeItem.insSize,
             outsSize: codeItem.outsSize,
-            debugInfo: debugInfo,
+            debugInfo,
             instructions: codeItem.instructions,
-            tries: codeItem.tryItems.map((tryItem) => {
+            tries: codeItem.tryItems.map(tryItem => {
                 const handler_ = codeItem.handlers.get(tryItem.handlerOffset);
                 invariant(handler_, 'Handler must be there. Handler offset: %s', tryItem.handlerOffset);
                 const handler = {
-                    ...handler_,
-                    handlers: handler_.handlers.map((encodedHandler) => {
+                    handlers: handler_.handlers.map(encodedHandler => {
                         const type = types.at(encodedHandler.typeIndex);
                         invariant(type, 'Type must be there. Type id: %s', encodedHandler.typeIndex);
                         return {
@@ -1246,6 +1376,7 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
                             address: encodedHandler.address,
                         };
                     }),
+                    catchAllAddress: handler_.catchAllAddress,
                 };
                 return {
                     startAddress: tryItem.startAddress,
@@ -1261,22 +1392,22 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
     const resolvers = {
         resolveIndexIntoStringIds(indexIntoStringIds) {
             const string = strings.at(indexIntoStringIds);
-            invariant(string, 'String must be there. String id: %s', indexIntoStringIds);
+            invariant(string !== undefined, 'String must be there. String id: %s', indexIntoStringIds);
             return string;
         },
         resolveIndexIntoTypeIds(indexIntoTypeIds) {
             const type = types.at(indexIntoTypeIds);
-            invariant(type, 'Type must be there. Type id: %s', indexIntoTypeIds);
+            invariant(type !== undefined, 'Type must be there. Type id: %s', indexIntoTypeIds);
             return type;
         },
         resolveIndexIntoMethodIds(indexIntoMethodIds) {
             const method = methods.at(indexIntoMethodIds);
-            invariant(method, 'Method must be there. Method id: %s', indexIntoMethodIds);
+            invariant(method !== undefined, 'Method must be there. Method id: %s', indexIntoMethodIds);
             return method;
         },
         resolveIndexIntoFieldIds(indexIntoFieldIds) {
             const field = fields.at(indexIntoFieldIds);
-            invariant(field, 'Field must be there. Field id: %s', indexIntoFieldIds);
+            invariant(field !== undefined, 'Field must be there. Field id: %s', indexIntoFieldIds);
             return field;
         },
     };
@@ -1290,14 +1421,12 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
         }
         return {
             ...rest,
-            instructions: instructions.map((instruction) => {
-                return resolveDalvikBytecodeOperation(instruction, resolvers);
-            }),
+            instructions: instructions.map((instruction) => resolveDalvikBytecodeOperation(instruction, resolvers)),
         };
     }
     for (const [offset, classDataItem] of classDataItemByOffset) {
         classDataByOffset.set(offset, {
-            staticFields: classDataItem.staticFields.map((encodedField) => {
+            staticFields: classDataItem.staticFields.map(encodedField => {
                 const field = fields.at(encodedField.fieldIndex);
                 invariant(field, 'Field must be there. Field id: %s', encodedField.fieldIndex);
                 return {
@@ -1305,7 +1434,7 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
                     accessFlags: encodedField.accessFlags,
                 };
             }),
-            instanceFields: classDataItem.instanceFields.map((encodedField) => {
+            instanceFields: classDataItem.instanceFields.map(encodedField => {
                 const field = fields.at(encodedField.fieldIndex);
                 invariant(field, 'Field must be there. Field id: %s', encodedField.fieldIndex);
                 return {
@@ -1313,7 +1442,7 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
                     accessFlags: encodedField.accessFlags,
                 };
             }),
-            directMethods: classDataItem.directMethods.map((method) => {
+            directMethods: classDataItem.directMethods.map(method => {
                 const method_ = methods.at(method.methodIndex);
                 invariant(method_, 'Method must be there. Method id: %s', method.methodIndex);
                 const code = codeByOffset.get(method.codeOffset);
@@ -1324,7 +1453,7 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
                     code: resolveCode(code),
                 };
             }),
-            virtualMethods: classDataItem.virtualMethods.map((method) => {
+            virtualMethods: classDataItem.virtualMethods.map(method => {
                 const method_ = methods.at(method.methodIndex);
                 invariant(method_, 'Method must be there. Method id: %s', method.methodIndex);
                 const code = codeByOffset.get(method.codeOffset);
@@ -1337,17 +1466,155 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
             }),
         });
     }
+    // Resolve TaggedEncodedValue to DalvikExecutableEncodedValue for static values
+    // Resolves internal index types to actual values while preserving type tags
+    function resolveTaggedEncodedValueForStaticValues(taggedValue) {
+        const { type, value } = taggedValue;
+        // For primitive types, keep the type tag and value
+        if (type === 'byte'
+            || type === 'short'
+            || type === 'char'
+            || type === 'int'
+            || type === 'float'
+            || type === 'double'
+            || type === 'long'
+            || type === 'boolean'
+            || type === 'null'
+            || type === 'methodHandle') {
+            return { type, value };
+        }
+        // For types that reference the pool, resolve the index to the actual value
+        if (type === 'methodType') {
+            const prototype = prototypes.at(value);
+            invariant(prototype, 'Prototype must be there. Prototype id: %s', isoIndexIntoPrototypeIds.unwrap(value));
+            return { type, value: prototype };
+        }
+        if (type === 'string') {
+            const string = strings.at(value);
+            invariant(string !== undefined, 'String must be there. String id: %s', isoIndexIntoStringIds.unwrap(value));
+            return { type, value: string };
+        }
+        if (type === 'type') {
+            const typeString = types.at(value);
+            invariant(typeString !== undefined, 'Type must be there. Type id: %s', isoIndexIntoTypeIds.unwrap(value));
+            return { type, value: typeString };
+        }
+        if (type === 'field' || type === 'enum') {
+            const field = fields.at(value);
+            invariant(field, 'Field must be there. Field id: %s', isoIndexIntoFieldIds.unwrap(value));
+            return { type, value: field };
+        }
+        if (type === 'method') {
+            const method = methods.at(value);
+            invariant(method, 'Method must be there. Method id: %s', isoIndexIntoMethodIds.unwrap(value));
+            return { type, value: method };
+        }
+        if (type === 'array') {
+            return { type, value: value.map(resolveTaggedEncodedValueForStaticValues) };
+        }
+        if (type === 'annotation') {
+            // Resolve the encoded annotation
+            const annotationType = types.at(value.typeIndex);
+            invariant(annotationType, 'Type must be there. Type id: %s', isoIndexIntoTypeIds.unwrap(value.typeIndex));
+            const resolvedElements = value.elements.map(element => {
+                const name = strings.at(element.nameIndex);
+                invariant(name, 'Name string must be there. String offset: %s', element.nameIndex);
+                return {
+                    name,
+                    value: resolveTaggedEncodedValueForAnnotations(element.value),
+                };
+            });
+            const annotation = {
+                visibility: 'build', // Default visibility for embedded annotations
+                type: annotationType,
+                elements: resolvedElements,
+            };
+            return { type, value: annotation };
+        }
+        // This should never happen
+        throw new Error(`Unknown encoded value type: ${type}`);
+    }
+    // Resolve TaggedEncodedValue to DalvikExecutableEncodedValue for annotation elements
+    // Resolves internal index types to actual values while preserving type tags
+    function resolveTaggedEncodedValueForAnnotations(taggedValue) {
+        const { type, value } = taggedValue;
+        // For primitive types, keep the type tag and value
+        if (type === 'byte'
+            || type === 'short'
+            || type === 'char'
+            || type === 'int'
+            || type === 'float'
+            || type === 'double'
+            || type === 'long'
+            || type === 'boolean'
+            || type === 'null'
+            || type === 'methodHandle') {
+            return { type, value };
+        }
+        // For types that reference the pool, resolve the index to the actual value
+        if (type === 'methodType') {
+            const prototype = prototypes.at(value);
+            invariant(prototype, 'Prototype must be there. Prototype id: %s', isoIndexIntoPrototypeIds.unwrap(value));
+            return { type, value: prototype };
+        }
+        if (type === 'string') {
+            const string = strings.at(value);
+            invariant(string !== undefined, 'String must be there. String id: %s', isoIndexIntoStringIds.unwrap(value));
+            return { type, value: string };
+        }
+        if (type === 'type') {
+            const typeString = types.at(value);
+            invariant(typeString !== undefined, 'Type must be there. Type id: %s', isoIndexIntoTypeIds.unwrap(value));
+            return { type, value: typeString };
+        }
+        if (type === 'field' || type === 'enum') {
+            const field = fields.at(value);
+            invariant(field, 'Field must be there. Field id: %s', isoIndexIntoFieldIds.unwrap(value));
+            return { type, value: field };
+        }
+        if (type === 'method') {
+            const method = methods.at(value);
+            invariant(method, 'Method must be there. Method id: %s', isoIndexIntoMethodIds.unwrap(value));
+            return { type, value: method };
+        }
+        // For arrays, recursively resolve elements
+        if (type === 'array') {
+            return { type, value: value.map(resolveTaggedEncodedValueForAnnotations) };
+        }
+        // For annotations
+        if (type === 'annotation') {
+            // Resolve the encoded annotation (subannotation)
+            const annotationType = types.at(value.typeIndex);
+            invariant(annotationType, 'Type must be there. Type id: %s', isoIndexIntoTypeIds.unwrap(value.typeIndex));
+            const resolvedElements = value.elements.map(element => {
+                const name = strings.at(element.nameIndex);
+                invariant(name, 'Name string must be there. String offset: %s', element.nameIndex);
+                return {
+                    name,
+                    value: resolveTaggedEncodedValueForAnnotations(element.value),
+                };
+            });
+            const annotation = {
+                visibility: 'build', // Default visibility for embedded annotations
+                type: annotationType,
+                elements: resolvedElements,
+            };
+            return { type, value: annotation };
+        }
+        // This should never happen
+        throw new Error(`Unknown encoded value type: ${type}`);
+    }
     function resolveAnnotationOffsetItem({ annotationOffset }) {
         const annotationItem = annotationItemByOffset.get(annotationOffset);
         invariant(annotationItem, 'Annotation must be there. Annotation offset: %s', annotationOffset);
         const type = types.at(annotationItem.encodedAnnotation.typeIndex);
         invariant(type, 'Type must be there. Type id: %s', annotationItem.encodedAnnotation.typeIndex);
-        const elements = annotationItem.encodedAnnotation.elements.map((element) => {
+        const elements = annotationItem.encodedAnnotation.elements.map(element => {
             const name = strings.at(element.nameIndex);
             invariant(name, 'Name string must be there. String offset: %s', element.nameIndex);
             return {
                 name,
-                value: element.value,
+                value: resolveTaggedEncodedValueForAnnotations(element.value),
             };
         });
         return {
@@ -1357,9 +1624,16 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
         };
     }
     function resolveAnnotationSetItem(annotationSetItem) {
-        return annotationSetItem?.entries.map(resolveAnnotationOffsetItem);
+        if (!annotationSetItem) {
+            return undefined;
+        }
+        const annotationSet = annotationSetItem.entries.map(resolveAnnotationOffsetItem);
+        if (!annotationSet.length) {
+            return [];
+        }
+        return annotationSet;
     }
-    const classDefinitions = classDefinitionItems.map((classDefinitionItem) => {
+    const classDefinitions = classDefinitionItems.map(classDefinitionItem => {
         const class_ = types.at(classDefinitionItem.classIndex);
         invariant(class_, 'Class must be there. Class id: %s', classDefinitionItem.classIndex);
         const superclass = types.at(classDefinitionItem.superclassIndex);
@@ -1377,31 +1651,48 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
             invariant(isoOffsetToAnnotationSetItem.unwrap(annotationsDirectoryItem.classAnnotationsOffset) === 0 || classAnnotationSetItem, 'Class annotations must be there. Class annotations offset: %s', annotationsDirectoryItem.classAnnotationsOffset);
             const classAnnotations = (classAnnotationSetItem
                 ? resolveAnnotationSetItem(classAnnotationSetItem)
-                : undefined);
-            const fieldAnnotations = annotationsDirectoryItem.fieldAnnotations.map((fieldAnnotation) => {
+                : undefined) ?? [];
+            const fieldAnnotations = annotationsDirectoryItem.fieldAnnotations.flatMap(fieldAnnotation => {
                 const field = fields.at(fieldAnnotation.fieldIndex);
                 invariant(field, 'Field must be there. Field id: %s', fieldAnnotation.fieldIndex);
-                const annotations = annotationSetItemByOffset.get(fieldAnnotation.annotationsOffset);
-                invariant(isoOffsetToAnnotationSetItem.unwrap(fieldAnnotation.annotationsOffset) === 0 || annotations, 'Annotations must be there. Annotations offset: %s', fieldAnnotation.annotationsOffset);
-                return { field, annotations: annotations?.entries.map(resolveAnnotationOffsetItem) };
+                const annotationSetItem = annotationSetItemByOffset.get(fieldAnnotation.annotationsOffset);
+                invariant(isoOffsetToAnnotationSetItem.unwrap(fieldAnnotation.annotationsOffset) === 0 || annotationSetItem, 'Annotations must be there. Annotations offset: %s', fieldAnnotation.annotationsOffset);
+                const annotations = resolveAnnotationSetItem(annotationSetItem);
+                // Skip fields with no annotations (undefined or empty array)
+                if (!annotations || annotations.length === 0) {
+                    return [];
+                }
+                return [{
+                        field,
+                        annotations,
+                    }];
             });
-            const methodAnnotations = annotationsDirectoryItem.methodAnnotations.map((methodAnnotation) => {
+            const methodAnnotations = annotationsDirectoryItem.methodAnnotations.flatMap(methodAnnotation => {
                 const method = methods.at(methodAnnotation.methodIndex);
                 invariant(method, 'Method must be there. Method id: %s', methodAnnotation.methodIndex);
                 const annotationSetItem = annotationSetItemByOffset.get(methodAnnotation.annotationsOffset);
                 invariant(isoOffsetToAnnotationSetItem.unwrap(methodAnnotation.annotationsOffset) === 0 || annotationSetItem, 'Annotations must be there. Annotations offset: %s', methodAnnotation.annotationsOffset);
-                return { method, annotations: resolveAnnotationSetItem(annotationSetItem) };
+                const annotations = resolveAnnotationSetItem(annotationSetItem) ?? [];
+                // Skip methods with no annotations
+                if (annotations.length === 0) {
+                    return [];
+                }
+                return [{
+                        method,
+                        annotations,
+                    }];
             });
-            const parameterAnnotations = annotationsDirectoryItem.parameterAnnotations.map((parameterAnnotation) => {
+            const parameterAnnotations = annotationsDirectoryItem.parameterAnnotations.flatMap(parameterAnnotation => {
                 const method = methods.at(parameterAnnotation.methodIndex);
                 invariant(method, 'Method must be there. Method id: %s', parameterAnnotation.methodIndex);
                 const annotationSetRefList = annotationSetRefListItemByOffset.get(parameterAnnotation.annotationsOffset);
                 invariant(isoOffsetToAnnotationSetRefListItem.unwrap(parameterAnnotation.annotationsOffset) === 0 || annotationSetRefList, 'Annotations must be there. Annotations offset: %s', parameterAnnotation.annotationsOffset);
-                const annotations = annotationSetRefList?.list.map((annotationSetRefItem) => {
+                const annotations = annotationSetRefList?.list.map(annotationSetRefItem => {
                     const annotationSetItem = annotationSetItemByOffset.get(annotationSetRefItem);
                     invariant(isoOffsetToAnnotationSetItem.unwrap(annotationSetRefItem) === 0 || annotationSetItem, 'Annotations must be there. Annotations offset: %s', annotationSetRefItem);
-                    return resolveAnnotationSetItem(annotationSetItem);
-                });
+                    const annotationSet = resolveAnnotationSetItem(annotationSetItem);
+                    return annotationSet ?? [];
+                }) ?? [];
                 return { method, annotations };
             });
             return {
@@ -1412,11 +1703,25 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
             };
         })();
         const classData = classDataByOffset.get(classDefinitionItem.classDataOffset);
-        const staticValues = isoOffsetToEncodedArrayItem.unwrap(classDefinitionItem.staticValuesOffset) === 0 ? [] : encodedArrayItemByOffset.get(classDefinitionItem.staticValuesOffset);
-        invariant(staticValues, 'Static values must be there. Static values offset: %s', classDefinitionItem.staticValuesOffset);
+        const staticValuesTagged = isoOffsetToEncodedArrayItem.unwrap(classDefinitionItem.staticValuesOffset) === 0 ? [] : encodedArrayItemByOffset.get(classDefinitionItem.staticValuesOffset);
+        invariant(staticValuesTagged, 'Static values must be there. Static values offset: %s', classDefinitionItem.staticValuesOffset);
+        const staticValues = staticValuesTagged.map(resolveTaggedEncodedValueForStaticValues);
+        const allMembers = [
+            ...classData?.staticFields ?? [],
+            ...classData?.instanceFields ?? [],
+            ...classData?.directMethods ?? [],
+            // ...classData?.virtualMethods ?? [], // TODO?
+        ];
+        const allMembersAreSynthetic = (allMembers.every(member => member.accessFlags.synthetic)
+            && allMembers.length > 0);
+        const accessFlags = {
+            ...classDefinitionItem.accessFlags,
+            // Use the synthetic flag from the class definition, or compute it from members if not set
+            synthetic: classDefinitionItem.accessFlags.synthetic || allMembersAreSynthetic,
+        };
         return {
             class: class_,
-            accessFlags: classDefinitionItem.accessFlags,
+            accessFlags,
             superclass,
             interfaces,
             sourceFile,
@@ -1425,6 +1730,19 @@ mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotatio
             staticValues,
         };
     });
+    // Sort parameter annotations in each class by method index in classData
+    for (const classDef of classDefinitions) {
+        if (classDef.annotations?.parameterAnnotations && classDef.classData) {
+            const allMethods = [...(classDef.classData.directMethods ?? []), ...(classDef.classData.virtualMethods ?? [])];
+            classDef.annotations.parameterAnnotations.sort((a, b) => {
+                const indexA = allMethods.findIndex(m => m.method.name === a.method.name &&
+                    m.method.prototype.shorty === a.method.prototype.shorty);
+                const indexB = allMethods.findIndex(m => m.method.name === b.method.name &&
+                    m.method.prototype.shorty === b.method.prototype.shorty);
+                return indexA - indexB;
+            });
+        }
+    }
     return {
         classDefinitions,
         link,