@futpib/parser 1.0.3 → 1.0.6

package/src/dalvikBytecodeParser.ts

@@ -31,10 +31,11 @@ import {
 } from './dalvikExecutableParser/typeParsers.js';
 import { type DalvikExecutableField, type DalvikExecutableMethod } from './dalvikExecutable.js';
 import {
-	type IndexIntoFieldIds, type IndexIntoMethodIds, type IndexIntoPrototypeIds, type IndexIntoStringIds, type IndexIntoTypeIds, isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoPrototypeIds, isoIndexIntoStringIds, isoIndexIntoTypeIds,
+	type CodeUnit, isoCodeUnit,
+	type IndexIntoCallSiteIds, type IndexIntoFieldIds, type IndexIntoMethodIds, type IndexIntoPrototypeIds, type IndexIntoStringIds, type IndexIntoTypeIds, isoIndexIntoCallSiteIds, isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoPrototypeIds, isoIndexIntoStringIds, isoIndexIntoTypeIds,
 } from './dalvikExecutableParser/typedNumbers.js';
 import { createExactElementParser } from './exactElementParser.js';
-import { createElementSwitchParser } from './exactElementSwitchParser.js';
+import { createElementSwitchParser } from './elementSwitchParser.js';
 import { type Parser, setParserName } from './parser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createSliceBoundedParser } from './sliceBoundedParser.js';
@@ -43,6 +44,7 @@ import { parserCreatorCompose } from './parserCreatorCompose.js';
 import { createQuantifierParser } from './quantifierParser.js';
 import { createDebugLogInputParser } from './debugLogInputParser.js';
 import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createObjectParser } from './objectParser.js';
 import { createTupleParser } from './tupleParser.js';
 
 // https://source.android.com/docs/core/runtime/dalvik-bytecode
@@ -69,12 +71,10 @@ type DalvikBytecodeOperationNoOperation = {
 	operation: 'nop';
 };
 
-const dalvikBytecodeOperationNoOperationParser: Parser<DalvikBytecodeOperationNoOperation, Uint8Array> = promiseCompose(
-	createExactUshortParser(0x00_00), // nop is 2 bytes: 0x00 0x00
-	() => ({
-		operation: 'nop',
-	}),
-);
+const dalvikBytecodeOperationNoOperationParser: Parser<DalvikBytecodeOperationNoOperation, Uint8Array> = createObjectParser({
+	_opcode: createExactUshortParser(0x00_00), // nop is 2 bytes: 0x00 0x00
+	operation: 'nop' as const,
+});
 
 setParserName(dalvikBytecodeOperationNoOperationParser, 'dalvikBytecodeOperationNoOperationParser');
 
@@ -253,9 +253,60 @@ const dalvikBytecodeOperationInvokePolymorphicRangeParser: Parser<DalvikBytecode
 
 setParserName(dalvikBytecodeOperationInvokePolymorphicRangeParser, 'dalvikBytecodeOperationInvokePolymorphicRangeParser');
 
+// Invoke-custom and invoke-custom/range (Android 8.0+)
+type DalvikBytecodeOperationInvokeCustom = {
+	operation: 'invoke-custom';
+	callSiteIndex: IndexIntoCallSiteIds;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationInvokeCustomParser: Parser<DalvikBytecodeOperationInvokeCustom, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0xFC),
+		createDalvikBytecodeFormat35cParser({
+			isoIndex: isoIndexIntoCallSiteIds,
+		}),
+	]),
+	([
+		_opcode,
+		{ index, registers },
+	]) => ({
+		operation: 'invoke-custom',
+		callSiteIndex: index,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationInvokeCustomParser, 'dalvikBytecodeOperationInvokeCustomParser');
+
+type DalvikBytecodeOperationInvokeCustomRange = {
+	operation: 'invoke-custom/range';
+	callSiteIndex: IndexIntoCallSiteIds;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationInvokeCustomRangeParser: Parser<DalvikBytecodeOperationInvokeCustomRange, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0xFD),
+		createDalvikBytecodeFormat3rcParser({
+			isoIndex: isoIndexIntoCallSiteIds,
+		}),
+	]),
+	([
+		_opcode,
+		{ index, registers },
+	]) => ({
+		operation: 'invoke-custom/range',
+		callSiteIndex: index,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationInvokeCustomRangeParser, 'dalvikBytecodeOperationInvokeCustomRangeParser');
+
 type DalvikBytecodeOperationGoto = {
 	operation: 'goto';
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 };
 
 const dalvikBytecodeOperationGotoParser: Parser<DalvikBytecodeOperationGoto, Uint8Array> = promiseCompose(
@@ -263,15 +314,15 @@ const dalvikBytecodeOperationGotoParser: Parser<DalvikBytecodeOperationGoto, Uin
 		createExactElementParser(0x28),
 		dalvikBytecodeFormat10tParser,
 	]),
-	([ _opcode, { branchOffset } ]) => ({
+	([ _opcode, { branchOffsetCodeUnit } ]) => ({
 		operation: 'goto',
-		branchOffset,
+		branchOffsetCodeUnit,
 	}),
 );
 
 type DalvikBytecodeOperationGoto16 = {
 	operation: 'goto/16';
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 };
 
 const dalvikBytecodeOperationGoto16Parser: Parser<DalvikBytecodeOperationGoto16, Uint8Array> = promiseCompose(
@@ -279,15 +330,15 @@ const dalvikBytecodeOperationGoto16Parser: Parser<DalvikBytecodeOperationGoto16,
 		createExactElementParser(0x29),
 		dalvikBytecodeFormat20tParser,
 	]),
-	([ _opcode, { branchOffset } ]) => ({
+	([ _opcode, { branchOffsetCodeUnit } ]) => ({
 		operation: 'goto/16',
-		branchOffset,
+		branchOffsetCodeUnit,
 	}),
 );
 
 type DalvikBytecodeOperationGoto32 = {
 	operation: 'goto/32';
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 };
 
 const dalvikBytecodeOperationGoto32Parser: Parser<DalvikBytecodeOperationGoto32, Uint8Array> = promiseCompose(
@@ -295,15 +346,15 @@ const dalvikBytecodeOperationGoto32Parser: Parser<DalvikBytecodeOperationGoto32,
 		createExactElementParser(0x2A),
 		dalvikBytecodeFormat30tParser,
 	]),
-	([ _opcode, { branchOffset } ]) => ({
+	([ _opcode, { branchOffsetCodeUnit } ]) => ({
 		operation: 'goto/32',
-		branchOffset,
+		branchOffsetCodeUnit,
 	}),
 );
 
 type DalvikBytecodeOperationPackedSwitch = {
 	operation: 'packed-switch';
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 	registers: number[];
 };
 
@@ -312,9 +363,9 @@ const dalvikBytecodeOperationPackedSwitchParser: Parser<DalvikBytecodeOperationP
 		createExactElementParser(0x2B),
 		dalvikBytecodeFormat31tParser,
 	]),
-	([ _opcode, { branchOffset, registers } ]) => ({
+	([ _opcode, { branchOffsetCodeUnit, registers } ]) => ({
 		operation: 'packed-switch',
-		branchOffset,
+		branchOffsetCodeUnit,
 		registers,
 	}),
 );
@@ -324,7 +375,7 @@ setParserName(dalvikBytecodeOperationPackedSwitchParser, 'dalvikBytecodeOperatio
 type DalvikBytecodeOperationPackedSwitchPayload = {
 	operation: 'packed-switch-payload';
 	value: number;
-	branchOffsets: number[];
+	branchOffsetsCodeUnit: CodeUnit[];
 };
 
 const dalvikBytecodeOperationPackedSwitchPayloadParser: Parser<DalvikBytecodeOperationPackedSwitchPayload, Uint8Array> = parserCreatorCompose(
@@ -347,7 +398,7 @@ const dalvikBytecodeOperationPackedSwitchPayloadParser: Parser<DalvikBytecodeOpe
 		branchOffsets => ({
 			operation: 'packed-switch-payload' as const,
 			value,
-			branchOffsets,
+			branchOffsetsCodeUnit: branchOffsets.map(isoCodeUnit.wrap),
 		}),
 	),
 )();
@@ -356,7 +407,7 @@ setParserName(dalvikBytecodeOperationPackedSwitchPayloadParser, 'dalvikBytecodeO
 
 type DalvikBytecodeOperationSparseSwitch = {
 	operation: 'sparse-switch';
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 	registers: number[];
 };
 
@@ -365,9 +416,9 @@ const dalvikBytecodeOperationSparseSwitchParser: Parser<DalvikBytecodeOperationS
 		createExactElementParser(0x2C),
 		dalvikBytecodeFormat31tParser,
 	]),
-	([ _opcode, { branchOffset, registers } ]) => ({
+	([ _opcode, { branchOffsetCodeUnit, registers } ]) => ({
 		operation: 'sparse-switch',
-		branchOffset,
+		branchOffsetCodeUnit,
 		registers,
 	}),
 );
@@ -377,7 +428,7 @@ setParserName(dalvikBytecodeOperationSparseSwitchParser, 'dalvikBytecodeOperatio
 type DalvikBytecodeOperationSparseSwitchPayload = {
 	operation: 'sparse-switch-payload';
 	keys: number[];
-	branchOffsets: number[];
+	branchOffsetsCodeUnit: CodeUnit[];
 };
 
 const dalvikBytecodeOperationSparseSwitchPayloadParser: Parser<DalvikBytecodeOperationSparseSwitchPayload, Uint8Array> = parserCreatorCompose(
@@ -404,7 +455,7 @@ const dalvikBytecodeOperationSparseSwitchPayloadParser: Parser<DalvikBytecodeOpe
 		([ keys, branchOffsets ]) => ({
 			operation: 'sparse-switch-payload' as const,
 			keys,
-			branchOffsets,
+			branchOffsetsCodeUnit: branchOffsets.map(isoCodeUnit.wrap),
 		}),
 	),
 )();
@@ -1293,6 +1344,10 @@ const dalvikBytecodeOperationDivideFloatParser = createDalvikBytecodeOperationBi
 
 type DalvikBytecodeOperationDivideFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideFloatParser>>;
 
+const dalvikBytecodeOperationRemainderFloatParser = createDalvikBytecodeOperationBinaryOperation('rem-float', 0xAA);
+
+type DalvikBytecodeOperationRemainderFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderFloatParser>>;
+
 const dalvikBytecodeOperationAddDoubleParser = createDalvikBytecodeOperationBinaryOperation('add-double', 0xAB);
 
 type DalvikBytecodeOperationAddDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationAddDoubleParser>>;
@@ -1340,6 +1395,7 @@ type DalvikBytecodeOperationBinaryOperation =
 	| DalvikBytecodeOperationSubtractFloat
 	| DalvikBytecodeOperationMultiplyFloat
 	| DalvikBytecodeOperationDivideFloat
+	| DalvikBytecodeOperationRemainderFloat
 	| DalvikBytecodeOperationAddDouble
 	| DalvikBytecodeOperationSubtractDouble
 	| DalvikBytecodeOperationMultiplyDouble
@@ -1374,6 +1430,7 @@ const dalvikBytecodeOperationBinaryOperationParser: Parser<DalvikBytecodeOperati
 	dalvikBytecodeOperationSubtractFloatParser,
 	dalvikBytecodeOperationMultiplyFloatParser,
 	dalvikBytecodeOperationDivideFloatParser,
+	dalvikBytecodeOperationRemainderFloatParser,
 	dalvikBytecodeOperationAddDoubleParser,
 	dalvikBytecodeOperationSubtractDoubleParser,
 	dalvikBytecodeOperationMultiplyDoubleParser,
@@ -1535,16 +1592,16 @@ setParserName(dalvikBytecodeOperationUnaryOperationParser, 'dalvikBytecodeOperat
 const createDalvikBytecodeOperationIfTestCommutative = <T extends string>(operation: T, opcode: number): Parser<{
 	operation: T;
 	registers: number[];
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array> => promiseCompose(
 	createTupleParser([
 		createExactElementParser(opcode),
 		createDalvikBytecodeFormat22tParser(),
 	]),
-	([ _opcode, { registers, branchOffset } ]) => ({
+	([ _opcode, { registers, branchOffsetCodeUnit } ]) => ({
 		operation,
 		registers: registers.sort((a, b) => a - b),
-		branchOffset,
+		branchOffsetCodeUnit,
 	}),
 );
 
@@ -1552,16 +1609,16 @@ const createDalvikBytecodeOperationIfTestCommutative = <T extends string>(operat
 const createDalvikBytecodeOperationIfTest = <T extends string>(operation: T, opcode: number): Parser<{
 	operation: T;
 	registers: number[];
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array> => promiseCompose(
 	createTupleParser([
 		createExactElementParser(opcode),
 		createDalvikBytecodeFormat22tParser(),
 	]),
-	([ _opcode, { registers, branchOffset } ]) => ({
+	([ _opcode, { registers, branchOffsetCodeUnit } ]) => ({
 		operation,
 		registers: registers.reverse(),
-		branchOffset,
+		branchOffsetCodeUnit,
 	}),
 );
 
@@ -1612,16 +1669,16 @@ setParserName(dalvikBytecodeOperationIfTestParser, 'dalvikBytecodeOperationIfTes
 const createDalvikBytecodeOperationIfTestZero = <T extends string>(operation: T, opcode: number): Parser<{
 	operation: T;
 	registers: number[];
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array> => promiseCompose(
 	createTupleParser([
 		createExactElementParser(opcode),
 		createDalvikBytecodeFormat21tParser(),
 	]),
-	([ _opcode, { registers, branchOffset } ]) => ({
+	([ _opcode, { registers, branchOffsetCodeUnit } ]) => ({
 		operation,
 		registers,
-		branchOffset,
+		branchOffsetCodeUnit,
 	}),
 );
 
@@ -1735,6 +1792,28 @@ const dalvikBytecodeOperationConstMethodHandleParser: Parser<DalvikBytecodeOpera
 
 setParserName(dalvikBytecodeOperationConstMethodHandleParser, 'dalvikBytecodeOperationConstMethodHandleParser');
 
+type DalvikBytecodeOperationConstMethodType = {
+	operation: 'const-method-type';
+	protoIndex: IndexIntoPrototypeIds;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationConstMethodTypeParser: Parser<DalvikBytecodeOperationConstMethodType, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0xFF),
+		createDalvikBytecodeFormat21cParser({
+			isoIndex: isoIndexIntoPrototypeIds,
+		}),
+	]),
+	([ _opcode, { index, registers } ]) => ({
+		operation: 'const-method-type',
+		protoIndex: index,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationConstMethodTypeParser, 'dalvikBytecodeOperationConstMethodTypeParser');
+
 type DalvikBytecodeOperationNewInstance = {
 	operation: 'new-instance';
 	typeIndex: IndexIntoTypeIds;
@@ -1825,7 +1904,7 @@ setParserName(dalvikBytecodeOperationFilledNewArrayRangeParser, 'dalvikBytecodeO
 
 type DalvikBytecodeOperationFillArrayData = {
 	operation: 'fill-array-data';
-	branchOffset: number;
+	branchOffsetCodeUnit: CodeUnit;
 	registers: number[];
 };
 
@@ -1834,9 +1913,9 @@ const dalvikBytecodeOperationFillArrayDataParser: Parser<DalvikBytecodeOperation
 		createExactElementParser(0x26),
 		dalvikBytecodeFormat31tParser,
 	]),
-	([ _opcode, { branchOffset, registers } ]) => ({
+	([ _opcode, { branchOffsetCodeUnit, registers } ]) => ({
 		operation: 'fill-array-data',
-		branchOffset,
+		branchOffsetCodeUnit,
 		registers,
 	}),
 );
@@ -1945,15 +2024,11 @@ type DalvikBytecodeOperationReturnVoid = {
 	operation: 'return-void';
 };
 
-const dalvikBytecodeOperationReturnVoidParser: Parser<DalvikBytecodeOperationReturnVoid, Uint8Array> = promiseCompose(
-	createTupleParser([
-		createExactElementParser(0x0E),
-		dalvikBytecodeFormat10xParser,
-	]),
-	() => ({
-		operation: 'return-void',
-	}),
-);
+const dalvikBytecodeOperationReturnVoidParser: Parser<DalvikBytecodeOperationReturnVoid, Uint8Array> = createObjectParser({
+	_opcode: createExactElementParser(0x0E),
+	_format: dalvikBytecodeFormat10xParser,
+	operation: 'return-void' as const,
+});
 
 setParserName(dalvikBytecodeOperationReturnVoidParser, 'dalvikBytecodeOperationReturnVoidParser');
 
@@ -2123,6 +2198,42 @@ const dalvikBytecodeOperationMoveWide16Parser: Parser<DalvikBytecodeOperationMov
 
 setParserName(dalvikBytecodeOperationMoveWide16Parser, 'dalvikBytecodeOperationMoveWide16Parser');
 
+type DalvikBytecodeOperationMove16 = {
+	operation: 'move/16';
+	registers: number[];
+};
+
+const dalvikBytecodeOperationMove16Parser: Parser<DalvikBytecodeOperationMove16, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x03),
+		dalvikBytecodeFormat32xParser,
+	]),
+	([ _opcode, { registers } ]) => ({
+		operation: 'move/16',
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationMove16Parser, 'dalvikBytecodeOperationMove16Parser');
+
+type DalvikBytecodeOperationMoveObject16 = {
+	operation: 'move-object/16';
+	registers: number[];
+};
+
+const dalvikBytecodeOperationMoveObject16Parser: Parser<DalvikBytecodeOperationMoveObject16, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x09),
+		dalvikBytecodeFormat32xParser,
+	]),
+	([ _opcode, { registers } ]) => ({
+		operation: 'move-object/16',
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationMoveObject16Parser, 'dalvikBytecodeOperationMoveObject16Parser');
+
 const createDalvikBytecodeOperationReturn1Parser = createDalvikBytecodeMoveResult1Parser;
 
 const dalvikBytecodeOperationReturnParser = createDalvikBytecodeOperationReturn1Parser('return', 0x0F);
@@ -2384,7 +2495,7 @@ const dalvikBytecodeOperationCompareParser: Parser<DalvikBytecodeOperationCompar
 
 setParserName(dalvikBytecodeOperationCompareParser, 'dalvikBytecodeOperationCompareParser');
 
-export type DalvikBytecodeOperation =
+export type RawDalvikBytecodeOperation =
 	| DalvikBytecodeOperationNoOperation
 
 	| DalvikBytecodeOperationIfTest
@@ -2414,14 +2525,18 @@ export type DalvikBytecodeOperation =
 	| DalvikBytecodeOperationMoveWide
 	| DalvikBytecodeOperationMoveObject
 	| DalvikBytecodeOperationMoveFrom16
+	| DalvikBytecodeOperationMove16
 	| DalvikBytecodeOperationMoveWideFrom16
 	| DalvikBytecodeOperationMoveObjectFrom16
 	| DalvikBytecodeOperationMoveWide16
+	| DalvikBytecodeOperationMoveObject16
 
 	| DalvikBytecodeOperationInvoke
 	| DalvikBytecodeOperationInvokeRange
 	| DalvikBytecodeOperationInvokePolymorphic
 	| DalvikBytecodeOperationInvokePolymorphicRange
+	| DalvikBytecodeOperationInvokeCustom
+	| DalvikBytecodeOperationInvokeCustomRange
 
 	| DalvikBytecodeOperationNewInstance
 
@@ -2446,6 +2561,7 @@ export type DalvikBytecodeOperation =
 	| DalvikBytecodeOperationConstString
 	| DalvikBytecodeOperationConstStringJumbo
 	| DalvikBytecodeOperationConstMethodHandle
+	| DalvikBytecodeOperationConstMethodType
 	| DalvikBytecodeOperationConstClass
 
 	| DalvikBytecodeOperationMonitorEnter
@@ -2457,8 +2573,8 @@ export type DalvikBytecodeOperation =
 
 	| DalvikBytecodeOperationReturnVoid
 	| DalvikBytecodeOperationReturn1;
-export const dalvikBytecodeOperationCompanion = {
-	getRegisters(operation: DalvikBytecodeOperation): number[] {
+export const rawDalvikBytecodeOperationCompanion = {
+	getRegisters(operation: RawDalvikBytecodeOperation): number[] {
 		if (operation && typeof operation === 'object' && 'registers' in operation) {
 			return operation.registers;
 		}
@@ -2487,6 +2603,10 @@ const dalvikBytecodeOperationOpcodeMap = new Map<number, Parser<unknown, Uint8Ar
 	[ 0xFA, dalvikBytecodeOperationInvokePolymorphicParser ],
 	[ 0xFB, dalvikBytecodeOperationInvokePolymorphicRangeParser ],
 
+	// Invoke custom operations
+	[ 0xFC, dalvikBytecodeOperationInvokeCustomParser ],
+	[ 0xFD, dalvikBytecodeOperationInvokeCustomRangeParser ],
+
 	// New instance/array operations
 	[ 0x22, dalvikBytecodeOperationNewInstanceParser ],
 	[ 0x23, dalvikBytecodeOperationNewArrayParser ],
@@ -2549,6 +2669,7 @@ const dalvikBytecodeOperationOpcodeMap = new Map<number, Parser<unknown, Uint8Ar
 	[ 0x1A, dalvikBytecodeOperationConstStringParser ],
 	[ 0x1B, dalvikBytecodeOperationConstStringJumboParser ],
 	[ 0xFE, dalvikBytecodeOperationConstMethodHandleParser ],
+	[ 0xFF, dalvikBytecodeOperationConstMethodTypeParser ],
 	[ 0x1C, dalvikBytecodeOperationConstClassParser ],
 
 	// Monitor operations
@@ -2585,6 +2706,8 @@ const dalvikBytecodeOperationOpcodeMap = new Map<number, Parser<unknown, Uint8Ar
 	[ 0x05, dalvikBytecodeOperationMoveWideFrom16Parser ],
 	[ 0x08, dalvikBytecodeOperationMoveObjectFrom16Parser ],
 	[ 0x06, dalvikBytecodeOperationMoveWide16Parser ],
+	[ 0x03, dalvikBytecodeOperationMove16Parser ],
+	[ 0x09, dalvikBytecodeOperationMoveObject16Parser ],
 
 	// Const value operations
 	[ 0x12, dalvikBytecodeOperationConst4Parser ],
@@ -2646,7 +2769,7 @@ const dalvikBytecodeOperationOpcodeMap = new Map<number, Parser<unknown, Uint8Ar
 	[ 0xA7, dalvikBytecodeOperationSubtractFloatParser ],
 	[ 0xA8, dalvikBytecodeOperationMultiplyFloatParser ],
 	[ 0xA9, dalvikBytecodeOperationDivideFloatParser ],
-	// Note: 0xAA (rem-float) parser is missing in codebase
+	[ 0xAA, dalvikBytecodeOperationRemainderFloatParser ],
 	[ 0xAB, dalvikBytecodeOperationAddDoubleParser ],
 	[ 0xAC, dalvikBytecodeOperationSubtractDoubleParser ],
 	[ 0xAD, dalvikBytecodeOperationMultiplyDoubleParser ],
@@ -2773,7 +2896,7 @@ const dalvikBytecodeOperationOpcodeMap = new Map<number, Parser<unknown, Uint8Ar
 ]);
 
 // Fallback parser for multi-byte opcodes (nop and payload instructions)
-const dalvikBytecodeOperationMultiByteParser: Parser<DalvikBytecodeOperation, Uint8Array> = createDisjunctionParser([
+const dalvikBytecodeOperationMultiByteParser: Parser<RawDalvikBytecodeOperation, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationNoOperationParser,
 	dalvikBytecodeOperationPackedSwitchPayloadParser,
 	dalvikBytecodeOperationSparseSwitchPayloadParser,
@@ -2782,11 +2905,11 @@ const dalvikBytecodeOperationMultiByteParser: Parser<DalvikBytecodeOperation, Ui
 
 setParserName(dalvikBytecodeOperationMultiByteParser, 'dalvikBytecodeOperationMultiByteParser');
 
-const dalvikBytecodeOperationParser: Parser<DalvikBytecodeOperation | undefined, Uint8Array> = promiseCompose(
+const dalvikBytecodeOperationParser: Parser<RawDalvikBytecodeOperation | undefined, Uint8Array> = promiseCompose(
 	createTupleParser([
 		() => {},
 		// CreateDebugLogInputParser(),
-		createElementSwitchParser<DalvikBytecodeOperation, Uint8Array>(
+		createElementSwitchParser(
 			dalvikBytecodeOperationOpcodeMap,
 			dalvikBytecodeOperationMultiByteParser,
 		),
@@ -2796,21 +2919,21 @@ const dalvikBytecodeOperationParser: Parser<DalvikBytecodeOperation | undefined,
 		operation,
 	]) =>
 		// Console.log(operation);
-		operation,
+		operation as RawDalvikBytecodeOperation | undefined,
 );
 
 setParserName(dalvikBytecodeOperationParser, 'dalvikBytecodeOperationParser');
 
-export type DalvikBytecode = DalvikBytecodeOperation[];
+export type RawDalvikBytecode = RawDalvikBytecodeOperation[];
 
-const dalvikBytecodeParser: Parser<DalvikBytecode, Uint8Array> = promiseCompose(
+const rawDalvikBytecodeParser: Parser<RawDalvikBytecode, Uint8Array> = promiseCompose(
 	createArrayParser(dalvikBytecodeOperationParser),
-	operations => operations.filter((operation): operation is DalvikBytecodeOperation => operation !== undefined),
+	operations => operations.filter((operation): operation is RawDalvikBytecodeOperation => operation !== undefined),
 );
 
-export const createDalvikBytecodeParser = (size: number): Parser<DalvikBytecode, Uint8Array> => createSliceBoundedParser(dalvikBytecodeParser, size, true);
+export const createRawDalvikBytecodeParser = (size: number): Parser<RawDalvikBytecode, Uint8Array> => createSliceBoundedParser(rawDalvikBytecodeParser, size, true);
 
-type ResolvedDalvikBytecodeOperation<T extends DalvikBytecodeOperation> = T extends { stringIndex: IndexIntoFieldIds }
+export type IndexResolvedOperation<T> = T extends { stringIndex: IndexIntoStringIds }
 	? Omit<T, 'stringIndex'> & { string: string }
 	: T extends { typeIndex: IndexIntoTypeIds }
 		? Omit<T, 'typeIndex'> & { type: string }
@@ -2820,26 +2943,28 @@ type ResolvedDalvikBytecodeOperation<T extends DalvikBytecodeOperation> = T exte
 				? Omit<T, 'fieldIndex'> & { field: DalvikExecutableField }
 				: T;
 
-export type DalvikBytecodeOperationResolvers = {
+type IndexResolvedRawDalvikBytecodeOperation<T extends RawDalvikBytecodeOperation> = IndexResolvedOperation<T>;
+
+export type RawDalvikBytecodeOperationResolvers = {
 	resolveIndexIntoStringIds: (index: IndexIntoStringIds) => string;
 	resolveIndexIntoTypeIds: (index: IndexIntoTypeIds) => string;
 	resolveIndexIntoMethodIds: (index: IndexIntoMethodIds) => DalvikExecutableMethod;
 	resolveIndexIntoFieldIds: (index: IndexIntoFieldIds) => DalvikExecutableField;
 };
 
-export function resolveDalvikBytecodeOperation<T extends DalvikBytecodeOperation>(operation: T, {
+export function resolveRawDalvikBytecodeOperationIndices<T extends RawDalvikBytecodeOperation>(operation: T, {
 	resolveIndexIntoStringIds,
 	resolveIndexIntoTypeIds,
 	resolveIndexIntoMethodIds,
 	resolveIndexIntoFieldIds,
-}: DalvikBytecodeOperationResolvers): ResolvedDalvikBytecodeOperation<T> {
+}: RawDalvikBytecodeOperationResolvers): IndexResolvedRawDalvikBytecodeOperation<T> {
 	if (operation && typeof operation === 'object' && 'stringIndex' in operation) {
 		const { stringIndex, ...rest } = operation;
 
 		return {
 			...rest,
 			string: resolveIndexIntoStringIds(stringIndex),
-		} as ResolvedDalvikBytecodeOperation<T>;
+		} as IndexResolvedRawDalvikBytecodeOperation<T>;
 	}
 
 	if (operation && typeof operation === 'object' && 'typeIndex' in operation) {
@@ -2848,7 +2973,7 @@ export function resolveDalvikBytecodeOperation<T extends DalvikBytecodeOperation
 		return {
 			...rest,
 			type: resolveIndexIntoTypeIds(typeIndex),
-		} as ResolvedDalvikBytecodeOperation<T>;
+		} as IndexResolvedRawDalvikBytecodeOperation<T>;
 	}
 
 	if (operation && typeof operation === 'object' && 'methodIndex' in operation) {
@@ -2857,7 +2982,7 @@ export function resolveDalvikBytecodeOperation<T extends DalvikBytecodeOperation
 		return {
 			...rest,
 			method: resolveIndexIntoMethodIds(methodIndex),
-		} as ResolvedDalvikBytecodeOperation<T>;
+		} as IndexResolvedRawDalvikBytecodeOperation<T>;
 	}
 
 	if (operation && typeof operation === 'object' && 'fieldIndex' in operation) {
@@ -2866,8 +2991,8 @@ export function resolveDalvikBytecodeOperation<T extends DalvikBytecodeOperation
 		return {
 			...rest,
 			field: resolveIndexIntoFieldIds(fieldIndex),
-		} as ResolvedDalvikBytecodeOperation<T>;
+		} as IndexResolvedRawDalvikBytecodeOperation<T>;
 	}
 
-	return operation as ResolvedDalvikBytecodeOperation<T>;
+	return operation as IndexResolvedRawDalvikBytecodeOperation<T>;
 }