@futpib/parser 1.0.3 → 1.0.6

package/src/smaliParser.ts

@@ -1,10 +1,12 @@
 import invariant from 'invariant';
 import { type Simplify } from 'type-fest';
-import { type DalvikBytecode, type DalvikBytecodeOperation, dalvikBytecodeOperationCompanion } from './dalvikBytecodeParser.js';
+import { type RawDalvikBytecodeOperation, rawDalvikBytecodeOperationCompanion } from './dalvikBytecodeParser.js';
+import { type DalvikBytecodeOperation, type DalvikBytecode, getOperationSizeInCodeUnits } from './dalvikBytecodeParser/addressConversion.js';
 import {
 	type DalvikExecutableAccessFlags, dalvikExecutableAccessFlagsDefault, type DalvikExecutableAnnotation, type DalvikExecutableClassAnnotations, type DalvikExecutableClassData, type DalvikExecutableClassDefinition, type DalvikExecutableClassMethodAnnotation, type DalvikExecutableClassParameterAnnotation, type DalvikExecutableCode, type DalvikExecutableDebugInfo, type DalvikExecutableEncodedValue, type DalvikExecutableField, dalvikExecutableFieldEquals, type DalvikExecutableFieldWithAccess, type DalvikExecutableMethod, dalvikExecutableMethodEquals, type DalvikExecutableMethodWithAccess, type DalvikExecutablePrototype, isDalvikExecutableField, isDalvikExecutableMethod,
 } from './dalvikExecutable.js';
 import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createObjectParser } from './objectParser.js';
 import { cloneParser, type Parser, setParserName } from './parser.js';
 import { type ParserContext } from './parserContext.js';
 import { promiseCompose } from './promiseCompose.js';
@@ -18,16 +20,13 @@ import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
 import { createSeparatedArrayParser } from './separatedArrayParser.js';
 import { smaliMemberNameParser, smaliTypeDescriptorParser } from './dalvikExecutableParser/stringSyntaxParser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
-import { formatSizes } from './dalvikBytecodeParser/formatSizes.js';
-import { operationFormats } from './dalvikBytecodeParser/operationFormats.js';
 import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
 import { parserCreatorCompose } from './parserCreatorCompose.js';
 import { type IndexIntoMethodIds } from './dalvikExecutableParser/typedNumbers.js';
-import { createDebugLogInputParser } from './debugLogInputParser.js';
-import { createDebugLogParser } from './debugLogParser.js';
 import { createElementParser } from './elementParser.js';
 import { createTerminatedArrayParser } from './terminatedArrayParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
+import { createRegExpParser } from './regexpParser.js';
 
 function shortyFromLongy(longy: string): string {
 	if (longy.startsWith('[')) {
@@ -37,30 +36,6 @@ function shortyFromLongy(longy: string): string {
 	return longy.slice(0, 1);
 }
 
-function getOperationFormatSize(operation: SmaliCodeOperation): number {
-	if (operation.operation === 'packed-switch-payload') {
-		return (operation.branchOffsetIndices.length * 2) + 4;
-	}
-
-	if (operation.operation === 'sparse-switch-payload') {
-		return (operation.branchOffsetIndices.length * 4) + 2;
-	}
-
-	if (operation.operation === 'fill-array-data-payload') {
-		const dataSize = operation.data.length; // in bytes
-		const paddingSize = dataSize % 2; // 1 if odd, 0 if even
-		const totalBytes = 8 + dataSize + paddingSize; // header (8 bytes) + data + padding
-		return totalBytes / 2; // Convert to code units (1 code unit = 2 bytes)
-	}
-
-	const operationFormat = operationFormats[operation.operation as keyof typeof operationFormats];
-	invariant(operationFormat, 'Unknown operation format for "%s" (operation: %o)', operation.operation, operation);
-
-	const operationSize = formatSizes[operationFormat];
-	invariant(operationSize, 'Unknown operation size for format %s of operation %s', operationFormat, operation.operation);
-
-	return operationSize;
-}
 
 // Helper function to convert raw annotation element values to tagged encoded values
 function convertToTaggedEncodedValue(wrappedValue: SmaliAnnotationElementValue): DalvikExecutableEncodedValue {
@@ -166,7 +141,7 @@ function convertToTaggedEncodedValue(wrappedValue: SmaliAnnotationElementValue):
 }
 
 
-const smaliNewlinesParser: Parser<void, string> = promiseCompose(
+const smaliNewlinesParser: Parser<undefined, string> = promiseCompose(
 	createNonEmptyArrayParser(createExactSequenceParser('\n')),
 	_newlines => undefined,
 );
@@ -188,31 +163,11 @@ const smaliIndentationParser: Parser<void, string> = promiseCompose(
 export const smaliCommentParser: Parser<string, string> = promiseCompose(
 	createTupleParser([
 		createExactSequenceParser('#'),
-		(async (parserContext: ParserContext<string, string>) => {
-			const characters: string[] = [];
-
-			while (true) {
-				const character = await parserContext.peek(0);
-
-				parserContext.invariant(character !== undefined, 'Unexpected end of input');
-
-				invariant(character !== undefined, 'Unexpected end of input');
-
-				if (character !== '\n') {
-					characters.push(character);
-
-					parserContext.skip(1);
-
-					continue;
-				}
-
-				parserContext.skip(1);
-
-				break;
-			}
-
-			return characters.join('');
-		}),
+		promiseCompose(
+			createRegExpParser(/[^\n]*/),
+			match => match[0],
+		),
+		createExactSequenceParser('\n'),
 	]),
 	([
 		_hash,
@@ -232,7 +187,7 @@ const smaliIndentedCommentParser: Parser<string, string> = promiseCompose(
 );
 
 const smaliCommentsOrNewlinesParser: Parser<string[], string> = promiseCompose(
-	createArrayParser(createUnionParser<undefined | string, string, string>([
+	createArrayParser(createUnionParser([
 		smaliNewlinesParser,
 		smaliIndentedCommentParser,
 		smaliCommentParser,
@@ -243,7 +198,7 @@ const smaliCommentsOrNewlinesParser: Parser<string[], string> = promiseCompose(
 const smaliLineEndPraser: Parser<undefined | string, string> = promiseCompose(
 	createTupleParser([
 		createOptionalParser(smaliWhitespaceParser),
-		createUnionParser<undefined | string, string, string>([
+		createUnionParser([
 			smaliNewlinesParser,
 			smaliCommentParser,
 		]),
@@ -254,89 +209,31 @@ const smaliLineEndPraser: Parser<undefined | string, string> = promiseCompose(
 	]) => newlineOrComment,
 );
 
-const smaliIdentifierParser: Parser<string, string> = async (parserContext: ParserContext<string, string>) => {
-	const characters: string[] = [];
-
-	while (true) {
-		const character = await parserContext.peek(0);
-
-		parserContext.invariant(character !== undefined, 'Unexpected end of input');
-
-		invariant(character !== undefined, 'Unexpected end of input');
-
-		if (
-			character === '_'
-			|| (
-				character >= 'a' && character <= 'z'
-			)
-			|| (
-				character >= 'A' && character <= 'Z'
-			)
-			|| (
-				character >= '0' && character <= '9'
-			)
-		) {
-			parserContext.skip(1);
-
-			characters.push(character);
-
-			continue;
-		}
-
-		parserContext.invariant(characters.length > 0, 'Expected at least one character');
-
-		break;
-	}
-
-	return characters.join('');
-};
+const smaliIdentifierParser: Parser<string, string> = promiseCompose(
+	createRegExpParser(/[a-zA-Z0-9_]+/),
+	match => match[0],
+);
 
 setParserName(smaliIdentifierParser, 'smaliIdentifierParser');
 
-const elementParser = createElementParser<string>();
-
 const smaliHexNumberParser: Parser<number | bigint, string> = promiseCompose(
-	createTupleParser([
-		createOptionalParser(createExactSequenceParser('-')),
-		createExactSequenceParser('0x'),
-		createArrayParser(parserCreatorCompose(
-			() => elementParser,
-			character => async parserContext => {
-				parserContext.invariant(
-					(
-						(character >= '0' && character <= '9')
-						|| (character >= 'a' && character <= 'f')
-						|| (character >= 'A' && character <= 'F')
-					),
-					'Expected "0" to "9", "a" to "f", "A" to "F", got "%s"',
-					character,
-				);
+	createRegExpParser(/-?0x([0-9a-fA-F]+)(L)?/),
+	match => {
+		const hexDigits = match[1]!;
+		const optionalL = match[2];
 
-				return character;
-			},
-		)()),
-		createOptionalParser(createExactSequenceParser('L')),
-	]),
-	([
-		optionalMinus,
-		_0x,
-		valueCharacters,
-		optionalL,
-	]) => {
-		const value = valueCharacters.join('');
-		
 		// If the 'L' suffix is present, use BigInt for long values
 		if (optionalL) {
-			const sign = optionalMinus ? -1n : 1n;
-			return sign * BigInt('0x' + value);
+			const sign = match[0].startsWith('-') ? -1n : 1n;
+			return sign * BigInt('0x' + hexDigits);
 		}
-		
-		const sign = optionalMinus ? -1 : 1;
-		return sign * Number.parseInt(value, 16);
+
+		const sign = match[0].startsWith('-') ? -1 : 1;
+		return sign * Number.parseInt(hexDigits, 16);
 	},
 );
 
-const smaliNumberParser = createUnionParser<number, string>([
+const smaliNumberParser = createUnionParser([
 	promiseCompose(
 		createTupleParser([
 			createNegativeLookaheadParser(createUnionParser([
@@ -383,7 +280,7 @@ const smaliNumberParser = createUnionParser<number, string>([
 setParserName(smaliNumberParser, 'smaliNumberParser');
 
 // Parser for field initial values that can include BigInt
-const smaliFieldValueParser = createUnionParser<number | bigint, string>([
+const smaliFieldValueParser = createUnionParser([
 	promiseCompose(
 		createTupleParser([
 			createNegativeLookaheadParser(createUnionParser([
@@ -424,7 +321,7 @@ const smaliQuotedStringParser: Parser<string, string> = promiseCompose(
 const smaliCharacterLiteralParser: Parser<number, string> = promiseCompose(
 	createTupleParser([
 		createExactSequenceParser('\''),
-		createDisjunctionParser<string, string>([
+		createDisjunctionParser([
 			// Handle escape sequences (must come before regular characters)
 			promiseCompose(createExactSequenceParser(String.raw`\\`), () => '\\'),
 			promiseCompose(createExactSequenceParser(String.raw`\'`), () => '\''),
@@ -477,9 +374,9 @@ const smaliIdentifierContinuationParser: Parser<string, string> = async (parserC
 setParserName(smaliIdentifierContinuationParser, 'smaliIdentifierContinuationParser');
 
 // Helper to create an access flag parser with word boundary check
-const createAccessFlagParser = (keyword: string): Parser<typeof keyword, string> => promiseCompose(
+const createAccessFlagParser = <const T extends string>(keyword: T): Parser<T, string> => promiseCompose(
 	createTupleParser([
-		createExactSequenceParser(keyword),
+		createExactSequenceParser(keyword) as Parser<T, string>,
 		createNegativeLookaheadParser(smaliIdentifierContinuationParser),
 	]),
 	([flag]) => flag,
@@ -487,7 +384,7 @@ const createAccessFlagParser = (keyword: string): Parser<typeof keyword, string>
 
 const smaliAccessFlagsParser: Parser<DalvikExecutableAccessFlags, string> = promiseCompose(
 	createSeparatedArrayParser(
-		createUnionParser<keyof DalvikExecutableAccessFlags | 'declared-synchronized', string>([
+		createUnionParser([
 			createAccessFlagParser('public'),
 			createAccessFlagParser('protected'),
 			createAccessFlagParser('private'),
@@ -554,20 +451,11 @@ const smaliClassDeclarationParser: Parser<Pick<DalvikExecutableClassDefinition<u
 
 setParserName(smaliClassDeclarationParser, 'smaliClassDeclarationParser');
 
-const smaliSuperDeclarationParser: Parser<Pick<DalvikExecutableClassDefinition<unknown>, 'superclass'>, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('.super '),
-		smaliTypeDescriptorParser,
-		smaliLineEndPraser,
-	]),
-	([
-		_super,
-		superclass,
-		_newline,
-	]) => ({
-		superclass,
-	}),
-);
+const smaliSuperDeclarationParser: Parser<Pick<DalvikExecutableClassDefinition<unknown>, 'superclass'>, string> = createObjectParser({
+	_super: createExactSequenceParser('.super '),
+	superclass: smaliTypeDescriptorParser,
+	_newline: smaliLineEndPraser,
+});
 
 setParserName(smaliSuperDeclarationParser, 'smaliSuperDeclarationParser');
 
@@ -586,20 +474,11 @@ const smaliInterfaceDeclarationParser: Parser<string, string> = promiseCompose(
 
 setParserName(smaliInterfaceDeclarationParser, 'smaliInterfaceDeclarationParser');
 
-const smaliSourceDeclarationParser: Parser<Pick<DalvikExecutableClassDefinition<unknown>, 'sourceFile'>, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('.source '),
-		smaliQuotedStringParser,
-		smaliLineEndPraser,
-	]),
-	([
-		_source,
-		sourceFile,
-		_newline,
-	]) => ({
-		sourceFile,
-	}),
-);
+const smaliSourceDeclarationParser: Parser<Pick<DalvikExecutableClassDefinition<unknown>, 'sourceFile'>, string> = createObjectParser({
+	_source: createExactSequenceParser('.source '),
+	sourceFile: smaliQuotedStringParser,
+	_newline: smaliLineEndPraser,
+});
 
 // Wrapper type to distinguish different value types in smali annotation elements
 type SmaliAnnotationElementValue =
@@ -613,28 +492,14 @@ type SmaliAnnotationElement = {
 	value: SmaliAnnotationElementValue;
 };
 
-const smaliEnumValueParser: Parser<DalvikExecutableField, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('.enum '),
-		smaliTypeDescriptorParser,
-		createExactSequenceParser('->'),
-		smaliMemberNameParser,
-		createExactSequenceParser(':'),
-		smaliTypeDescriptorParser,
-	]),
-	([
-		_enum,
-		classType,
-		_arrow,
-		fieldName,
-		_colon,
-		fieldType,
-	]) => ({
-		class: classType,
-		type: fieldType,
-		name: fieldName,
-	}),
-);
+const smaliEnumValueParser: Parser<DalvikExecutableField, string> = createObjectParser({
+	_enum: createExactSequenceParser('.enum '),
+	class: smaliTypeDescriptorParser,
+	_arrow: createExactSequenceParser('->'),
+	name: smaliMemberNameParser,
+	_colon: createExactSequenceParser(':'),
+	type: smaliTypeDescriptorParser,
+});
 
 setParserName(smaliEnumValueParser, 'smaliEnumValueParser');
 
@@ -665,24 +530,12 @@ const smaliMethodPrototypeParser: Parser<DalvikExecutablePrototype, string> = pr
 
 setParserName(smaliMethodPrototypeParser, 'smaliMethodPrototypeParser');
 
-const smaliParametersMethodParser: Parser<DalvikExecutableMethod, string> = promiseCompose(
-	createTupleParser([
-		smaliTypeDescriptorParser,
-		createExactSequenceParser('->'),
-		smaliMemberNameParser,
-		smaliMethodPrototypeParser,
-	]),
-	([
-		classPath,
-		_separator,
-		methodName,
-		prototype,
-	]) => ({
-		class: classPath,
-		prototype,
-		name: methodName,
-	}),
-);
+const smaliParametersMethodParser: Parser<DalvikExecutableMethod, string> = createObjectParser({
+	class: smaliTypeDescriptorParser,
+	_separator: createExactSequenceParser('->'),
+	name: smaliMemberNameParser,
+	prototype: smaliMethodPrototypeParser,
+});
 
 setParserName(smaliParametersMethodParser, 'smaliParametersMethodParser');
 
@@ -700,46 +553,49 @@ const smaliAnnotationElementParser: Parser<SmaliAnnotationElement, string> = pro
 		smaliIdentifierParser,
 		createExactSequenceParser(' = '),
 		createDisjunctionParser([
-			promiseCompose(
-				createParserAccessorParser(() => smaliSubannotationParser),
-				value => ({ kind: 'raw' as const, value }),
-			),
-			promiseCompose(
-				smaliEnumValueParser,
-				value => ({ kind: 'enum' as const, value }),
-			),
-			promiseCompose(
-				smaliQuotedStringParser,
-				value => ({ kind: 'string' as const, value }),
-			),
-			promiseCompose(
-				smaliParametersMethodParser,
-				value => ({ kind: 'raw' as const, value }),
-			),
-			promiseCompose(
-				smaliTypeDescriptorParser,
-				value => ({ kind: 'type' as const, value }),
-			),
-			promiseCompose(
-				smaliNumberParser,
-				value => ({ kind: 'raw' as const, value }),
-			),
-			promiseCompose(
-				createExactSequenceParser('true'),
-				() => ({ kind: 'raw' as const, value: true }),
-			),
-			promiseCompose(
-				createExactSequenceParser('false'),
-				() => ({ kind: 'raw' as const, value: false }),
-			),
+			createObjectParser({
+				kind: 'raw' as const,
+				value: createParserAccessorParser(() => smaliSubannotationParser),
+			}),
+			createObjectParser({
+				kind: 'enum' as const,
+				value: smaliEnumValueParser,
+			}),
+			createObjectParser({
+				kind: 'string' as const,
+				value: smaliQuotedStringParser,
+			}),
+			createObjectParser({
+				kind: 'raw' as const,
+				value: smaliParametersMethodParser,
+			}),
+			createObjectParser({
+				kind: 'type' as const,
+				value: smaliTypeDescriptorParser,
+			}),
+			createObjectParser({
+				kind: 'raw' as const,
+				value: smaliNumberParser,
+			}),
+			createObjectParser({
+				kind: 'raw' as const,
+				value: true as const,
+				_true: createExactSequenceParser('true'),
+			}),
+			createObjectParser({
+				kind: 'raw' as const,
+				value: false as const,
+				_false: createExactSequenceParser('false'),
+			}),
 			promiseCompose(
 				createExactSequenceParser('null'),
 				() => ({ kind: 'raw' as const, value: null }),
 			),
-			promiseCompose(
-				createExactSequenceParser('{}'),
-				() => ({ kind: 'raw' as const, value: [] }),
-			),
+			createObjectParser({
+				kind: 'raw' as const,
+				value: [] as const,
+				_emptyBraces: createExactSequenceParser('{}'),
+			}),
 			promiseCompose(
 				createTupleParser([
 					createExactSequenceParser('{\n'),
@@ -862,27 +718,14 @@ const smaliAnnotationElementParser: Parser<SmaliAnnotationElement, string> = pro
 setParserName(smaliAnnotationElementParser, 'smaliAnnotationElementParser');
 
 // Now define the subannotation parser
-smaliSubannotationParser = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('.subannotation '),
-		smaliTypeDescriptorParser,
-		smaliLineEndPraser,
-		createArrayParser(smaliAnnotationElementParser),
-		smaliIndentationParser,
-		createExactSequenceParser('.end subannotation'),
-	]),
-	([
-		_subannotation,
-		type,
-		_newline,
-		elements,
-		_indentation,
-		_endSubannotation,
-	]) => ({
-		type,
-		elements,
-	}),
-);
+smaliSubannotationParser = createObjectParser({
+	_subannotation: createExactSequenceParser('.subannotation '),
+	type: smaliTypeDescriptorParser,
+	_newline: smaliLineEndPraser,
+	elements: createArrayParser(smaliAnnotationElementParser),
+	_indentation: smaliIndentationParser,
+	_endSubannotation: createExactSequenceParser('.end subannotation'),
+});
 
 setParserName(smaliSubannotationParser, 'smaliSubannotationParser');
 
@@ -892,38 +735,21 @@ type SmaliAnnotation = {
 	visibility: 'build' | 'runtime' | 'system';
 };
 
-export const smaliAnnotationParser: Parser<SmaliAnnotation, string> = promiseCompose(
-	createTupleParser([
-		smaliIndentationParser,
-		createExactSequenceParser('.annotation '),
-		createUnionParser<'build' | 'runtime' | 'system', string, string>([
-			createExactSequenceParser('build'),
-			createExactSequenceParser('runtime'),
-			createExactSequenceParser('system'),
-		]),
-		smaliSingleWhitespaceParser,
-		smaliTypeDescriptorParser,
-		smaliLineEndPraser,
-		createArrayParser(smaliAnnotationElementParser),
-		smaliIndentationParser,
-		createExactSequenceParser('.end annotation\n'),
+export const smaliAnnotationParser: Parser<SmaliAnnotation, string> = createObjectParser({
+	_indentation0: smaliIndentationParser,
+	_annotation: createExactSequenceParser('.annotation '),
+	visibility: createUnionParser([
+		createExactSequenceParser('build' as const),
+		createExactSequenceParser('runtime' as const),
+		createExactSequenceParser('system' as const),
 	]),
-	([
-		_indentation0,
-		_annotation,
-		visibility,
-		_space,
-		type,
-		_newline,
-		elements,
-		_indentation1,
-		_endAnnotation,
-	]) => ({
-		type,
-		elements,
-		visibility,
-	}),
-);
+	_space: smaliSingleWhitespaceParser,
+	type: smaliTypeDescriptorParser,
+	_newline: smaliLineEndPraser,
+	elements: createArrayParser(smaliAnnotationElementParser),
+	_indentation1: smaliIndentationParser,
+	_endAnnotation: createExactSequenceParser('.end annotation\n'),
+});
 
 setParserName(smaliAnnotationParser, 'smaliAnnotationParser');
 
@@ -949,7 +775,7 @@ export const smaliFieldParser: Parser<SmaliField, string> = promiseCompose(
 		createOptionalParser(promiseCompose(
 			createTupleParser([
 				createExactSequenceParser(' = '),
-				createUnionParser<number | bigint | string | boolean | null, string>([
+				createUnionParser([
 					smaliCharacterLiteralParser,
 					smaliFieldValueParser,
 					smaliQuotedStringParser,
@@ -1154,25 +980,16 @@ function isSmaliRegister(value: unknown): value is SmaliRegister {
 	);
 }
 
-const smaliParametersRegisterParser: Parser<SmaliRegister, string> = promiseCompose(
-	createUnionParser<['v' | 'p', number], string>([
-		createTupleParser([
-			createExactSequenceParser('v'),
-			smaliNumberParser,
-		]),
-		createTupleParser([
-			createExactSequenceParser('p'),
-			smaliNumberParser,
-		]),
-	]),
-	([
-		prefix,
-		index,
-	]) => ({
-		prefix,
-		index,
+const smaliParametersRegisterParser: Parser<SmaliRegister, string> = createUnionParser([
+	createObjectParser({
+		prefix: createExactSequenceParser('v' as const),
+		index: smaliNumberParser,
 	}),
-);
+	createObjectParser({
+		prefix: createExactSequenceParser('p' as const),
+		index: smaliNumberParser,
+	}),
+]);
 
 setParserName(smaliParametersRegisterParser, 'smaliParametersRegisterParser');
 
@@ -1180,6 +997,7 @@ type SmaliCodeLocal = {
 	register: SmaliRegister;
 	name: string | undefined;
 	type: string | undefined;
+	signature: string | undefined;
 };
 
 const smaliCodeLocalParser: Parser<SmaliCodeLocal, string> = promiseCompose(
@@ -1192,6 +1010,11 @@ const smaliCodeLocalParser: Parser<SmaliCodeLocal, string> = promiseCompose(
 			smaliQuotedStringParser,
 			createExactSequenceParser(':'),
 			smaliTypeDescriptorParser,
+			createOptionalParser(createTupleParser([
+				createExactSequenceParser(','),
+				smaliWhitespaceParser,
+				smaliQuotedStringParser,
+			])),
 		])),
 		smaliLineEndPraser,
 	]),
@@ -1203,6 +1026,7 @@ const smaliCodeLocalParser: Parser<SmaliCodeLocal, string> = promiseCompose(
 		register,
 		name: nameAndType?.[2],
 		type: nameAndType?.[4],
+		signature: nameAndType?.[5]?.[2],
 	}),
 );
 
@@ -1341,52 +1165,33 @@ type SmaliCatchDirective = {
 	handlerLabel: string;
 };
 
-const smaliCatchDirectiveParser: Parser<SmaliCatchDirective, string> = promiseCompose(
-	createTupleParser([
-		smaliIndentationParser,
-		createExactSequenceParser('.catch'),
-		createUnionParser<string | undefined, string, string>([
-			promiseCompose(
-				createExactSequenceParser('all'),
-				() => undefined as undefined,
-			),
-			promiseCompose(
-				createTupleParser([
-					createExactSequenceParser(' '),
-					smaliTypeDescriptorParser,
-				]),
-				([
-					_space,
-					type,
-				]) => type,
-			),
-		]),
-		createExactSequenceParser(' {'),
-		smaliCodeLabelParser,
-		createExactSequenceParser(' .. '),
-		smaliCodeLabelParser,
-		createExactSequenceParser('} '),
-		smaliCodeLabelParser,
-		smaliLineEndPraser,
+const smaliCatchDirectiveParser: Parser<SmaliCatchDirective, string> = createObjectParser({
+	_indentation: smaliIndentationParser,
+	_catch: createExactSequenceParser('.catch'),
+	type: createUnionParser([
+		promiseCompose(
+			createExactSequenceParser('all'),
+			() => undefined as undefined,
+		),
+		promiseCompose(
+			createTupleParser([
+				createExactSequenceParser(' '),
+				smaliTypeDescriptorParser,
+			]),
+			([
+				_space,
+				type,
+			]) => type,
+		),
 	]),
-	([
-		_indentation,
-		_catch,
-		type,
-		_openBrace,
-		startLabel,
-		_dots,
-		endLabel,
-		_closeBrace,
-		handlerLabel,
-		_newline,
-	]) => ({
-		type,
-		startLabel,
-		endLabel,
-		handlerLabel,
-	}),
-);
+	_openBrace: createExactSequenceParser(' {'),
+	startLabel: smaliCodeLabelParser,
+	_dots: createExactSequenceParser(' .. '),
+	endLabel: smaliCodeLabelParser,
+	_closeBrace: createExactSequenceParser('} '),
+	handlerLabel: smaliCodeLabelParser,
+	_newline: smaliLineEndPraser,
+});
 
 setParserName(smaliCatchDirectiveParser, 'smaliCatchDirectiveParser');
 
@@ -1395,23 +1200,12 @@ type SmaliLabeledCatchDirective = {
 	catchDirective: SmaliCatchDirective;
 };
 
-const smaliLabeledCatchDirectiveParser: Parser<SmaliLabeledCatchDirective, string> = promiseCompose(
-	createTupleParser([
-		createArrayParser(smaliCodeLineParser),
-		createOptionalParser(smaliCodeLocalParser),
-		createArrayParser(smaliCodeLabelLineParser),
-		smaliCatchDirectiveParser,
-	]),
-	([
-		_lines,
-		_local,
-		labels,
-		catchDirective,
-	]) => ({
-		labels,
-		catchDirective,
-	}),
-);
+const smaliLabeledCatchDirectiveParser: Parser<SmaliLabeledCatchDirective, string> = createObjectParser({
+	_lines: createArrayParser(smaliCodeLineParser),
+	_local: createOptionalParser(smaliCodeLocalParser),
+	labels: createArrayParser(smaliCodeLabelLineParser),
+	catchDirective: smaliCatchDirectiveParser,
+});
 
 setParserName(smaliLabeledCatchDirectiveParser, 'smaliLabeledCatchDirectiveParser');
 
@@ -1490,57 +1284,20 @@ const smaliParametersStringParser: Parser<string, string> = cloneParser(smaliQuo
 setParserName(smaliParametersStringParser, 'smaliParametersStringParser');
 
 const smaliParametersIntegerParser: Parser<number | bigint, string> = promiseCompose(
-	createTupleParser([
-		createOptionalParser(createExactSequenceParser('-')),
-		createExactSequenceParser('0x'),
-		async parserContext => {
-			const characters: string[] = [];
-
-			while (true) {
-				const character = await parserContext.peek(0);
-
-				parserContext.invariant(character !== undefined, 'Unexpected end of input');
-
-				invariant(character !== undefined, 'Unexpected end of input');
+	createRegExpParser(/-?0x([0-9a-fA-F]+)([Lts])?/),
+	match => {
+		const hexDigits = match[1]!;
+		const optionalSuffix = match[2];
 
-				if (
-					(character >= '0' && character <= '9')
-					|| (character >= 'a' && character <= 'f')
-					|| (character >= 'A' && character <= 'F')
-				) {
-					characters.push(character);
-
-					parserContext.skip(1);
-
-					continue;
-				}
-
-				break;
-			}
-
-			return characters.join('');
-		},
-		createOptionalParser(createUnionParser([
-			createExactSequenceParser('L'),
-			createExactSequenceParser('t'),
-			createExactSequenceParser('s'),
-		])),
-	]),
-	([
-		optionalMinus,
-		_0x,
-		value,
-		optionalSuffix,
-	]) => {
 		if (optionalSuffix === 'L') {
-			const sign = optionalMinus ? -1n : 1n;
+			const sign = match[0].startsWith('-') ? -1n : 1n;
 
-			return sign * BigInt('0x' + value);
+			return sign * BigInt('0x' + hexDigits);
 		}
 
-		const sign = optionalMinus ? -1 : 1;
+		const sign = match[0].startsWith('-') ? -1 : 1;
 
-		return sign * Number.parseInt(value, 16);
+		return sign * Number.parseInt(hexDigits, 16);
 	},
 );
 
@@ -1563,26 +1320,13 @@ const smaliParametersTypeParser: Parser<string, string> = cloneParser(smaliTypeD
 
 setParserName(smaliParametersTypeParser, 'smaliParametersTypeParser');
 
-const smaliParametersFieldParser: Parser<DalvikExecutableField, string> = promiseCompose(
-	createTupleParser([
-		smaliTypeDescriptorParser,
-		createExactSequenceParser('->'),
-		smaliMemberNameParser,
-		createExactSequenceParser(':'),
-		smaliTypeDescriptorParser,
-	]),
-	([
-		classPath,
-		_separator,
-		fieldName,
-		_colon,
-		type,
-	]) => ({
-		class: classPath,
-		name: fieldName,
-		type,
-	}),
-);
+const smaliParametersFieldParser: Parser<DalvikExecutableField, string> = createObjectParser({
+	class: smaliTypeDescriptorParser,
+	_separator: createExactSequenceParser('->'),
+	name: smaliMemberNameParser,
+	_colon: createExactSequenceParser(':'),
+	type: smaliTypeDescriptorParser,
+});
 
 setParserName(smaliParametersFieldParser, 'smaliParametersFieldParser');
 
@@ -1590,12 +1334,15 @@ type SmaliCodeOperationParameter =
 	| SmaliRegister
 	| SmaliRegister[]
 	| string
+	| number
+	| bigint
 	| DalvikExecutableMethod
+	| DalvikExecutableField
 ;
 
 const smaliCodeOperationParametersParser: Parser<SmaliCodeOperationParameter[], string> = createArrayParser(promiseCompose(
 	createTupleParser([
-		createUnionParser<SmaliCodeOperationParameter, string>([
+		createUnionParser([
 			smaliParametersRegisterParser,
 			smaliParametersRegistersParser,
 			smaliParametersStringParser,
@@ -1663,29 +1410,18 @@ type SmaliOneLineCodeOperation = {
 	parameters: SmaliCodeOperationParameter[];
 };
 
-const smaliOneLineCodeOperationParser: Parser<SmaliOneLineCodeOperation, string> = promiseCompose(
-	createTupleParser([
-		smaliSingleIndentationParser,
-		smaliCodeOperationNameParser,
-		promiseCompose(
-			createOptionalParser(createTupleParser([
-				smaliSingleWhitespaceParser,
-				smaliCodeOperationParametersParser,
-			])),
-			undefinedOrParameters => undefinedOrParameters === undefined ? [] : undefinedOrParameters[1],
-		),
-		smaliLineEndPraser,
-	]),
-	([
-		_indent,
-		operation,
-		parameters,
-		_newline,
-	]) => ({
-		operation,
-		parameters,
-	}),
-);
+const smaliOneLineCodeOperationParser: Parser<SmaliOneLineCodeOperation, string> = createObjectParser({
+	_indent: smaliSingleIndentationParser,
+	operation: smaliCodeOperationNameParser,
+	parameters: promiseCompose(
+		createOptionalParser(createTupleParser([
+			smaliSingleWhitespaceParser,
+			smaliCodeOperationParametersParser,
+		])),
+		undefinedOrParameters => undefinedOrParameters === undefined ? [] : undefinedOrParameters[1],
+	),
+	_newline: smaliLineEndPraser,
+});
 
 setParserName(smaliOneLineCodeOperationParser, 'smaliOneLineCodeOperationParser');
 
@@ -1841,17 +1577,21 @@ const smaliLooseCodeOperationParser: Parser<SmaliLooseCodeOperation, string> = c
 
 setParserName(smaliLooseCodeOperationParser, 'smaliLooseCodeOperationParser');
 
-type SmaliCodeOperationFromDalvikBytecodeOperation<T extends DalvikBytecodeOperation> =
-	T extends { branchOffsets: number[] }
-		? Simplify<Omit<T, 'branchOffsets'> & { branchOffsetIndices: number[] }>
-		: T extends { branchOffset: number }
-			? Simplify<Omit<T, 'branchOffset'> & { branchOffsetIndex: number }>
+// SmaliCodeOperation transforms DalvikBytecodeOperation:
+// - targetInstructionIndex -> branchOffsetIndex (intermediate form during parsing, relative)
+// - targetInstructionIndices -> branchOffsetIndices (intermediate form during parsing, relative)
+// - methodIndex -> method (resolved)
+type SmaliCodeOperationFromDalvikOperation<T extends DalvikBytecodeOperation> =
+	T extends { targetInstructionIndices: number[] }
+		? Simplify<Omit<T, 'targetInstructionIndices'> & { branchOffsetIndices: number[] }>
+		: T extends { targetInstructionIndex: number }
+			? Simplify<Omit<T, 'targetInstructionIndex'> & { branchOffsetIndex: number }>
 			: T extends { methodIndex: IndexIntoMethodIds }
 				? Simplify<Omit<T, 'methodIndex'> & { method: DalvikExecutableMethod }>
 				: T
 ;
 
-type SmaliCodeOperation = SmaliCodeOperationFromDalvikBytecodeOperation<DalvikBytecodeOperation>;
+type SmaliCodeOperation = SmaliCodeOperationFromDalvikOperation<DalvikBytecodeOperation>;
 
 export const smaliCodeOperationParser: Parser<SmaliCodeOperation, string> = promiseCompose(
 	smaliLooseCodeOperationParser,
@@ -2240,41 +1980,15 @@ const smaliExecutableCodeParser: Parser<SmaliExecutableCode<DalvikBytecode>, str
 			}
 		}
 
-		const branchOffsetByBranchOffsetIndex = new Map<number, number>();
-
-		let operationOffset = 0;
-
-		for (const [ operationIndex, operation ] of instructions.entries()) {
-			const operationSize = getOperationFormatSize(operation);
-
-			branchOffsetByBranchOffsetIndex.set(
-				operationIndex,
-				operationOffset,
-			);
-
-			operationOffset += operationSize;
-		}
-
+		// Convert branchOffsetIndex (relative) to targetInstructionIndex (absolute)
 		for (const [ operationIndex, operation ] of instructions.entries()) {
 			if (
 				'branchOffsetIndex' in operation
 				&& typeof operation.branchOffsetIndex === 'number'
 			) {
-				const operationOffset = branchOffsetByBranchOffsetIndex.get(operationIndex + operation.branchOffsetIndex);
-				invariant(
-					operationOffset !== undefined,
-					'Expected branch offset for operation index %s, but got undefined',
-					operation.branchOffsetIndex,
-				);
-
-				const branchOffset = branchOffsetByBranchOffsetIndex.get(operationIndex);
-				invariant(
-					branchOffset !== undefined,
-					'Expected branch offset for operation index %s, but got undefined',
-					operationIndex,
-				);
-
-				(operation as any).branchOffset = operationOffset - branchOffset;
+				// branchOffsetIndex is the relative instruction index from the label
+				// targetInstructionIndex is the absolute instruction index
+				(operation as any).targetInstructionIndex = operationIndex + operation.branchOffsetIndex;
 			}
 
 			if (
@@ -2297,22 +2011,11 @@ const smaliExecutableCodeParser: Parser<SmaliExecutableCode<DalvikBytecode>, str
 				const [ sourceOperation ] = sourceOperations;
 				const sourceOperationIndex = instructions.indexOf(sourceOperation);
 
-				(operation as any).branchOffsets = operation.branchOffsetIndices.map((branchOffsetIndex: number) => {
-					const operationOffset = branchOffsetByBranchOffsetIndex.get(sourceOperationIndex + branchOffsetIndex);
-					invariant(
-						operationOffset !== undefined,
-						'Expected branch offset for operation index %s, but got undefined',
-						sourceOperationIndex + branchOffsetIndex,
-					);
-
-					const branchOffset = branchOffsetByBranchOffsetIndex.get(sourceOperationIndex);
-					invariant(
-						branchOffset !== undefined,
-						'Expected branch offset for operation index %s, but got undefined',
-						sourceOperationIndex,
-					);
-
-					return operationOffset - branchOffset;
+				// For payload instructions, branchOffsetIndices contains instruction-relative indices
+				// from the source switch instruction. Convert to absolute instruction indices.
+				(operation as any).targetInstructionIndices = operation.branchOffsetIndices.map((branchOffsetIndex: number) => {
+					// branchOffsetIndex is relative to the source operation
+					return sourceOperationIndex + branchOffsetIndex;
 				});
 			}
 		}
@@ -2356,11 +2059,12 @@ const smaliExecutableCodeParser: Parser<SmaliExecutableCode<DalvikBytecode>, str
 		}
 
 		// Build tries array from catch directives
+		// Now using instruction indices directly instead of code unit offsets
 		const triesByRange = new Map<string, {
-			startAddress: number;
+			startInstructionIndex: number;
 			instructionCount: number;
-			handlers: Array<{ type: string; address: number }>;
-			catchAllAddress: number | undefined;
+			handlers: Array<{ type: string; handlerInstructionIndex: number }>;
+			catchAllInstructionIndex: number | undefined;
 		}>();
 
 		for (const catchDirective of catchDirectives) {
@@ -2373,56 +2077,64 @@ const smaliExecutableCodeParser: Parser<SmaliExecutableCode<DalvikBytecode>, str
 			invariant(endIndex !== undefined, 'Expected to find end label %s', catchDirective.endLabel);
 			invariant(handlerIndex !== undefined, 'Expected to find handler label %s', catchDirective.handlerLabel);
 
-			const startAddress = branchOffsetByBranchOffsetIndex.get(startIndex);
-			const endAddress = branchOffsetByBranchOffsetIndex.get(endIndex);
-			const handlerAddress = branchOffsetByBranchOffsetIndex.get(handlerIndex);
-
-			invariant(startAddress !== undefined, 'Expected start address for index %s', startIndex);
-			invariant(endAddress !== undefined, 'Expected end address for index %s', endIndex);
-			invariant(handlerAddress !== undefined, 'Expected handler address for index %s', handlerIndex);
+			// Use instruction indices directly
+			const startInstructionIndex = startIndex;
+			const instructionCount = endIndex - startIndex;
+			const handlerInstructionIndex = handlerIndex;
 
-			const instructionCount = endAddress - startAddress;
-			const rangeKey = `${startAddress}-${instructionCount}`;
+			const rangeKey = `${startInstructionIndex}-${instructionCount}`;
 
 			let tryEntry = triesByRange.get(rangeKey);
 			if (!tryEntry) {
 				tryEntry = {
-					startAddress,
+					startInstructionIndex,
 					instructionCount,
 					handlers: [],
-					catchAllAddress: undefined,
+					catchAllInstructionIndex: undefined as number | undefined,
 				};
 				triesByRange.set(rangeKey, tryEntry);
 			}
 
 			if (catchDirective.type === undefined) {
 				// .catchall
-				tryEntry.catchAllAddress = handlerAddress;
+				tryEntry.catchAllInstructionIndex = handlerInstructionIndex;
 			} else {
 				// .catch Type
 				tryEntry.handlers.push({
 					type: catchDirective.type,
-					address: handlerAddress,
+					handlerInstructionIndex,
 				});
 			}
 		}
 
 		const tries = Array.from(triesByRange.values()).map(tryEntry => ({
-			startAddress: tryEntry.startAddress,
+			startInstructionIndex: tryEntry.startInstructionIndex,
 			instructionCount: tryEntry.instructionCount,
 			handler: {
 				handlers: tryEntry.handlers,
-				catchAllAddress: tryEntry.catchAllAddress,
+				catchAllInstructionIndex: tryEntry.catchAllInstructionIndex,
 			},
 		}));
 
+		// Build debug info from debug directives
+		// Debug info still uses code unit offsets (addressDiff), so we need to build the mapping
+		// IMPORTANT: Must be done BEFORE deleting branchOffsetIndices, as getOperationSizeInCodeUnits uses it
+		const codeUnitOffsetByInstructionIndex = new Map<number, number>();
+		let codeUnitOffset = 0;
+		for (let i = 0; i < instructions.length; i++) {
+			codeUnitOffsetByInstructionIndex.set(i, codeUnitOffset);
+			codeUnitOffset += getOperationSizeInCodeUnits(instructions[i]);
+		}
+		codeUnitOffsetByInstructionIndex.set(instructions.length, codeUnitOffset);
+		// Alias for backward compatibility with debug info code
+		const branchOffsetByBranchOffsetIndex = codeUnitOffsetByInstructionIndex;
+
 		for (const operation of instructions) {
 			delete (operation as any).labels;
 			delete (operation as any).branchOffsetIndex;
 			delete (operation as any).branchOffsetIndices;
 		}
 
-		// Build debug info from debug directives
 		type DebugByteCodeValue = DalvikExecutableDebugInfo['bytecode'][number];
 		let debugInfo: DalvikExecutableDebugInfo | undefined;
 		const debugBytecode: DebugByteCodeValue[] = [];
@@ -2741,7 +2453,7 @@ export const smaliMethodParser: Parser<SmaliMethod<DalvikBytecode>, string> = pr
 			code.insSize = insSize;
 
 			for (const operation of code.instructions) {
-				const smaliRegisters = dalvikBytecodeOperationCompanion.getRegisters(operation) as unknown[] as SmaliRegister[]; // TODO
+				const smaliRegisters = rawDalvikBytecodeOperationCompanion.getRegisters(operation as RawDalvikBytecodeOperation) as unknown[] as SmaliRegister[]; // TODO
 
 				if (smaliRegisters.length === 0) {
 					continue;
@@ -2769,7 +2481,7 @@ export const smaliMethodParser: Parser<SmaliMethod<DalvikBytecode>, string> = pr
 					continue;
 				}
 
-				const registers = dalvikBytecodeOperationCompanion.getRegisters(operation);
+				const registers = rawDalvikBytecodeOperationCompanion.getRegisters(operation as RawDalvikBytecodeOperation);
 
 				outsSize = Math.max(outsSize, registers.length); // TODO?: two words for wide types?
 			}
@@ -2829,7 +2541,7 @@ type SmaliMethods = Pick<DalvikExecutableClassData<DalvikBytecode>, 'directMetho
 };
 
 const smaliMethodsParser: Parser<SmaliMethods, string> = promiseCompose(
-	createArrayParser<string[] | SmaliMethod<DalvikBytecode>, string>(createDisjunctionParser<string[] | SmaliMethod<DalvikBytecode>, string, string>([
+	createArrayParser(createDisjunctionParser([
 		smaliMethodParser,
 		smaliCommentsOrNewlinesParser,
 	])),