@futpib/parser 1.0.2 → 1.0.3

package/src/dalvikExecutableParser.ts

@@ -1,5 +1,6 @@
 import invariant from 'invariant';
-import { MUtf8Decoder } from "mutf-8";
+import { MUtf8Decoder } from 'mutf-8';
+import { type Iso } from 'monocle-ts';
 import { createExactElementParser } from './exactElementParser.js';
 import { createExactSequenceParser } from './exactSequenceParser.js';
 import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
@@ -11,19 +12,69 @@ import { createTupleParser } from './tupleParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
 import { createSkipToParser } from './skipToParser.js';
 import { createLookaheadParser } from './lookaheadParser.js';
-import { getIsoTypedNumberArray, IndexIntoFieldIds, IndexIntoMethodIds, IndexIntoPrototypeIds, IndexIntoStringIds, IndexIntoTypeIds, isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoPrototypeIds, isoIndexIntoStringIds, isoIndexIntoTypeIds, isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler, isoOffsetToAnnotationItem, isoOffsetToAnnotationsDirectoryItem, isoOffsetToAnnotationSetItem, isoOffsetToAnnotationSetRefListItem, isoOffsetToClassDataItem, isoOffsetToCodeItem, isoOffsetToDebugInfoItem, isoOffsetToEncodedArrayItem, isoOffsetToStringDataItem, isoOffsetToTypeList, OffsetFromEncodedCatchHandlerListToEncodedCatchHandler, OffsetToAnnotationItem, OffsetToAnnotationsDirectoryItem, OffsetToAnnotationSetItem, OffsetToAnnotationSetRefListItem, OffsetToClassDataItem, OffsetToCodeItem, OffsetToDebugInfoItem, OffsetToEncodedArrayItem, OffsetToStringDataItem, OffsetToTypeList, TypedNumberArray } from './dalvikExecutableParser/typedNumbers.js';
-import { Iso } from 'monocle-ts';
+import {
+	getIsoTypedNumberArray,
+	type IndexIntoFieldIds,
+	type IndexIntoMethodIds,
+	type IndexIntoPrototypeIds,
+	type IndexIntoStringIds,
+	type IndexIntoTypeIds,
+	isoIndexIntoFieldIds,
+	isoIndexIntoMethodIds,
+	isoIndexIntoPrototypeIds,
+	isoIndexIntoStringIds,
+	isoIndexIntoTypeIds,
+	isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler,
+	isoOffsetToAnnotationItem,
+	isoOffsetToAnnotationsDirectoryItem,
+	isoOffsetToAnnotationSetItem,
+	isoOffsetToAnnotationSetRefListItem,
+	isoOffsetToClassDataItem,
+	isoOffsetToCodeItem,
+	isoOffsetToDebugInfoItem,
+	isoOffsetToEncodedArrayItem,
+	isoOffsetToStringDataItem,
+	isoOffsetToTypeList,
+	type OffsetFromEncodedCatchHandlerListToEncodedCatchHandler,
+	type OffsetToAnnotationItem,
+	type OffsetToAnnotationsDirectoryItem,
+	type OffsetToAnnotationSetItem,
+	type OffsetToAnnotationSetRefListItem,
+	type OffsetToClassDataItem,
+	type OffsetToCodeItem,
+	type OffsetToDebugInfoItem,
+	type OffsetToEncodedArrayItem,
+	type OffsetToStringDataItem,
+	type OffsetToTypeList,
+	type TypedNumberArray,
+} 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, DalvikBytecode, DalvikBytecodeOperation, DalvikBytecodeOperationResolvers, resolveDalvikBytecodeOperation } from './dalvikBytecodeParser.js';
-import { ubyteParser, uintParser, uleb128p1NumberParser, ushortParser } from './dalvikExecutableParser/typeParsers.js';
-import { DalvikExecutable, DalvikExecutableAccessFlags, DalvikExecutableAnnotation, DalvikExecutableClassAnnotations, DalvikExecutableClassData, DalvikExecutableClassFieldAnnotation, DalvikExecutableClassMethodAnnotation, DalvikExecutableClassParameterAnnotation, DalvikExecutableCode, DalvikExecutableDebugInfo, DalvikExecutableEncodedValue } from './dalvikExecutable.js';
+import {
+	createDalvikBytecodeParser, type DalvikBytecode, type DalvikBytecodeOperation, type DalvikBytecodeOperationResolvers, resolveDalvikBytecodeOperation,
+} from './dalvikBytecodeParser.js';
+import {
+	byteParser, ubyteParser, uintParser, uleb128p1NumberParser, ushortParser,
+} from './dalvikExecutableParser/typeParsers.js';
+import {
+	type DalvikExecutable,
+	type DalvikExecutableAccessFlags,
+	type DalvikExecutableAnnotation,
+	type DalvikExecutableClassAnnotations,
+	type DalvikExecutableClassData,
+	type DalvikExecutableClassFieldAnnotation,
+	type DalvikExecutableClassMethodAnnotation,
+	type DalvikExecutableClassParameterAnnotation,
+	type DalvikExecutableCode,
+	type DalvikExecutableDebugInfo,
+	type DalvikExecutableEncodedValue,
+} from './dalvikExecutable.js';
 
 // https://source.android.com/docs/core/runtime/dex-format
 
-const createByteAlignParser = (byteAlignment: number): Parser<void, Uint8Array> => async (parserContext) => {
+const createByteAlignParser = (byteAlignment: number): Parser<void, Uint8Array> => async parserContext => {
 	const toSkip = (byteAlignment - (parserContext.position % byteAlignment)) % byteAlignment;
 
 	parserContext.skip(toSkip);
@@ -46,8 +97,8 @@ const dalvikExecutableHeaderVersionParser: Parser<number, Uint8Array> = promiseC
 );
 
 type SizeOffset = {
-	size: number,
-	offset: number,
+	size: number;
+	offset: number;
 };
 
 const sizeOffsetParser: Parser<SizeOffset, Uint8Array> = promiseCompose(
@@ -59,21 +110,21 @@ const sizeOffsetParser: Parser<SizeOffset, Uint8Array> = promiseCompose(
 );
 
 type DalvikExecutableHeaderItem = {
-	version: number,
-	checksum: number,
-	sha1Hash: Uint8Array,
-	fileSize: number,
-	headerSize: number,
-	endianTag: number,
-	link: SizeOffset,
-	mapOffset: number,
-	stringIds: SizeOffset,
-	typeIds: SizeOffset,
-	prototypeIds: SizeOffset,
-	fieldIds: SizeOffset,
-	methodIds: SizeOffset,
-	classDefinitions: SizeOffset,
-	data: SizeOffset,
+	version: number;
+	checksum: number;
+	sha1Hash: Uint8Array;
+	fileSize: number;
+	headerSize: number;
+	endianTag: number;
+	link: SizeOffset;
+	mapOffset: number;
+	stringIds: SizeOffset;
+	typeIds: SizeOffset;
+	prototypeIds: SizeOffset;
+	fieldIds: SizeOffset;
+	methodIds: SizeOffset;
+	classDefinitions: SizeOffset;
+	data: SizeOffset;
 };
 
 const dalvikExecutableHeaderItemParser: Parser<DalvikExecutableHeaderItem, Uint8Array> = promiseCompose(
@@ -133,7 +184,7 @@ type DalvikExecutableStringIdItem = OffsetToStringDataItem;
 
 const dalvikExecutableStringIdItemParser: Parser<DalvikExecutableStringIdItem, Uint8Array> = promiseCompose(
 	cloneParser(uintParser),
-	(offset) => isoOffsetToStringDataItem.wrap(offset),
+	offset => isoOffsetToStringDataItem.wrap(offset),
 );
 
 type DalvikExecutableStringIdItems = TypedNumberArray<IndexIntoStringIds, DalvikExecutableStringIdItem>;
@@ -159,7 +210,7 @@ type DalvikExecutableTypeIdItem = IndexIntoStringIds;
 
 const dalvikExecutableTypeIdItemParser: Parser<DalvikExecutableTypeIdItem, Uint8Array> = promiseCompose(
 	cloneParser(uintParser),
-	(index) => isoIndexIntoStringIds.wrap(index),
+	index => isoIndexIntoStringIds.wrap(index),
 );
 
 type DalvikExecutableTypeIdItems = TypedNumberArray<IndexIntoTypeIds, DalvikExecutableTypeIdItem>;
@@ -233,7 +284,7 @@ const createSkipToThenItemByOffsetParser = <Offset, Item>({
 	isoOffset: Iso<Offset, number>;
 	parserName: string;
 }): Parser<Map<Offset, Item>, Uint8Array> => {
-	const skipToThenItemByOffsetParser: Parser<Map<Offset, Item>, Uint8Array> = async (parserContext) => {
+	const skipToThenItemByOffsetParser: Parser<Map<Offset, Item>, Uint8Array> = async parserContext => {
 		const itemByOffset = new Map<Offset, Item>();
 
 		if (size === 0) {
@@ -338,54 +389,62 @@ const createSkipToThenMethodIdItemsParser = ({ size, offset }: SizeOffset): Pars
 		)
 );
 
+const parseAccessFlagsCommon = (flags: number): DalvikExecutableAccessFlags => ({
+	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: number): DalvikExecutableAccessFlags => parseAccessFlagsCommon(flags);
+
+const parseFieldAccessFlags = (flags: number): DalvikExecutableAccessFlags => ({
+	...parseAccessFlagsCommon(flags),
+	volatile: Boolean(flags & 0b0100_0000),
+	varargs: false, // Varargs is only for methods, not fields
+	bridge: false,
+});
+
+const parseMethodAccessFlags = (flags: number): DalvikExecutableAccessFlags => ({
+	...parseAccessFlagsCommon(flags),
+	volatile: false,
+	transient: false, // Transient is only for fields, not methods
+	bridge: Boolean(flags & 0b0100_0000),
+});
+
 const uintAccessFlagsParser: Parser<DalvikExecutableAccessFlags, Uint8Array> = 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,
-	}),
+	parseAccessFlags,
 );
 
 const uleb128AccessFlagsParser: Parser<DalvikExecutableAccessFlags, Uint8Array> = 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),
-	}),
+	parseAccessFlags,
+);
+
+const uleb128FieldAccessFlagsParser: Parser<DalvikExecutableAccessFlags, Uint8Array> = promiseCompose(
+	uleb128NumberParser,
+	parseFieldAccessFlags,
+);
+
+const uleb128MethodAccessFlagsParser: Parser<DalvikExecutableAccessFlags, Uint8Array> = promiseCompose(
+	uleb128NumberParser,
+	parseMethodAccessFlags,
 );
 
 type DalvikExecutableClassDefinitionItem = {
@@ -399,7 +458,7 @@ type DalvikExecutableClassDefinitionItem = {
 	staticValuesOffset: OffsetToEncodedArrayItem;
 };
 
-const DEX_CLASS_DEFINITION_ITEM_SOURCE_FILE_NO_INDEX = 0xffffffff;
+const DEX_CLASS_DEFINITION_ITEM_SOURCE_FILE_NO_INDEX = 0xFF_FF_FF_FF;
 
 const createSkipToThenClassDefinitionItemsParser = ({ size, offset }: SizeOffset): Parser<DalvikExecutableClassDefinitionItem[], Uint8Array> => (
 	size === 0
@@ -470,9 +529,7 @@ type DalvikExecutableStringDataItem = {
 const stringDataItemParser: Parser<DalvikExecutableStringDataItem, Uint8Array> = promiseCompose(
 	createTupleParser([
 		uleb128NumberParser,
-		createElementTerminatedSequenceParser(
-			0,
-		),
+		createElementTerminatedSequenceParser(0),
 	]),
 	([ utf16Size, data ]) => ({
 		utf16Size,
@@ -506,7 +563,7 @@ type DalvikExecutableTypeItem = IndexIntoTypeIds;
 
 const dalvikExecutableTypeItemParser: Parser<DalvikExecutableTypeItem, Uint8Array> = promiseCompose(
 	cloneParser(ushortParser),
-	(index) => isoIndexIntoTypeIds.wrap(index),
+	index => isoIndexIntoTypeIds.wrap(index),
 );
 
 type DalvikExecutableTypeList = TypedNumberArray<IndexIntoTypeIds, DalvikExecutableTypeItem>;
@@ -523,7 +580,7 @@ const dalvikExecutableTypeListParser: Parser<DalvikExecutableTypeList, Uint8Arra
 			dalvikExecutableTypeItemParser,
 			size,
 		),
-		(typeItems) => isoDalvikExecutableTypeList.wrap(typeItems),
+		typeItems => isoDalvikExecutableTypeList.wrap(typeItems),
 	),
 )();
 
@@ -669,7 +726,7 @@ type DalvikExecutableEncodedFieldDiff = {
 const encodedFieldParser: Parser<DalvikExecutableEncodedFieldDiff, Uint8Array> = promiseCompose(
 	createTupleParser([
 		uleb128NumberParser,
-		uleb128AccessFlagsParser,
+		uleb128FieldAccessFlagsParser,
 	]),
 	([ fieldIndexDiff, accessFlags ]) => ({ fieldIndexDiff, accessFlags }),
 );
@@ -684,7 +741,7 @@ const createEncodedFieldsParser = (fieldsSize: number): Parser<DalvikExecutableE
 		encodedFieldParser,
 		fieldsSize,
 	),
-	(encodedFields) => {
+	encodedFields => {
 		let previousFieldIndex = 0;
 		return encodedFields.map(({ fieldIndexDiff, accessFlags }) => {
 			previousFieldIndex += fieldIndexDiff;
@@ -705,7 +762,7 @@ type DalvikExecutableEncodedMethodDiff = {
 const encodedMethodParser: Parser<DalvikExecutableEncodedMethodDiff, Uint8Array> = promiseCompose(
 	createTupleParser([
 		uleb128NumberParser,
-		uleb128AccessFlagsParser,
+		uleb128MethodAccessFlagsParser,
 		uleb128NumberParser,
 	]),
 	([
@@ -730,7 +787,7 @@ const createEncodedMethodsParser = (methodsSize: number): Parser<DalvikExecutabl
 		encodedMethodParser,
 		methodsSize,
 	),
-	(encodedMethods) => {
+	encodedMethods => {
 		let previousMethodIndex = 0;
 		return encodedMethods.map(({ methodIndexDiff, accessFlags, codeOffset }) => {
 			previousMethodIndex += methodIndexDiff;
@@ -744,10 +801,10 @@ const createEncodedMethodsParser = (methodsSize: number): Parser<DalvikExecutabl
 );
 
 type DalvikExecutableClassDataItem = {
-	staticFields: DalvikExecutableEncodedField[],
-	instanceFields: DalvikExecutableEncodedField[],
-	directMethods: DalvikExecutableEncodedMethod[],
-	virtualMethods: DalvikExecutableEncodedMethod[],
+	staticFields: DalvikExecutableEncodedField[];
+	instanceFields: DalvikExecutableEncodedField[];
+	directMethods: DalvikExecutableEncodedMethod[];
+	virtualMethods: DalvikExecutableEncodedMethod[];
 };
 
 const classDataItemParser: Parser<DalvikExecutableClassDataItem, Uint8Array> = parserCreatorCompose(
@@ -793,11 +850,33 @@ const createSkipToThenClassDataItemsParser = (sizeOffset: SizeOffset): Parser<Da
 	parserName: 'skipToThenClassDataItemsParser',
 });
 
+// Internal type for encoded values with type tags during parsing
+type DalvikExecutableTaggedEncodedValue =
+	| { type: 'byte'; value: number }
+	| { type: 'short'; value: number }
+	| { type: 'char'; value: number }
+	| { type: 'int'; value: number }
+	| { type: 'long'; value: bigint }
+	| { type: 'float'; value: number }
+	| { type: 'double'; value: number }
+	| { type: 'methodType'; value: IndexIntoPrototypeIds }
+	| { type: 'methodHandle'; value: number }
+	| { type: 'string'; value: IndexIntoStringIds }
+	| { type: 'type'; value: IndexIntoTypeIds }
+	| { type: 'field'; value: IndexIntoFieldIds }
+	| { type: 'method'; value: IndexIntoMethodIds }
+	| { type: 'enum'; value: IndexIntoFieldIds }
+	| { type: 'array'; value: DalvikExecutableTaggedEncodedValue[] }
+	| { type: 'annotation'; value: DalvikExecutableEncodedAnnotation }
+	// eslint-disable-next-line @typescript-eslint/no-restricted-types
+	| { type: 'null'; value: null }
+	| { type: 'boolean'; value: boolean };
+
 const createByteWith5LeastSignificantBitsEqualParser = (leastSignificant5: number): Parser<number, Uint8Array> => {
-	const byteWith5LeastSignificantBitsEqualParser: Parser<number, Uint8Array> = async (parserContext) => {
+	const byteWith5LeastSignificantBitsEqualParser: Parser<number, Uint8Array> = async parserContext => {
 		const byte = await parserContext.read(0);
 		parserContext.invariant(
-			(byte & 0b00011111) === leastSignificant5,
+			(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'),
@@ -812,20 +891,20 @@ const createByteWith5LeastSignificantBitsEqualParser = (leastSignificant5: numbe
 
 const createEncodedValueArgParser = (valueType: number): Parser<number, Uint8Array> => promiseCompose(
 	createByteWith5LeastSignificantBitsEqualParser(valueType),
-	(byte) => byte >> 5,
+	byte => byte >> 5,
 );
 
-const encodedValueByteParser: Parser<number, Uint8Array> = promiseCompose(
+const encodedValueByteParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = promiseCompose(
 	createTupleParser([
 		createExactElementParser(0),
-		ubyteParser,
+		byteParser,
 	]),
-	([ _, value ]) => value,
+	([ _, value ]) => ({ type: 'byte' as const, value }),
 );
 
 setParserName(encodedValueByteParser, 'encodedValueByteParser');
 
-const encodedValueShortParser: Parser<number, Uint8Array> = parserCreatorCompose(
+const encodedValueShortParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x02),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -833,9 +912,9 @@ const encodedValueShortParser: Parser<number, Uint8Array> = parserCreatorCompose
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readInt8(0);
+					return { type: 'short' as const, value: buffer.readInt8(0) };
 				},
 			);
 		}
@@ -844,9 +923,9 @@ const encodedValueShortParser: Parser<number, Uint8Array> = parserCreatorCompose
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readInt16LE(0);
+				return { type: 'short' as const, value: buffer.readInt16LE(0) };
 			},
 		);
 	},
@@ -854,7 +933,7 @@ const encodedValueShortParser: Parser<number, Uint8Array> = parserCreatorCompose
 
 setParserName(encodedValueShortParser, 'encodedValueShortParser');
 
-const encodedValueCharParser: Parser<number, Uint8Array> = parserCreatorCompose(
+const encodedValueCharParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x03),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -862,9 +941,9 @@ const encodedValueCharParser: Parser<number, Uint8Array> = parserCreatorCompose(
 		if (size == 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
-					const buffer = Buffer.from([ 0, ...uint8Array ]);
-					return buffer.readUInt16LE(0);
+				uint8Array => {
+					const buffer = Buffer.from([ ...uint8Array, 0 ]);
+					return { type: 'char' as const, value: buffer.readUInt16LE(0) };
 				},
 			);
 		}
@@ -873,9 +952,9 @@ const encodedValueCharParser: Parser<number, Uint8Array> = parserCreatorCompose(
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readUInt16LE(0);
+				return { type: 'char' as const, value: buffer.readUInt16LE(0) };
 			},
 		);
 	},
@@ -883,7 +962,7 @@ const encodedValueCharParser: Parser<number, Uint8Array> = parserCreatorCompose(
 
 setParserName(encodedValueCharParser, 'encodedValueCharParser');
 
-const encodedValueIntParser: Parser<number, Uint8Array> = parserCreatorCompose(
+const encodedValueIntParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x04),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -891,9 +970,9 @@ const encodedValueIntParser: Parser<number, Uint8Array> = parserCreatorCompose(
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readInt8(0);
+					return { type: 'int' as const, value: buffer.readInt8(0) };
 				},
 			);
 		}
@@ -901,9 +980,9 @@ const encodedValueIntParser: Parser<number, Uint8Array> = parserCreatorCompose(
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readInt16LE(0);
+					return { type: 'int' as const, value: buffer.readInt16LE(0) };
 				},
 			);
 		}
@@ -911,13 +990,13 @@ const encodedValueIntParser: Parser<number, Uint8Array> = parserCreatorCompose(
 		if (size === 3) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
-					const firstByte = uint8Array[0];
-					const firstBit = (firstByte & 0b10000000) >> 7;
-					const extensionByte = firstBit === 1 ? 0xff : 0x00;
+				uint8Array => {
+					const lastByte = uint8Array[uint8Array.length - 1];
+					const signBit = (lastByte & 0b1000_0000) >> 7;
+					const extensionByte = signBit === 1 ? 0xFF : 0x00;
 
-					const buffer = Buffer.from([ extensionByte, ...uint8Array ]);
-					return buffer.readInt32LE(0);
+					const buffer = Buffer.from([ ...uint8Array, extensionByte ]);
+					return { type: 'int' as const, value: buffer.readInt32LE(0) };
 				},
 			);
 		}
@@ -926,9 +1005,9 @@ const encodedValueIntParser: Parser<number, Uint8Array> = parserCreatorCompose(
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readInt32LE(0);
+				return { type: 'int' as const, value: buffer.readInt32LE(0) };
 			},
 		);
 	},
@@ -936,7 +1015,7 @@ const encodedValueIntParser: Parser<number, Uint8Array> = parserCreatorCompose(
 
 setParserName(encodedValueIntParser, 'encodedValueIntParser');
 
-const encodedValueLongParser: Parser<bigint, Uint8Array> = parserCreatorCompose(
+const encodedValueLongParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x06),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -944,9 +1023,9 @@ const encodedValueLongParser: Parser<bigint, Uint8Array> = parserCreatorCompose(
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return BigInt(buffer.readInt8(0));
+					return { type: 'long' as const, value: BigInt(buffer.readInt8(0)) };
 				},
 			);
 		}
@@ -954,9 +1033,9 @@ const encodedValueLongParser: Parser<bigint, Uint8Array> = parserCreatorCompose(
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return BigInt(buffer.readInt16LE(0));
+					return { type: 'long' as const, value: BigInt(buffer.readInt16LE(0)) };
 				},
 			);
 		}
@@ -964,13 +1043,13 @@ const encodedValueLongParser: Parser<bigint, Uint8Array> = parserCreatorCompose(
 		if (size === 3) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
-					const firstByte = uint8Array[0];
-					const firstBit = (firstByte & 0b10000000) >> 7;
-					const extensionByte = firstBit === 1 ? 0xff : 0x00;
+				uint8Array => {
+					const lastByte = uint8Array[size - 1];
+					const firstBit = (lastByte & 0b1000_0000) >> 7;
+					const extensionByte = firstBit === 1 ? 0xFF : 0x00;
 
-					const buffer = Buffer.from([ extensionByte, ...uint8Array ]);
-					return BigInt(buffer.readInt32LE(0));
+					const buffer = Buffer.from([ ...uint8Array, extensionByte ]);
+					return { type: 'long' as const, value: BigInt(buffer.readInt32LE(0)) };
 				},
 			);
 		}
@@ -978,9 +1057,9 @@ const encodedValueLongParser: Parser<bigint, Uint8Array> = parserCreatorCompose(
 		if (size === 4) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return BigInt(buffer.readInt32LE(0));
+					return { type: 'long' as const, value: BigInt(buffer.readInt32LE(0)) };
 				},
 			);
 		}
@@ -988,13 +1067,41 @@ const encodedValueLongParser: Parser<bigint, Uint8Array> = parserCreatorCompose(
 		if (size === 5) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
-					const firstByte = uint8Array[0];
-					const firstBit = (firstByte & 0b10000000) >> 7;
-					const extensionByte = firstBit === 1 ? 0xff : 0x00;
+				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' as const, 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([ extensionByte, extensionByte, extensionByte, ...uint8Array ]);
-					return BigInt(buffer.readBigInt64LE(0));
+					const buffer = Buffer.from([ ...uint8Array, extensionByte, extensionByte ]);
+					return { type: 'long' as const, 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' as const, value: BigInt(buffer.readBigInt64LE(0)) };
 				},
 			);
 		}
@@ -1003,9 +1110,9 @@ const encodedValueLongParser: Parser<bigint, Uint8Array> = parserCreatorCompose(
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readBigInt64LE(0);
+				return { type: 'long' as const, value: buffer.readBigInt64LE(0) };
 			},
 		);
 	},
@@ -1013,7 +1120,7 @@ const encodedValueLongParser: Parser<bigint, Uint8Array> = parserCreatorCompose(
 
 setParserName(encodedValueLongParser, 'encodedValueLongParser');
 
-const encodedValueFloatParser: Parser<number, Uint8Array> = parserCreatorCompose(
+const encodedValueFloatParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x10),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -1021,9 +1128,9 @@ const encodedValueFloatParser: Parser<number, Uint8Array> = parserCreatorCompose
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
-					const buffer = Buffer.from([ ...uint8Array, 0, 0, 0 ]);
-					return buffer.readFloatLE(0);
+				uint8Array => {
+					const buffer = Buffer.from([ 0, 0, 0, ...uint8Array ]);
+					return { type: 'float' as const, value: buffer.readFloatLE(0) };
 				},
 			);
 		}
@@ -1031,9 +1138,19 @@ const encodedValueFloatParser: Parser<number, Uint8Array> = parserCreatorCompose
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
-					const buffer = Buffer.from([ ...uint8Array, 0, 0 ]);
-					return buffer.readFloatLE(0);
+				uint8Array => {
+					const buffer = Buffer.from([ 0, 0, ...uint8Array ]);
+					return { type: 'float' as const, value: buffer.readFloatLE(0) };
+				},
+			);
+		}
+
+		if (size === 3) {
+			return promiseCompose(
+				createFixedLengthSequenceParser(size),
+				uint8Array => {
+					const buffer = Buffer.from([ 0, ...uint8Array ]);
+					return { type: 'float' as const, value: buffer.readFloatLE(0) };
 				},
 			);
 		}
@@ -1042,9 +1159,9 @@ const encodedValueFloatParser: Parser<number, Uint8Array> = parserCreatorCompose
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readFloatLE(0);
+				return { type: 'float' as const, value: buffer.readFloatLE(0) };
 			},
 		);
 	},
@@ -1052,7 +1169,7 @@ const encodedValueFloatParser: Parser<number, Uint8Array> = parserCreatorCompose
 
 setParserName(encodedValueFloatParser, 'encodedValueFloatParser');
 
-const encodedValueDoubleParser: Parser<number, Uint8Array> = parserCreatorCompose(
+const encodedValueDoubleParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x11),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -1060,9 +1177,9 @@ const encodedValueDoubleParser: Parser<number, Uint8Array> = parserCreatorCompos
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
-					const buffer = Buffer.from([ ...uint8Array, 0, 0, 0, 0, 0, 0, 0 ]);
-					return buffer.readDoubleLE(0);
+				uint8Array => {
+					const buffer = Buffer.from([ 0, 0, 0, 0, 0, 0, 0, ...uint8Array ]);
+					return { type: 'double' as const, value: buffer.readDoubleLE(0) };
 				},
 			);
 		}
@@ -1070,9 +1187,19 @@ const encodedValueDoubleParser: Parser<number, Uint8Array> = parserCreatorCompos
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
-					const buffer = Buffer.from([ ...uint8Array, 0, 0, 0, 0, 0, 0 ]);
-					return buffer.readDoubleLE(0);
+				uint8Array => {
+					const buffer = Buffer.from([ 0, 0, 0, 0, 0, 0, ...uint8Array ]);
+					return { type: 'double' as const, 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' as const, value: buffer.readDoubleLE(0) };
 				},
 			);
 		}
@@ -1080,9 +1207,39 @@ const encodedValueDoubleParser: Parser<number, Uint8Array> = parserCreatorCompos
 		if (size === 4) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
-					const buffer = Buffer.from([ ...uint8Array, 0, 0, 0, 0 ]);
-					return buffer.readDoubleLE(0);
+				uint8Array => {
+					const buffer = Buffer.from([ 0, 0, 0, 0, ...uint8Array ]);
+					return { type: 'double' as const, value: buffer.readDoubleLE(0) };
+				},
+			);
+		}
+
+		if (size === 5) {
+			return promiseCompose(
+				createFixedLengthSequenceParser(size),
+				uint8Array => {
+					const buffer = Buffer.from([ 0, 0, 0, ...uint8Array ]);
+					return { type: 'double' as const, value: buffer.readDoubleLE(0) };
+				},
+			);
+		}
+
+		if (size === 6) {
+			return promiseCompose(
+				createFixedLengthSequenceParser(size),
+				uint8Array => {
+					const buffer = Buffer.from([ 0, 0, ...uint8Array ]);
+					return { type: 'double' as const, value: buffer.readDoubleLE(0) };
+				},
+			);
+		}
+
+		if (size === 7) {
+			return promiseCompose(
+				createFixedLengthSequenceParser(size),
+				uint8Array => {
+					const buffer = Buffer.from([ 0, ...uint8Array ]);
+					return { type: 'double' as const, value: buffer.readDoubleLE(0) };
 				},
 			);
 		}
@@ -1091,9 +1248,9 @@ const encodedValueDoubleParser: Parser<number, Uint8Array> = parserCreatorCompos
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readDoubleLE(0);
+				return { type: 'double' as const, value: buffer.readDoubleLE(0) };
 			},
 		);
 	},
@@ -1101,7 +1258,7 @@ const encodedValueDoubleParser: Parser<number, Uint8Array> = parserCreatorCompos
 
 setParserName(encodedValueDoubleParser, 'encodedValueDoubleParser');
 
-const encodedValueMethodTypeParser: Parser<number, Uint8Array> = parserCreatorCompose(
+const encodedValueMethodTypeParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x15),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -1109,9 +1266,9 @@ const encodedValueMethodTypeParser: Parser<number, Uint8Array> = parserCreatorCo
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUint8(0);
+					return { type: 'methodType' as const, value: isoIndexIntoPrototypeIds.wrap(buffer.readUint8(0)) };
 				},
 			);
 		}
@@ -1119,9 +1276,9 @@ const encodedValueMethodTypeParser: Parser<number, Uint8Array> = parserCreatorCo
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt16LE(0);
+					return { type: 'methodType' as const, value: isoIndexIntoPrototypeIds.wrap(buffer.readUInt16LE(0)) };
 				},
 			);
 		}
@@ -1130,9 +1287,9 @@ const encodedValueMethodTypeParser: Parser<number, Uint8Array> = parserCreatorCo
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readUInt32LE(0);
+				return { type: 'methodType' as const, value: isoIndexIntoPrototypeIds.wrap(buffer.readUInt32LE(0)) };
 			},
 		);
 	},
@@ -1140,7 +1297,7 @@ const encodedValueMethodTypeParser: Parser<number, Uint8Array> = parserCreatorCo
 
 setParserName(encodedValueMethodTypeParser, 'encodedValueMethodTypeParser');
 
-const encodedValueMethodHandleParser: Parser<number, Uint8Array> = parserCreatorCompose(
+const encodedValueMethodHandleParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x16),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -1148,9 +1305,9 @@ const encodedValueMethodHandleParser: Parser<number, Uint8Array> = parserCreator
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt8(0);
+					return { type: 'methodHandle' as const, value: buffer.readUInt8(0) };
 				},
 			);
 		}
@@ -1158,9 +1315,9 @@ const encodedValueMethodHandleParser: Parser<number, Uint8Array> = parserCreator
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt16LE(0);
+					return { type: 'methodHandle' as const, value: buffer.readUInt16LE(0) };
 				},
 			);
 		}
@@ -1169,9 +1326,9 @@ const encodedValueMethodHandleParser: Parser<number, Uint8Array> = parserCreator
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readUInt32LE(0);
+				return { type: 'methodHandle' as const, value: buffer.readUInt32LE(0) };
 			},
 		);
 	},
@@ -1179,7 +1336,7 @@ const encodedValueMethodHandleParser: Parser<number, Uint8Array> = parserCreator
 
 setParserName(encodedValueMethodHandleParser, 'encodedValueMethodHandleParser');
 
-const encodedValueStringParser: Parser<number, Uint8Array> = parserCreatorCompose(
+const encodedValueStringParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x17),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -1187,9 +1344,9 @@ const encodedValueStringParser: Parser<number, Uint8Array> = parserCreatorCompos
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt8(0);
+					return { type: 'string' as const, value: isoIndexIntoStringIds.wrap(buffer.readUInt8(0)) };
 				},
 			);
 		}
@@ -1197,9 +1354,9 @@ const encodedValueStringParser: Parser<number, Uint8Array> = parserCreatorCompos
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt16LE(0);
+					return { type: 'string' as const, value: isoIndexIntoStringIds.wrap(buffer.readUInt16LE(0)) };
 				},
 			);
 		}
@@ -1208,9 +1365,9 @@ const encodedValueStringParser: Parser<number, Uint8Array> = parserCreatorCompos
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readUInt32LE(0);
+				return { type: 'string' as const, value: isoIndexIntoStringIds.wrap(buffer.readUInt32LE(0)) };
 			},
 		);
 	},
@@ -1218,7 +1375,7 @@ const encodedValueStringParser: Parser<number, Uint8Array> = parserCreatorCompos
 
 setParserName(encodedValueStringParser, 'encodedValueStringParser');
 
-const encodedValueTypeParser: Parser<number, Uint8Array> = parserCreatorCompose(
+const encodedValueTypeParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x18),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -1226,9 +1383,9 @@ const encodedValueTypeParser: Parser<number, Uint8Array> = parserCreatorCompose(
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt8(0);
+					return { type: 'type' as const, value: isoIndexIntoTypeIds.wrap(buffer.readUInt8(0)) };
 				},
 			);
 		}
@@ -1236,9 +1393,9 @@ const encodedValueTypeParser: Parser<number, Uint8Array> = parserCreatorCompose(
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt16LE(0);
+					return { type: 'type' as const, value: isoIndexIntoTypeIds.wrap(buffer.readUInt16LE(0)) };
 				},
 			);
 		}
@@ -1247,9 +1404,9 @@ const encodedValueTypeParser: Parser<number, Uint8Array> = parserCreatorCompose(
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readUInt32LE(0);
+				return { type: 'type' as const, value: isoIndexIntoTypeIds.wrap(buffer.readUInt32LE(0)) };
 			},
 		);
 	},
@@ -1257,7 +1414,7 @@ const encodedValueTypeParser: Parser<number, Uint8Array> = parserCreatorCompose(
 
 setParserName(encodedValueTypeParser, 'encodedValueTypeParser');
 
-const encodedValueFieldParser: Parser<number, Uint8Array> = parserCreatorCompose(
+const encodedValueFieldParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
 	() => createEncodedValueArgParser(0x19),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
@@ -1265,9 +1422,9 @@ const encodedValueFieldParser: Parser<number, Uint8Array> = parserCreatorCompose
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt8(0);
+					return { type: 'field' as const, value: isoIndexIntoFieldIds.wrap(buffer.readUInt8(0)) };
 				},
 			);
 		}
@@ -1275,9 +1432,9 @@ const encodedValueFieldParser: Parser<number, Uint8Array> = parserCreatorCompose
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt16LE(0);
+					return { type: 'field' as const, value: isoIndexIntoFieldIds.wrap(buffer.readUInt16LE(0)) };
 				},
 			);
 		}
@@ -1286,9 +1443,9 @@ const encodedValueFieldParser: Parser<number, Uint8Array> = parserCreatorCompose
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readUInt32LE(0);
+				return { type: 'field' as const, value: isoIndexIntoFieldIds.wrap(buffer.readUInt32LE(0)) };
 			},
 		);
 	},
@@ -1296,17 +1453,17 @@ const encodedValueFieldParser: Parser<number, Uint8Array> = parserCreatorCompose
 
 setParserName(encodedValueFieldParser, 'encodedValueFieldParser');
 
-const encodedValueMethodParser: Parser<number, Uint8Array> = parserCreatorCompose(
-	() => createEncodedValueArgParser(0x1a),
+const encodedValueMethodParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
+	() => createEncodedValueArgParser(0x1A),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
 
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt8(0);
+					return { type: 'method' as const, value: isoIndexIntoMethodIds.wrap(buffer.readUInt8(0)) };
 				},
 			);
 		}
@@ -1314,9 +1471,9 @@ const encodedValueMethodParser: Parser<number, Uint8Array> = parserCreatorCompos
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt16LE(0);
+					return { type: 'method' as const, value: isoIndexIntoMethodIds.wrap(buffer.readUInt16LE(0)) };
 				},
 			);
 		}
@@ -1325,9 +1482,9 @@ const encodedValueMethodParser: Parser<number, Uint8Array> = parserCreatorCompos
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readUInt32LE(0);
+				return { type: 'method' as const, value: isoIndexIntoMethodIds.wrap(buffer.readUInt32LE(0)) };
 			},
 		);
 	},
@@ -1335,17 +1492,17 @@ const encodedValueMethodParser: Parser<number, Uint8Array> = parserCreatorCompos
 
 setParserName(encodedValueMethodParser, 'encodedValueMethodParser');
 
-const encodedValueEnumParser: Parser<number, Uint8Array> = parserCreatorCompose(
-	() => createEncodedValueArgParser(0x1b),
+const encodedValueEnumParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
+	() => createEncodedValueArgParser(0x1B),
 	sizeSubOne => {
 		const size = sizeSubOne + 1;
 
 		if (size === 1) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt8(0);
+					return { type: 'enum' as const, value: isoIndexIntoFieldIds.wrap(buffer.readUInt8(0)) };
 				},
 			);
 		}
@@ -1353,9 +1510,9 @@ const encodedValueEnumParser: Parser<number, Uint8Array> = parserCreatorCompose(
 		if (size === 2) {
 			return promiseCompose(
 				createFixedLengthSequenceParser(size),
-				(uint8Array) => {
+				uint8Array => {
 					const buffer = Buffer.from(uint8Array);
-					return buffer.readUInt16LE(0);
+					return { type: 'enum' as const, value: isoIndexIntoFieldIds.wrap(buffer.readUInt16LE(0)) };
 				},
 			);
 		}
@@ -1364,9 +1521,9 @@ const encodedValueEnumParser: Parser<number, Uint8Array> = parserCreatorCompose(
 
 		return promiseCompose(
 			createFixedLengthSequenceParser(size),
-			(uint8Array) => {
+			uint8Array => {
 				const buffer = Buffer.from(uint8Array);
-				return buffer.readUInt32LE(0);
+				return { type: 'enum' as const, value: isoIndexIntoFieldIds.wrap(buffer.readUInt32LE(0)) };
 			},
 		);
 	},
@@ -1374,11 +1531,11 @@ const encodedValueEnumParser: Parser<number, Uint8Array> = parserCreatorCompose(
 
 setParserName(encodedValueEnumParser, 'encodedValueEnumParser');
 
-type DalvikExecutableEncodedArray = DalvikExecutableEncodedValue[];
+type DalvikExecutableEncodedArray = DalvikExecutableTaggedEncodedValue[];
 
-const encodedArrayParser: Parser<DalvikExecutableEncodedArray, Uint8Array> = parserCreatorCompose(
+const encodedArrayParser: Parser<DalvikExecutableTaggedEncodedValue[], Uint8Array> = parserCreatorCompose(
 	() => uleb128NumberParser,
-	(size) => createQuantifierParser(
+	size => createQuantifierParser(
 		encodedValueParser,
 		size,
 	),
@@ -1386,24 +1543,24 @@ const encodedArrayParser: Parser<DalvikExecutableEncodedArray, Uint8Array> = par
 
 setParserName(encodedArrayParser, 'encodedArrayParser');
 
-const encodedValueArrayParser: Parser<DalvikExecutableEncodedValue[], Uint8Array> = promiseCompose(
+const encodedValueArrayParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = promiseCompose(
 	createTupleParser([
 		parserCreatorCompose(
-			() => createEncodedValueArgParser(0x1c),
+			() => createEncodedValueArgParser(0x1C),
 			valueArg => parserContext => {
 				parserContext.invariant(valueArg === 0, '(encodedValueArrayParser) valueArg: %s', valueArg);
 			},
 		)(),
 		encodedArrayParser,
 	]),
-	([ _, array ]) => array,
+	([ _, array ]) => ({ type: 'array' as const, value: array }),
 );
 
 setParserName(encodedValueArrayParser, 'encodedValueArrayParser');
 
 type DalvikExecutableAnnotationElement = {
 	nameIndex: IndexIntoStringIds;
-	value: DalvikExecutableEncodedValue;
+	value: DalvikExecutableTaggedEncodedValue;
 };
 
 type DalvikExecutableEncodedAnnotation = {
@@ -1455,39 +1612,39 @@ const encodedAnnotationParser: Parser<DalvikExecutableEncodedAnnotation, Uint8Ar
 
 setParserName(encodedAnnotationParser, 'encodedAnnotationParser');
 
-const encodedValueAnnotationParser: Parser<DalvikExecutableEncodedAnnotation, Uint8Array> = promiseCompose(
+const encodedValueAnnotationParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = promiseCompose(
 	createTupleParser([
 		parserCreatorCompose(
-			() => createEncodedValueArgParser(0x1d),
+			() => createEncodedValueArgParser(0x1D),
 			valueArg => parserContext => {
 				parserContext.invariant(valueArg === 0, '(encodedValueAnnotationParser) valueArg: %s', valueArg);
 			},
 		)(),
 		encodedAnnotationParser,
 	]),
-	([ _, annotation ]) => annotation,
+	([ _, annotation ]) => ({ type: 'annotation' as const, value: annotation }),
 );
 
 setParserName(encodedValueAnnotationParser, 'encodedValueAnnotationParser');
 
-const encodedValueNullParser: Parser<null, Uint8Array> = parserCreatorCompose(
-	() => createEncodedValueArgParser(0x1e),
+const encodedValueNullParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = parserCreatorCompose(
+	() => createEncodedValueArgParser(0x1E),
 	valueArg => parserContext => {
 		parserContext.invariant(valueArg === 0, '(encodedValueNullParser) valueArg: %s', valueArg);
-		return null;
+		return ({ type: 'null' as const, value: null });
 	},
 )();
 
 setParserName(encodedValueNullParser, 'encodedValueNullParser');
 
-const encodedValueBooleanParser: Parser<boolean, Uint8Array> = promiseCompose(
-	createEncodedValueArgParser(0x1f),
-	(value) => Boolean(value),
+const encodedValueBooleanParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = promiseCompose(
+	createEncodedValueArgParser(0x1F),
+	valueArg => ({ type: 'boolean' as const, value: Boolean(valueArg) }),
 );
 
 setParserName(encodedValueBooleanParser, 'encodedValueBooleanParser');
 
-const encodedValueParser: Parser<DalvikExecutableEncodedValue, Uint8Array> = createDisjunctionParser([
+const encodedValueParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = createDisjunctionParser([
 	encodedValueByteParser,
 	encodedValueShortParser,
 	encodedValueCharParser,
@@ -1555,8 +1712,8 @@ const encodedTypeAddressPairParser: Parser<DalvikExecutableEncodedTypeAddressPai
 );
 
 type DalvikExecutableEncodedCatchHandler_ = {
-	handlers: DalvikExecutableEncodedTypeAddressPair_[],
-	catchAllAddress: undefined | number,
+	handlers: DalvikExecutableEncodedTypeAddressPair_[];
+	catchAllAddress: undefined | number;
 };
 
 const encodedCatchHandlerParser: Parser<DalvikExecutableEncodedCatchHandler_, Uint8Array> = parserCreatorCompose(
@@ -1584,16 +1741,14 @@ setParserName(encodedCatchHandlerParser, 'encodedCatchHandlerParser');
 
 type DalvikExecutableEncodedCatchHandlerByRelativeOffset = Map<OffsetFromEncodedCatchHandlerListToEncodedCatchHandler, DalvikExecutableEncodedCatchHandler_>;
 
-const encodedCatchHandlerListParser: Parser<DalvikExecutableEncodedCatchHandlerByRelativeOffset, Uint8Array> = async (parserContext) => {
+const encodedCatchHandlerListParser: Parser<DalvikExecutableEncodedCatchHandlerByRelativeOffset, Uint8Array> = async parserContext => {
 	const listOffset = parserContext.position;
 	const handlers: DalvikExecutableEncodedCatchHandlerByRelativeOffset = new Map();
 
 	const size = await uleb128NumberParser(parserContext);
 
 	for (let i = 0; i < size; i += 1) {
-		const handlerRelativeOffset = isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler.wrap(
-			parserContext.position - listOffset,
-		);
+		const handlerRelativeOffset = isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler.wrap(parserContext.position - listOffset);
 		const handler = await encodedCatchHandlerParser(parserContext);
 
 		handlers.set(handlerRelativeOffset, handler);
@@ -1639,51 +1794,47 @@ const createDalvikExecutableCodeItemParser = <Instructions>({
 			triesSize,
 			debugInfoOffset,
 			instructionsSize,
-		]) => {
-			return promiseCompose(
-				createTupleParser([
-					createInstructionsParser(instructionsSize * 2),
-					(
-						(
-							triesSize !== 0
-								&& instructionsSize % 2 === 1
-						)
-							? byteAlign4Parser
-							: () => undefined
-					),
-					(
-						triesSize !== 0
-							? createQuantifierParser(
-								tryItemParser,
-								triesSize,
-							)
-							: () => []
-					),
+		]) => promiseCompose(
+			createTupleParser([
+				createInstructionsParser(instructionsSize * 2),
+				(
 					(
 						triesSize !== 0
-							? encodedCatchHandlerListParser
-							: () => new Map()
-					),
-				]),
-				([
-					instructions,
-					_padding,
-					tryItems,
-					handlers,
-				]) => {
-					return {
-						registersSize,
-						insSize,
-						outsSize,
-						triesSize,
-						debugInfoOffset: isoOffsetToDebugInfoItem.wrap(debugInfoOffset),
-						instructions,
-						tryItems,
-						handlers,
-					};
-				},
-			);
-		},
+						&& 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');
@@ -1721,15 +1872,15 @@ type DalvikExecutableDebugByteCodeValueItem =
 	| {
 		type: 'startLocal';
 		registerNum: number;
-		nameIndex: IndexIntoStringIds;
-		typeIndex: IndexIntoTypeIds;
+		nameIndex: undefined | IndexIntoStringIds;
+		typeIndex: undefined | IndexIntoTypeIds;
 	}
 	| {
 		type: 'startLocalExtended';
 		registerNum: number;
-		nameIndex: IndexIntoStringIds;
-		typeIndex: IndexIntoTypeIds;
-		signatureIndex: IndexIntoStringIds;
+		nameIndex: undefined | IndexIntoStringIds;
+		typeIndex: undefined | IndexIntoTypeIds;
+		signatureIndex: undefined | IndexIntoStringIds;
 	}
 	| {
 		type: 'endLocal';
@@ -1747,7 +1898,7 @@ type DalvikExecutableDebugByteCodeValueItem =
 	}
 	| {
 		type: 'setFile';
-		nameIndex: IndexIntoStringIds;
+		nameIndex: undefined | IndexIntoStringIds;
 	}
 	| {
 		type: 'special';
@@ -1759,62 +1910,81 @@ const dalvikExecutableDebugByteCodeValueParser: Parser<DalvikExecutableDebugByte
 	() => ubyteParser,
 	(value): Parser<DalvikExecutableDebugByteCodeValueItem, Uint8Array> => {
 		switch (value) {
-			case 0x01: return promiseCompose(
+			case 0x01: { return promiseCompose(
 				uleb128NumberParser,
-				(addressDiff) => ({ type: 'advancePc', addressDiff }),
+				addressDiff => ({ type: 'advancePc', addressDiff }),
 			);
-			case 0x02: return promiseCompose(
+			}
+
+			case 0x02: { return promiseCompose(
 				sleb128NumberParser,
-				(lineDiff) => ({ type: 'advanceLine', lineDiff }),
+				lineDiff => ({ type: 'advanceLine', lineDiff }),
 			);
-			case 0x03: return promiseCompose(
+			}
+
+			case 0x03: { return promiseCompose(
 				createTupleParser([
 					uleb128NumberParser,
-					uleb128NumberParser,
-					uleb128NumberParser,
+					uleb128p1NumberParser,
+					uleb128p1NumberParser,
 				]),
-				([ registerNum, nameIndex, typeIndex ]) => ({
+				([ registerNumber, nameIndex, typeIndex ]) => ({
 					type: 'startLocal',
-					registerNum,
-					nameIndex: isoIndexIntoStringIds.wrap(nameIndex),
-					typeIndex: isoIndexIntoTypeIds.wrap(typeIndex),
+					registerNum: registerNumber,
+					nameIndex: nameIndex === -1 ? undefined : isoIndexIntoStringIds.wrap(nameIndex),
+					typeIndex: typeIndex === -1 ? undefined : isoIndexIntoTypeIds.wrap(typeIndex),
 				}),
 			);
-			case 0x04: return promiseCompose(
+			}
+
+			case 0x04: { return promiseCompose(
 				createTupleParser([
 					uleb128NumberParser,
-					uleb128NumberParser,
-					uleb128NumberParser,
-					uleb128NumberParser,
+					uleb128p1NumberParser,
+					uleb128p1NumberParser,
+					uleb128p1NumberParser,
 				]),
-				([ registerNum, nameIndex, typeIndex, signatureIndex ]) => ({
+				([ registerNumber, nameIndex, typeIndex, signatureIndex ]) => ({
 					type: 'startLocalExtended',
-					registerNum,
-					nameIndex: isoIndexIntoStringIds.wrap(nameIndex),
-					typeIndex: isoIndexIntoTypeIds.wrap(typeIndex),
-					signatureIndex: isoIndexIntoStringIds.wrap(signatureIndex),
+					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(
+			}
+
+			case 0x05: { return promiseCompose(
 				uleb128NumberParser,
-				(registerNum) => ({ type: 'endLocal', registerNum }),
+				registerNumber => ({ type: 'endLocal', registerNum: registerNumber }),
 			);
-			case 0x06: return promiseCompose(
+			}
+
+			case 0x06: { return promiseCompose(
 				uleb128NumberParser,
-				(registerNum) => ({ type: 'restartLocal', registerNum }),
+				registerNumber => ({ type: 'restartLocal', registerNum: registerNumber }),
 			);
-			case 0x07: return () => ({ type: 'setPrologueEnd' });
-			case 0x08: return () => ({ type: 'setEpilogueBegin' });
-			case 0x09: return promiseCompose(
-				uleb128NumberParser,
-				(nameIndex) => ({ type: 'setFile', nameIndex: isoIndexIntoStringIds.wrap(nameIndex) }),
+			}
+
+			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);
+			}
+
+			default: { return parserContext => {
+				parserContext.invariant(value >= 0x0A, 'Unexpected special value: %s', value);
 				return { type: 'special', value };
 			};
+			}
 		}
-	}
+	},
 )();
 
 setParserName(dalvikExecutableDebugByteCodeValueParser, 'dalvikExecutableDebugByteCodeValueParser');
@@ -1830,7 +2000,7 @@ setParserName(debugByteCodeParser, 'debugByteCodeParser');
 
 type DalvikExecutableDebugInfoItem = {
 	lineStart: number;
-	parameterNames: (undefined | IndexIntoStringIds)[];
+	parameterNames: Array<undefined | IndexIntoStringIds>;
 	bytecode: DalvikExecutableDebugByteCodeItem;
 };
 
@@ -1880,12 +2050,19 @@ type DalvikExecutableAnnotationItemVisibility =
 
 const dalvikExecutableAnnotationItemVisibilityParser: Parser<DalvikExecutableAnnotationItemVisibility, Uint8Array> = promiseCompose(
 	ubyteParser,
-	(visibility) => {
+	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);
+			}
 		}
 	},
 );
@@ -1924,19 +2101,19 @@ type DalvikExecutableHeaderAndMap = {
 
 const dalvikExecutableHeaderAndMapParser: Parser<DalvikExecutableHeaderAndMap, Uint8Array> = parserCreatorCompose(
 	() => dalvikExecutableHeaderItemParser,
-	(headerItem) => promiseCompose(
+	headerItem => promiseCompose(
 		createLookaheadParser(createDalvikExecutableMapListParser(headerItem.mapOffset)),
-		(mapList) => ({ headerItem, mapList }),
+		mapList => ({ headerItem, mapList }),
 	),
 )();
 
 type DalvikExecutableAnnotationOffsetItem = {
 	annotationOffset: OffsetToAnnotationItem;
-}
+};
 
 const dalvikExecutableAnnotationOffsetItemParser: Parser<DalvikExecutableAnnotationOffsetItem, Uint8Array> = promiseCompose(
 	uintParser,
-	(annotationOffset) => ({
+	annotationOffset => ({
 		annotationOffset: isoOffsetToAnnotationItem.wrap(annotationOffset),
 	}),
 );
@@ -1955,7 +2132,7 @@ const dalvikExecutableAnnotationSetItemParser: Parser<DalvikExecutableAnnotation
 			dalvikExecutableAnnotationOffsetItemParser,
 			size,
 		),
-		(entries) => ({ entries }),
+		entries => ({ entries }),
 	),
 )();
 
@@ -1973,7 +2150,7 @@ type DalvikExecutableAnnotationSetRefItem = OffsetToAnnotationSetItem;
 
 const dalvikExecutableAnnotationSetRefItemParser: Parser<DalvikExecutableAnnotationSetRefItem, Uint8Array> = promiseCompose(
 	uintParser,
-	(annotationsOffset) => isoOffsetToAnnotationSetItem.wrap(annotationsOffset),
+	annotationsOffset => isoOffsetToAnnotationSetItem.wrap(annotationsOffset),
 );
 
 type DalvikExecutableAnnotationSetRefList = {
@@ -1990,7 +2167,7 @@ const dalvikExecutableAnnotationSetRefListParser: Parser<DalvikExecutableAnnotat
 			dalvikExecutableAnnotationSetRefItemParser,
 			size,
 		),
-		(list) => ({ list }),
+		list => ({ list }),
 	),
 )();
 
@@ -2030,30 +2207,73 @@ type DalvikExecutableMapItemType =
 
 const dalvikExecutableMapItemTypeParser: Parser<DalvikExecutableMapItemType, Uint8Array> = promiseCompose(
 	ushortParser,
-	(type) => {
+	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);
+			}
 		}
 	},
 );
@@ -2078,12 +2298,10 @@ type DalvikExecutableMapList = DalvikExecutableMapItem[];
 
 const dalvikExecutableMapListParser: Parser<DalvikExecutableMapList, Uint8Array> = parserCreatorCompose(
 	() => uintParser,
-	size => {
-		return createQuantifierParser(
-			dalvikExecutableMapItemParser,
-			size,
-		);
-	},
+	size => createQuantifierParser(
+		dalvikExecutableMapItemParser,
+		size,
+	),
 )();
 
 setParserName(dalvikExecutableMapListParser, 'dalvikExecutableMapListParser');
@@ -2142,6 +2360,7 @@ type DalvikExecutableData<Instructions> = {
 	encodedArrayItemByOffset: DalvikExecutableEncodedArrayItemByOffset;
 	annotationsDirectoryItemByOffset: DalvikExecutableAnnotationsDirectoryItemByOffset;
 	hiddenApiClassDataItems: DalvikExecutableHiddenApiClassDataItem[];
+	link: undefined | Uint8Array;
 };
 
 const createDalvikExecutableDataParser = <Instructions>({
@@ -2151,15 +2370,15 @@ const createDalvikExecutableDataParser = <Instructions>({
 }: DalvikExecutableHeaderAndMap & {
 	createInstructionsParser: CreateInstructionsParser<Instructions>;
 }): Parser<DalvikExecutableData<Instructions>, Uint8Array> => {
-	const dalvikExecutableDataParser: Parser<DalvikExecutableData<Instructions>, Uint8Array> = async (parserContext) => {
+	const dalvikExecutableDataParser: Parser<DalvikExecutableData<Instructions>, Uint8Array> = async parserContext => {
 		let stringIdItems: DalvikExecutableStringIdItems = isoDalvikExecutableStringIdItems.wrap([]);
 		let typeIdItems: DalvikExecutableTypeIdItems = isoDalvikExecutableTypeIdItems.wrap([]);
 		let prototypeIdItems: DalvikExecutablePrototypeIdItems = isoDalvikExecutablePrototypeIdItems.wrap([]);
 		let fieldIdItems: DalvikExecutableFieldIdItems = isoDalvikExecutableFieldIdItems.wrap([]);
 		let methodIdItems: DalvikExecutableMethodIdItems = isoDalvikExecutableMethodIdItems.wrap([]);
 		let classDefinitionItems: DalvikExecutableClassDefinitionItem[] = [];
-		let callSiteIdItems: DalvikExecutableCallSiteIdItem[] = [];
-		let methodHandleItems: DalvikExecutableMethodHandleItem[] = [];
+		const callSiteIdItems: DalvikExecutableCallSiteIdItem[] = [];
+		const methodHandleItems: DalvikExecutableMethodHandleItem[] = [];
 		let typeListByOffset: DalvikExecutableTypeListByOffset = new Map();
 		let annotationSetRefListItemByOffset: DalvikExecutableAnnotationSetRefListItemByOffset = new Map();
 		let annotationSetItemByOffset: DalvikExecutableAnnotationSetItemByOffset = new Map();
@@ -2170,9 +2389,19 @@ const createDalvikExecutableDataParser = <Instructions>({
 		let annotationItemByOffset: DalvikExecutableAnnotationItemByOffset = new Map();
 		let encodedArrayItemByOffset: DalvikExecutableEncodedArrayItemByOffset = new Map();
 		let annotationsDirectoryItemByOffset: DalvikExecutableAnnotationsDirectoryItemByOffset = new Map();
-		let hiddenApiClassDataItems: DalvikExecutableHiddenApiClassDataItem[] = [];
+		const hiddenApiClassDataItems: DalvikExecutableHiddenApiClassDataItem[] = [];
+		
+		// Track if link has been parsed
+		let link: undefined | Uint8Array = 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;
 			}
@@ -2216,6 +2445,7 @@ const createDalvikExecutableDataParser = <Instructions>({
 			}
 
 			if (dexMapItem.type === 'mapList') {
+				// Re-parse the map itself to consume it from the input
 				await createDalvikExecutableMapListParser(dexMapItem.offset)(parserContext);
 				continue;
 			}
@@ -2280,6 +2510,12 @@ const createDalvikExecutableDataParser = <Instructions>({
 			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,
@@ -2302,6 +2538,7 @@ const createDalvikExecutableDataParser = <Instructions>({
 			encodedArrayItemByOffset,
 			annotationsDirectoryItemByOffset,
 			hiddenApiClassDataItems,
+			link,
 		};
 	};
 
@@ -2320,41 +2557,36 @@ const createDalvikExecutableParser = <Instructions>({
 		headerItem,
 		mapList,
 	}) => promiseCompose(
-		createTupleParser([
-			createDalvikExecutableDataParser({
-				headerItem,
-				mapList,
-				createInstructionsParser,
-			}),
-			createRawDataParser(headerItem.link),
-		]),
-		async ([
-			{
-				headerItem: _headerItem,
-				stringIdItems,
-				typeIdItems,
-				prototypeIdItems,
-				fieldIdItems,
-				methodIdItems,
-				classDefinitionItems,
-				// callSiteIdItems,
-				// methodHandleItems,
-				mapList: _mapList,
-				typeListByOffset,
-				annotationSetRefListItemByOffset,
-				annotationSetItemByOffset,
-				classDataItemByOffset,
-				codeItemByOffset,
-				stringDataItemStringByOffset,
-				debugInfoItemByOffset,
-				annotationItemByOffset,
-				encodedArrayItemByOffset,
-				annotationsDirectoryItemByOffset,
-				// hiddenApiClassDataItems,
-			},
+		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) => {
+		}) => {
+			const strings = stringIdItems.map(stringId => {
 				const stringOffset = stringId;
 				const string = stringDataItemStringByOffset.get(stringOffset);
 				invariant(string !== undefined, 'String must be there. String offset: %s', stringOffset);
@@ -2362,7 +2594,7 @@ const createDalvikExecutableParser = <Instructions>({
 				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);
 
@@ -2374,7 +2606,7 @@ const createDalvikExecutableParser = <Instructions>({
 			]);
 
 			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);
 
@@ -2384,7 +2616,7 @@ const createDalvikExecutableParser = <Instructions>({
 				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);
 
@@ -2397,7 +2629,7 @@ const createDalvikExecutableParser = <Instructions>({
 				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);
 
@@ -2410,7 +2642,7 @@ const createDalvikExecutableParser = <Instructions>({
 				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);
 
@@ -2430,7 +2662,7 @@ const createDalvikExecutableParser = <Instructions>({
 			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;
 						}
@@ -2440,23 +2672,30 @@ const createDalvikExecutableParser = <Instructions>({
 
 						return string;
 					}),
-					bytecode: debugInfoItem.bytecode.map((value) => {
+					bytecode: debugInfoItem.bytecode.map(value => {
 						switch (value.type) {
-							case 'startLocal': return {
+							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 {
+							}
+
+							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 'setFile': { return { type: 'setFile', name: value.nameIndex === undefined ? undefined : strings.at(value.nameIndex) };
+							}
+
+							default: { return value;
+							}
 						}
 					}),
 				});
@@ -2473,15 +2712,14 @@ const createDalvikExecutableParser = <Instructions>({
 					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);
 
@@ -2490,6 +2728,7 @@ const createDalvikExecutableParser = <Instructions>({
 									address: encodedHandler.address,
 								};
 							}),
+							catchAllAddress: handler_.catchAllAddress,
 						};
 
 						return {
@@ -2508,28 +2747,28 @@ const createDalvikExecutableParser = <Instructions>({
 			const resolvers: DalvikBytecodeOperationResolvers = {
 				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;
 				},
@@ -2548,15 +2787,13 @@ const createDalvikExecutableParser = <Instructions>({
 
 				return {
 					...rest,
-					instructions: instructions.map((instruction: DalvikBytecodeOperation) => {
-						return resolveDalvikBytecodeOperation(instruction, resolvers);
-					}) as Instructions,
+					instructions: instructions.map((instruction: DalvikBytecodeOperation) => resolveDalvikBytecodeOperation(instruction, resolvers)) as Instructions,
 				};
 			}
 
 			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);
 
@@ -2566,7 +2803,7 @@ const createDalvikExecutableParser = <Instructions>({
 						};
 					}),
 
-					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);
 
@@ -2576,7 +2813,7 @@ const createDalvikExecutableParser = <Instructions>({
 						};
 					}),
 
-					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);
 
@@ -2590,7 +2827,7 @@ const createDalvikExecutableParser = <Instructions>({
 						};
 					}),
 
-					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);
 
@@ -2606,6 +2843,176 @@ const createDalvikExecutableParser = <Instructions>({
 				});
 			}
 
+			// Resolve TaggedEncodedValue to DalvikExecutableEncodedValue for static values
+			// Resolves internal index types to actual values while preserving type tags
+			function resolveTaggedEncodedValueForStaticValues(taggedValue: DalvikExecutableTaggedEncodedValue): DalvikExecutableEncodedValue {
+				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 } as DalvikExecutableEncodedValue;
+				}
+
+				// 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: DalvikExecutableAnnotation = {
+						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: DalvikExecutableTaggedEncodedValue): DalvikExecutableEncodedValue {
+				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 } as DalvikExecutableEncodedValue;
+				}
+
+				// 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: DalvikExecutableAnnotation = {
+						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 }: DalvikExecutableAnnotationOffsetItem): DalvikExecutableAnnotation {
 				const annotationItem = annotationItemByOffset.get(annotationOffset);
 				invariant(annotationItem, 'Annotation must be there. Annotation offset: %s', annotationOffset);
@@ -2613,13 +3020,13 @@ const createDalvikExecutableParser = <Instructions>({
 				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),
 					};
 				});
 
@@ -2631,10 +3038,20 @@ const createDalvikExecutableParser = <Instructions>({
 			}
 
 			function resolveAnnotationSetItem(annotationSetItem: undefined | DalvikExecutableAnnotationSetItem): undefined | DalvikExecutableAnnotation[] {
-				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);
 
@@ -2669,23 +3086,33 @@ const createDalvikExecutableParser = <Instructions>({
 						classAnnotationSetItem
 							? resolveAnnotationSetItem(classAnnotationSetItem)
 							: undefined
-					);
+					) ?? [];
 
-					const fieldAnnotations: DalvikExecutableClassFieldAnnotation[] = annotationsDirectoryItem.fieldAnnotations.map((fieldAnnotation) => {
+					const fieldAnnotations: DalvikExecutableClassFieldAnnotation[] = 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);
+						const annotationSetItem = annotationSetItemByOffset.get(fieldAnnotation.annotationsOffset);
 						invariant(
-							isoOffsetToAnnotationSetItem.unwrap(fieldAnnotation.annotationsOffset) === 0 || annotations,
+							isoOffsetToAnnotationSetItem.unwrap(fieldAnnotation.annotationsOffset) === 0 || annotationSetItem,
 							'Annotations must be there. Annotations offset: %s',
 							fieldAnnotation.annotationsOffset,
 						);
 
-						return { field, annotations: annotations?.entries.map(resolveAnnotationOffsetItem) };
+						const annotations = resolveAnnotationSetItem(annotationSetItem);
+
+						// Skip fields with no annotations (undefined or empty array)
+						if (!annotations || annotations.length === 0) {
+							return [];
+						}
+
+						return [{
+							field,
+							annotations,
+						}];
 					});
 
-					const methodAnnotations: DalvikExecutableClassMethodAnnotation[] = annotationsDirectoryItem.methodAnnotations.map((methodAnnotation) => {
+					const methodAnnotations: DalvikExecutableClassMethodAnnotation[] = annotationsDirectoryItem.methodAnnotations.flatMap(methodAnnotation => {
 						const method = methods.at(methodAnnotation.methodIndex);
 						invariant(method, 'Method must be there. Method id: %s', methodAnnotation.methodIndex);
 
@@ -2696,10 +3123,20 @@ const createDalvikExecutableParser = <Instructions>({
 							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: DalvikExecutableClassParameterAnnotation[] = annotationsDirectoryItem.parameterAnnotations.map((parameterAnnotation) => {
+					const parameterAnnotations: DalvikExecutableClassParameterAnnotation[] = annotationsDirectoryItem.parameterAnnotations.flatMap(parameterAnnotation => {
 						const method = methods.at(parameterAnnotation.methodIndex);
 						invariant(method, 'Method must be there. Method id: %s', parameterAnnotation.methodIndex);
 
@@ -2710,7 +3147,7 @@ const createDalvikExecutableParser = <Instructions>({
 							parameterAnnotation.annotationsOffset,
 						);
 
-						const annotations = annotationSetRefList?.list.map((annotationSetRefItem) => {
+						const annotations: DalvikExecutableClassParameterAnnotation['annotations'] = annotationSetRefList?.list.map(annotationSetRefItem => {
 							const annotationSetItem = annotationSetItemByOffset.get(annotationSetRefItem);
 							invariant(
 								isoOffsetToAnnotationSetItem.unwrap(annotationSetRefItem) === 0 || annotationSetItem,
@@ -2718,8 +3155,10 @@ const createDalvikExecutableParser = <Instructions>({
 								annotationSetRefItem,
 							);
 
-							return resolveAnnotationSetItem(annotationSetItem);
-						});
+							const annotationSet = resolveAnnotationSetItem(annotationSetItem);
+
+							return annotationSet ?? [];
+						}) ?? [];
 
 						return { method, annotations };
 					});
@@ -2734,12 +3173,32 @@ const createDalvikExecutableParser = <Instructions>({
 
 				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,
@@ -2749,6 +3208,24 @@ const createDalvikExecutableParser = <Instructions>({
 				};
 			});
 
+		// 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,