@futpib/parser 1.0.3 → 1.0.6

package/build/smaliParser.js

@@ -1,7 +1,9 @@
 import invariant from 'invariant';
-import { dalvikBytecodeOperationCompanion } from './dalvikBytecodeParser.js';
+import { rawDalvikBytecodeOperationCompanion } from './dalvikBytecodeParser.js';
+import { getOperationSizeInCodeUnits } from './dalvikBytecodeParser/addressConversion.js';
 import { dalvikExecutableAccessFlagsDefault, dalvikExecutableFieldEquals, dalvikExecutableMethodEquals, isDalvikExecutableField, isDalvikExecutableMethod, } from './dalvikExecutable.js';
 import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createObjectParser } from './objectParser.js';
 import { cloneParser, setParserName } from './parser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createTupleParser } from './tupleParser.js';
@@ -14,37 +16,17 @@ 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 { createElementParser } from './elementParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
+import { createRegExpParser } from './regexpParser.js';
 function shortyFromLongy(longy) {
     if (longy.startsWith('[')) {
         return 'L';
     }
     return longy.slice(0, 1);
 }
-function getOperationFormatSize(operation) {
-    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];
-    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) {
     const { kind, value } = wrappedValue;
@@ -141,22 +123,8 @@ const smaliSingleIndentationParser = createExactSequenceParser('    ');
 const smaliIndentationParser = promiseCompose(createArrayParser(smaliSingleIndentationParser), _indentation => undefined);
 export const smaliCommentParser = promiseCompose(createTupleParser([
     createExactSequenceParser('#'),
-    (async (parserContext) => {
-        const characters = [];
-        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, comment,]) => comment);
 const smaliIndentedCommentParser = promiseCompose(createTupleParser([
     createNonEmptyArrayParser(smaliSingleIndentationParser),
@@ -174,46 +142,18 @@ const smaliLineEndPraser = promiseCompose(createTupleParser([
         smaliCommentParser,
     ]),
 ]), ([_optionalWhitespace, newlineOrComment,]) => newlineOrComment);
-const smaliIdentifierParser = async (parserContext) => {
-    const characters = [];
-    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 = promiseCompose(createRegExpParser(/[a-zA-Z0-9_]+/), match => match[0]);
 setParserName(smaliIdentifierParser, 'smaliIdentifierParser');
-const elementParser = createElementParser();
-const smaliHexNumberParser = 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);
-        return character;
-    })()),
-    createOptionalParser(createExactSequenceParser('L')),
-]), ([optionalMinus, _0x, valueCharacters, optionalL,]) => {
-    const value = valueCharacters.join('');
+const smaliHexNumberParser = promiseCompose(createRegExpParser(/-?0x([0-9a-fA-F]+)(L)?/), match => {
+    const hexDigits = match[1];
+    const optionalL = match[2];
     // 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([
     promiseCompose(createTupleParser([
@@ -361,13 +301,11 @@ const smaliClassDeclarationParser = promiseCompose(createTupleParser([
     class: classPath,
 }));
 setParserName(smaliClassDeclarationParser, 'smaliClassDeclarationParser');
-const smaliSuperDeclarationParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('.super '),
-    smaliTypeDescriptorParser,
-    smaliLineEndPraser,
-]), ([_super, superclass, _newline,]) => ({
-    superclass,
-}));
+const smaliSuperDeclarationParser = createObjectParser({
+    _super: createExactSequenceParser('.super '),
+    superclass: smaliTypeDescriptorParser,
+    _newline: smaliLineEndPraser,
+});
 setParserName(smaliSuperDeclarationParser, 'smaliSuperDeclarationParser');
 const smaliInterfaceDeclarationParser = promiseCompose(createTupleParser([
     createExactSequenceParser('.implements '),
@@ -375,25 +313,19 @@ const smaliInterfaceDeclarationParser = promiseCompose(createTupleParser([
     smaliLineEndPraser,
 ]), ([_interface, interface_, _newline,]) => interface_);
 setParserName(smaliInterfaceDeclarationParser, 'smaliInterfaceDeclarationParser');
-const smaliSourceDeclarationParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('.source '),
-    smaliQuotedStringParser,
-    smaliLineEndPraser,
-]), ([_source, sourceFile, _newline,]) => ({
-    sourceFile,
-}));
-const smaliEnumValueParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('.enum '),
-    smaliTypeDescriptorParser,
-    createExactSequenceParser('->'),
-    smaliMemberNameParser,
-    createExactSequenceParser(':'),
-    smaliTypeDescriptorParser,
-]), ([_enum, classType, _arrow, fieldName, _colon, fieldType,]) => ({
-    class: classType,
-    type: fieldType,
-    name: fieldName,
-}));
+const smaliSourceDeclarationParser = createObjectParser({
+    _source: createExactSequenceParser('.source '),
+    sourceFile: smaliQuotedStringParser,
+    _newline: smaliLineEndPraser,
+});
+const smaliEnumValueParser = createObjectParser({
+    _enum: createExactSequenceParser('.enum '),
+    class: smaliTypeDescriptorParser,
+    _arrow: createExactSequenceParser('->'),
+    name: smaliMemberNameParser,
+    _colon: createExactSequenceParser(':'),
+    type: smaliTypeDescriptorParser,
+});
 setParserName(smaliEnumValueParser, 'smaliEnumValueParser');
 const smaliMethodPrototypeParser = promiseCompose(createTupleParser([
     createExactSequenceParser('('),
@@ -411,16 +343,12 @@ const smaliMethodPrototypeParser = promiseCompose(createTupleParser([
     }).join(''),
 }));
 setParserName(smaliMethodPrototypeParser, 'smaliMethodPrototypeParser');
-const smaliParametersMethodParser = promiseCompose(createTupleParser([
-    smaliTypeDescriptorParser,
-    createExactSequenceParser('->'),
-    smaliMemberNameParser,
-    smaliMethodPrototypeParser,
-]), ([classPath, _separator, methodName, prototype,]) => ({
-    class: classPath,
-    prototype,
-    name: methodName,
-}));
+const smaliParametersMethodParser = createObjectParser({
+    class: smaliTypeDescriptorParser,
+    _separator: createExactSequenceParser('->'),
+    name: smaliMemberNameParser,
+    prototype: smaliMethodPrototypeParser,
+});
 setParserName(smaliParametersMethodParser, 'smaliParametersMethodParser');
 // Forward declaration to handle circular reference
 let smaliSubannotationParser;
@@ -429,16 +357,46 @@ const smaliAnnotationElementParser = promiseCompose(createTupleParser([
     smaliIdentifierParser,
     createExactSequenceParser(' = '),
     createDisjunctionParser([
-        promiseCompose(createParserAccessorParser(() => smaliSubannotationParser), value => ({ kind: 'raw', value })),
-        promiseCompose(smaliEnumValueParser, value => ({ kind: 'enum', value })),
-        promiseCompose(smaliQuotedStringParser, value => ({ kind: 'string', value })),
-        promiseCompose(smaliParametersMethodParser, value => ({ kind: 'raw', value })),
-        promiseCompose(smaliTypeDescriptorParser, value => ({ kind: 'type', value })),
-        promiseCompose(smaliNumberParser, value => ({ kind: 'raw', value })),
-        promiseCompose(createExactSequenceParser('true'), () => ({ kind: 'raw', value: true })),
-        promiseCompose(createExactSequenceParser('false'), () => ({ kind: 'raw', value: false })),
+        createObjectParser({
+            kind: 'raw',
+            value: createParserAccessorParser(() => smaliSubannotationParser),
+        }),
+        createObjectParser({
+            kind: 'enum',
+            value: smaliEnumValueParser,
+        }),
+        createObjectParser({
+            kind: 'string',
+            value: smaliQuotedStringParser,
+        }),
+        createObjectParser({
+            kind: 'raw',
+            value: smaliParametersMethodParser,
+        }),
+        createObjectParser({
+            kind: 'type',
+            value: smaliTypeDescriptorParser,
+        }),
+        createObjectParser({
+            kind: 'raw',
+            value: smaliNumberParser,
+        }),
+        createObjectParser({
+            kind: 'raw',
+            value: true,
+            _true: createExactSequenceParser('true'),
+        }),
+        createObjectParser({
+            kind: 'raw',
+            value: false,
+            _false: createExactSequenceParser('false'),
+        }),
         promiseCompose(createExactSequenceParser('null'), () => ({ kind: 'raw', value: null })),
-        promiseCompose(createExactSequenceParser('{}'), () => ({ kind: 'raw', value: [] })),
+        createObjectParser({
+            kind: 'raw',
+            value: [],
+            _emptyBraces: createExactSequenceParser('{}'),
+        }),
         promiseCompose(createTupleParser([
             createExactSequenceParser('{\n'),
             createSeparatedArrayParser(promiseCompose(createTupleParser([
@@ -487,37 +445,30 @@ const smaliAnnotationElementParser = promiseCompose(createTupleParser([
 }));
 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');
-export const smaliAnnotationParser = promiseCompose(createTupleParser([
-    smaliIndentationParser,
-    createExactSequenceParser('.annotation '),
-    createUnionParser([
+export const smaliAnnotationParser = createObjectParser({
+    _indentation0: smaliIndentationParser,
+    _annotation: createExactSequenceParser('.annotation '),
+    visibility: createUnionParser([
         createExactSequenceParser('build'),
         createExactSequenceParser('runtime'),
         createExactSequenceParser('system'),
     ]),
-    smaliSingleWhitespaceParser,
-    smaliTypeDescriptorParser,
-    smaliLineEndPraser,
-    createArrayParser(smaliAnnotationElementParser),
-    smaliIndentationParser,
-    createExactSequenceParser('.end annotation\n'),
-]), ([_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');
 export const smaliFieldParser = promiseCompose(createTupleParser([
     createExactSequenceParser('.field '),
@@ -640,19 +591,16 @@ function isSmaliRegister(value) {
         && typeof value.prefix === 'string'
         && typeof value.index === 'number');
 }
-const smaliParametersRegisterParser = promiseCompose(createUnionParser([
-    createTupleParser([
-        createExactSequenceParser('v'),
-        smaliNumberParser,
-    ]),
-    createTupleParser([
-        createExactSequenceParser('p'),
-        smaliNumberParser,
-    ]),
-]), ([prefix, index,]) => ({
-    prefix,
-    index,
-}));
+const smaliParametersRegisterParser = createUnionParser([
+    createObjectParser({
+        prefix: createExactSequenceParser('v'),
+        index: smaliNumberParser,
+    }),
+    createObjectParser({
+        prefix: createExactSequenceParser('p'),
+        index: smaliNumberParser,
+    }),
+]);
 setParserName(smaliParametersRegisterParser, 'smaliParametersRegisterParser');
 const smaliCodeLocalParser = promiseCompose(createTupleParser([
     createExactSequenceParser('    .local '),
@@ -663,12 +611,18 @@ const smaliCodeLocalParser = promiseCompose(createTupleParser([
         smaliQuotedStringParser,
         createExactSequenceParser(':'),
         smaliTypeDescriptorParser,
+        createOptionalParser(createTupleParser([
+            createExactSequenceParser(','),
+            smaliWhitespaceParser,
+            smaliQuotedStringParser,
+        ])),
     ])),
     smaliLineEndPraser,
 ]), ([_local, register, nameAndType,]) => ({
     register,
     name: nameAndType?.[2],
     type: nameAndType?.[4],
+    signature: nameAndType?.[5]?.[2],
 }));
 setParserName(smaliCodeLocalParser, 'smaliCodeLocalParser');
 const smaliCodeEndLocalParser = promiseCompose(createTupleParser([
@@ -732,39 +686,31 @@ const smaliCodeLabelLineParser = promiseCompose(createTupleParser([
     smaliLineEndPraser,
 ]), ([_label, label, _newlabel,]) => label);
 setParserName(smaliCodeLabelLineParser, 'smaliCodeLabelLineParser');
-const smaliCatchDirectiveParser = promiseCompose(createTupleParser([
-    smaliIndentationParser,
-    createExactSequenceParser('.catch'),
-    createUnionParser([
+const smaliCatchDirectiveParser = createObjectParser({
+    _indentation: smaliIndentationParser,
+    _catch: createExactSequenceParser('.catch'),
+    type: createUnionParser([
         promiseCompose(createExactSequenceParser('all'), () => undefined),
         promiseCompose(createTupleParser([
             createExactSequenceParser(' '),
             smaliTypeDescriptorParser,
         ]), ([_space, type,]) => type),
     ]),
-    createExactSequenceParser(' {'),
-    smaliCodeLabelParser,
-    createExactSequenceParser(' .. '),
-    smaliCodeLabelParser,
-    createExactSequenceParser('} '),
-    smaliCodeLabelParser,
-    smaliLineEndPraser,
-]), ([_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');
-const smaliLabeledCatchDirectiveParser = promiseCompose(createTupleParser([
-    createArrayParser(smaliCodeLineParser),
-    createOptionalParser(smaliCodeLocalParser),
-    createArrayParser(smaliCodeLabelLineParser),
-    smaliCatchDirectiveParser,
-]), ([_lines, _local, labels, catchDirective,]) => ({
-    labels,
-    catchDirective,
-}));
+const smaliLabeledCatchDirectiveParser = createObjectParser({
+    _lines: createArrayParser(smaliCodeLineParser),
+    _local: createOptionalParser(smaliCodeLocalParser),
+    labels: createArrayParser(smaliCodeLabelLineParser),
+    catchDirective: smaliCatchDirectiveParser,
+});
 setParserName(smaliLabeledCatchDirectiveParser, 'smaliLabeledCatchDirectiveParser');
 const smaliParametersRegisterRangeParser = promiseCompose(createTupleParser([
     createExactSequenceParser('{'),
@@ -801,38 +747,15 @@ const smaliParametersRegistersParser = createUnionParser([
 setParserName(smaliParametersRegistersParser, 'smaliParametersRegistersParser');
 const smaliParametersStringParser = cloneParser(smaliQuotedStringParser);
 setParserName(smaliParametersStringParser, 'smaliParametersStringParser');
-const smaliParametersIntegerParser = promiseCompose(createTupleParser([
-    createOptionalParser(createExactSequenceParser('-')),
-    createExactSequenceParser('0x'),
-    async (parserContext) => {
-        const characters = [];
-        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 >= '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,]) => {
+const smaliParametersIntegerParser = promiseCompose(createRegExpParser(/-?0x([0-9a-fA-F]+)([Lts])?/), match => {
+    const hexDigits = match[1];
+    const optionalSuffix = match[2];
     if (optionalSuffix === 'L') {
-        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);
 });
 setParserName(smaliParametersIntegerParser, 'smaliParametersIntegerParser');
 const smaliParametersLabelParser = promiseCompose(createTupleParser([
@@ -842,17 +765,13 @@ const smaliParametersLabelParser = promiseCompose(createTupleParser([
 setParserName(smaliParametersLabelParser, 'smaliParametersLabelParser');
 const smaliParametersTypeParser = cloneParser(smaliTypeDescriptorParser);
 setParserName(smaliParametersTypeParser, 'smaliParametersTypeParser');
-const smaliParametersFieldParser = promiseCompose(createTupleParser([
-    smaliTypeDescriptorParser,
-    createExactSequenceParser('->'),
-    smaliMemberNameParser,
-    createExactSequenceParser(':'),
-    smaliTypeDescriptorParser,
-]), ([classPath, _separator, fieldName, _colon, type,]) => ({
-    class: classPath,
-    name: fieldName,
-    type,
-}));
+const smaliParametersFieldParser = createObjectParser({
+    class: smaliTypeDescriptorParser,
+    _separator: createExactSequenceParser('->'),
+    name: smaliMemberNameParser,
+    _colon: createExactSequenceParser(':'),
+    type: smaliTypeDescriptorParser,
+});
 setParserName(smaliParametersFieldParser, 'smaliParametersFieldParser');
 const smaliCodeOperationParametersParser = createArrayParser(promiseCompose(createTupleParser([
     createUnionParser([
@@ -884,18 +803,15 @@ const smaliCodeOperationNameParser = promiseCompose(createTupleParser([
     ]), ([slash, name]) => slash + name)),
 ]), ([name, optionalSlashName,]) => name + (optionalSlashName || ''));
 setParserName(smaliCodeOperationNameParser, 'smaliCodeOperationNameParser');
-const smaliOneLineCodeOperationParser = promiseCompose(createTupleParser([
-    smaliSingleIndentationParser,
-    smaliCodeOperationNameParser,
-    promiseCompose(createOptionalParser(createTupleParser([
+const smaliOneLineCodeOperationParser = createObjectParser({
+    _indent: smaliSingleIndentationParser,
+    operation: smaliCodeOperationNameParser,
+    parameters: promiseCompose(createOptionalParser(createTupleParser([
         smaliSingleWhitespaceParser,
         smaliCodeOperationParametersParser,
     ])), undefinedOrParameters => undefinedOrParameters === undefined ? [] : undefinedOrParameters[1]),
-    smaliLineEndPraser,
-]), ([_indent, operation, parameters, _newline,]) => ({
-    operation,
-    parameters,
-}));
+    _newline: smaliLineEndPraser,
+});
 setParserName(smaliOneLineCodeOperationParser, 'smaliOneLineCodeOperationParser');
 const createMultilineSmaliCodeOperationLabelsBodyParser = operationName => promiseCompose(createTupleParser([
     createArrayParser(promiseCompose(createTupleParser([
@@ -1223,21 +1139,13 @@ const smaliExecutableCodeParser = promiseCompose(createTupleParser([
             delete operation.branchLabels;
         }
     }
-    const branchOffsetByBranchOffsetIndex = new Map();
-    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.branchOffset = operationOffset - branchOffset;
+            // branchOffsetIndex is the relative instruction index from the label
+            // targetInstructionIndex is the absolute instruction index
+            operation.targetInstructionIndex = operationIndex + operation.branchOffsetIndex;
         }
         if ('branchOffsetIndices' in operation
             && typeof operation.branchOffsetIndices === 'object'
@@ -1248,12 +1156,11 @@ const smaliExecutableCodeParser = promiseCompose(createTupleParser([
             invariant(sourceOperations.length === 1, 'Expected exactly one source operation to point to %s', JSON.stringify(operation));
             const [sourceOperation] = sourceOperations;
             const sourceOperationIndex = instructions.indexOf(sourceOperation);
-            operation.branchOffsets = operation.branchOffsetIndices.map((branchOffsetIndex) => {
-                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.targetInstructionIndices = operation.branchOffsetIndices.map((branchOffsetIndex) => {
+                // branchOffsetIndex is relative to the source operation
+                return sourceOperationIndex + branchOffsetIndex;
             });
         }
     }
@@ -1292,6 +1199,7 @@ const smaliExecutableCodeParser = promiseCompose(createTupleParser([
         }
     }
     // Build tries array from catch directives
+    // Now using instruction indices directly instead of code unit offsets
     const triesByRange = new Map();
     for (const catchDirective of catchDirectives) {
         // Find the start and end instruction indices
@@ -1301,44 +1209,53 @@ const smaliExecutableCodeParser = promiseCompose(createTupleParser([
         invariant(startIndex !== undefined, 'Expected to find start label %s', catchDirective.startLabel);
         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);
-        const instructionCount = endAddress - startAddress;
-        const rangeKey = `${startAddress}-${instructionCount}`;
+        // Use instruction indices directly
+        const startInstructionIndex = startIndex;
+        const instructionCount = endIndex - startIndex;
+        const handlerInstructionIndex = handlerIndex;
+        const rangeKey = `${startInstructionIndex}-${instructionCount}`;
         let tryEntry = triesByRange.get(rangeKey);
         if (!tryEntry) {
             tryEntry = {
-                startAddress,
+                startInstructionIndex,
                 instructionCount,
                 handlers: [],
-                catchAllAddress: undefined,
+                catchAllInstructionIndex: 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();
+    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.labels;
         delete operation.branchOffsetIndex;
@@ -1603,7 +1520,7 @@ export const smaliMethodParser = promiseCompose(createTupleParser([
         const insSize = (accessFlags.static ? 0 : 1) + shortyGetInsSize(prototype.shorty);
         code.insSize = insSize;
         for (const operation of code.instructions) {
-            const smaliRegisters = dalvikBytecodeOperationCompanion.getRegisters(operation); // TODO
+            const smaliRegisters = rawDalvikBytecodeOperationCompanion.getRegisters(operation); // TODO
             if (smaliRegisters.length === 0) {
                 continue;
             }
@@ -1623,7 +1540,7 @@ export const smaliMethodParser = promiseCompose(createTupleParser([
             if (!operation.operation.startsWith('invoke-')) {
                 continue;
             }
-            const registers = dalvikBytecodeOperationCompanion.getRegisters(operation);
+            const registers = rawDalvikBytecodeOperationCompanion.getRegisters(operation);
             outsSize = Math.max(outsSize, registers.length); // TODO?: two words for wide types?
         }
         code.outsSize = outsSize;