@futpib/parser 1.0.1 → 1.0.3

package/build/smaliParser.js

@@ -0,0 +1,2081 @@
+import invariant from 'invariant';
+import { dalvikBytecodeOperationCompanion } from './dalvikBytecodeParser.js';
+import { dalvikExecutableAccessFlagsDefault, dalvikExecutableFieldEquals, dalvikExecutableMethodEquals, isDalvikExecutableField, isDalvikExecutableMethod, } from './dalvikExecutable.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { cloneParser, setParserName } from './parser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createUnionParser } from './unionParser.js';
+import { createArrayParser } from './arrayParser.js';
+import { jsonNumberParser, jsonStringParser } from './jsonParser.js';
+import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
+import { createOptionalParser } from './optionalParser.js';
+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';
+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;
+    // Handle type descriptors
+    if (kind === 'type') {
+        if (Array.isArray(value)) {
+            // Array of type descriptors
+            return { type: 'array', value: value.map(v => ({ type: 'type', value: v })) };
+        }
+        // Single type descriptor
+        return { type: 'type', value };
+    }
+    // Handle string literals
+    if (kind === 'string') {
+        if (Array.isArray(value)) {
+            // Array of strings
+            return { type: 'array', value: value.map(v => ({ type: 'string', value: v })) };
+        }
+        // Single string
+        return { type: 'string', value };
+    }
+    // Handle enum values
+    if (kind === 'enum') {
+        if (Array.isArray(value)) {
+            // Array of enum values
+            return { type: 'array', value: value.map(v => ({ type: 'enum', value: v })) };
+        }
+        // Single enum value
+        return { type: 'enum', value };
+    }
+    // Handle raw values (everything else)
+    // Handle null
+    if (value === null) {
+        return { type: 'null', value: null };
+    }
+    // Handle boolean
+    if (typeof value === 'boolean') {
+        return { type: 'boolean', value };
+    }
+    // Handle numbers - we need to determine the type based on context
+    // For annotation elements from smali, we'll use 'int' as the default
+    if (typeof value === 'number') {
+        // Check if it's a float or integer
+        if (!Number.isInteger(value)) {
+            return { type: 'float', value };
+        }
+        // For integers, default to 'int' type
+        // The actual byte/short/int distinction would need more context
+        return { type: 'int', value };
+    }
+    // Handle bigint
+    if (typeof value === 'bigint') {
+        return { type: 'long', value };
+    }
+    // Handle DalvikExecutableField (including enums)
+    if (isDalvikExecutableField(value)) {
+        // Note: We can't distinguish between 'field' and 'enum' without more context
+        // Default to 'field' type - the context in smali might help distinguish later
+        return { type: 'field', value };
+    }
+    // Handle DalvikExecutableMethod
+    if (isDalvikExecutableMethod(value)) {
+        return { type: 'method', value };
+    }
+    // Handle DalvikExecutablePrototype (method type)
+    if (typeof value === 'object' && value !== null && 'returnType' in value && 'parameters' in value && 'shorty' in value) {
+        return { type: 'methodType', value: value };
+    }
+    // Handle annotations (subannotations)
+    if (typeof value === 'object' && value !== null && 'type' in value && 'elements' in value) {
+        const subannotation = value;
+        // Convert subannotation to DalvikExecutableAnnotation
+        const annotation = {
+            type: subannotation.type,
+            visibility: 'build', // Subannotations default to 'build' visibility
+            elements: subannotation.elements.map(element => ({
+                name: element.name,
+                value: convertToTaggedEncodedValue(element.value),
+            })),
+        };
+        return { type: 'annotation', value: annotation };
+    }
+    // Handle arrays
+    if (Array.isArray(value)) {
+        return { type: 'array', value: value.map(v => convertToTaggedEncodedValue({ kind: 'raw', value: v })) };
+    }
+    // Fallback - this shouldn't happen in well-formed smali
+    throw new Error(`Cannot convert value to tagged encoded value: ${JSON.stringify(value)}`);
+}
+const smaliNewlinesParser = promiseCompose(createNonEmptyArrayParser(createExactSequenceParser('\n')), _newlines => undefined);
+const smaliSingleWhitespaceParser = createExactSequenceParser(' ');
+const smaliWhitespaceParser = promiseCompose(createArrayParser(smaliSingleWhitespaceParser), _indentation => undefined);
+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('');
+    }),
+]), ([_hash, comment,]) => comment);
+const smaliIndentedCommentParser = promiseCompose(createTupleParser([
+    createNonEmptyArrayParser(smaliSingleIndentationParser),
+    smaliCommentParser,
+]), ([_indentation, comment,]) => comment);
+const smaliCommentsOrNewlinesParser = promiseCompose(createArrayParser(createUnionParser([
+    smaliNewlinesParser,
+    smaliIndentedCommentParser,
+    smaliCommentParser,
+])), newlinesOrComments => newlinesOrComments.filter((newlineOrComment) => typeof newlineOrComment === 'string'));
+const smaliLineEndPraser = promiseCompose(createTupleParser([
+    createOptionalParser(smaliWhitespaceParser),
+    createUnionParser([
+        smaliNewlinesParser,
+        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('');
+};
+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('');
+    // 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 = optionalMinus ? -1 : 1;
+    return sign * Number.parseInt(value, 16);
+});
+const smaliNumberParser = createUnionParser([
+    promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createUnionParser([
+            createExactSequenceParser('0x'),
+            createExactSequenceParser('-0x'),
+        ])),
+        jsonNumberParser,
+        createOptionalParser(createUnionParser([
+            createExactSequenceParser('f'),
+            createExactSequenceParser('F'),
+        ])),
+    ]), ([_not0x, number, optionalFloatSuffix,]) => {
+        // If there's an 'f' or 'F' suffix, convert to 32-bit float precision
+        // to match what would be stored in a DEX file
+        if (optionalFloatSuffix) {
+            const float32Array = new Float32Array(1);
+            float32Array[0] = number;
+            return float32Array[0];
+        }
+        return number;
+    }),
+    promiseCompose(smaliHexNumberParser, value => {
+        // For smaliNumberParser, we need to ensure we return a number
+        // BigInt values from hex parser should be converted if they fit in number range
+        if (typeof value === 'bigint') {
+            // This shouldn't happen in contexts where smaliNumberParser is used
+            // (registers, line numbers, etc) but if it does, convert to number
+            return Number(value);
+        }
+        return value;
+    }),
+]);
+setParserName(smaliNumberParser, 'smaliNumberParser');
+// Parser for field initial values that can include BigInt
+const smaliFieldValueParser = createUnionParser([
+    promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createUnionParser([
+            createExactSequenceParser('0x'),
+            createExactSequenceParser('-0x'),
+        ])),
+        jsonNumberParser,
+        createOptionalParser(createUnionParser([
+            createExactSequenceParser('f'),
+            createExactSequenceParser('F'),
+        ])),
+    ]), ([_not0x, number, optionalFloatSuffix,]) => {
+        // If there's an 'f' or 'F' suffix, convert to 32-bit float precision
+        // to match what would be stored in a DEX file
+        if (optionalFloatSuffix) {
+            const float32Array = new Float32Array(1);
+            float32Array[0] = number;
+            return float32Array[0];
+        }
+        return number;
+    }),
+    smaliHexNumberParser,
+]);
+const smaliQuotedStringParser = promiseCompose(jsonStringParser, string => string.replaceAll(String.raw `\'`, '\''));
+// Parser for smali character literals (e.g., 'a', ':', '\'', '\\')
+const smaliCharacterLiteralParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\''),
+    createDisjunctionParser([
+        // Handle escape sequences (must come before regular characters)
+        promiseCompose(createExactSequenceParser(String.raw `\\`), () => '\\'),
+        promiseCompose(createExactSequenceParser(String.raw `\'`), () => '\''),
+        promiseCompose(createExactSequenceParser(String.raw `\"`), () => '"'),
+        promiseCompose(createExactSequenceParser(String.raw `\n`), () => '\n'),
+        promiseCompose(createExactSequenceParser(String.raw `\r`), () => '\r'),
+        promiseCompose(createExactSequenceParser(String.raw `\t`), () => '\t'),
+        promiseCompose(createExactSequenceParser(String.raw `\b`), () => '\b'),
+        promiseCompose(createExactSequenceParser(String.raw `\f`), () => '\f'),
+        // Handle regular characters (not a single quote)
+        parserCreatorCompose(() => createElementParser(), character => async (parserContext) => {
+            parserContext.invariant(character !== '\'', 'Unexpected single quote');
+            return character;
+        })(),
+    ]),
+    createExactSequenceParser('\''),
+]), ([, character]) => character.charCodeAt(0));
+setParserName(smaliCharacterLiteralParser, 'smaliCharacterLiteralParser');
+// Parser that matches identifier continuation characters (letters, digits, $, -, _)
+const smaliIdentifierContinuationParser = async (parserContext) => {
+    const character = await parserContext.peek(0);
+    parserContext.invariant(character !== undefined, 'Unexpected end of input');
+    invariant(character !== undefined, 'Unexpected end of input');
+    parserContext.invariant((character >= 'a' && character <= 'z')
+        || (character >= 'A' && character <= 'Z')
+        || (character >= '0' && character <= '9')
+        || character === '$'
+        || character === '-'
+        || character === '_', 'Expected identifier continuation character, got "%s"', character);
+    parserContext.skip(1);
+    return character;
+};
+setParserName(smaliIdentifierContinuationParser, 'smaliIdentifierContinuationParser');
+// Helper to create an access flag parser with word boundary check
+const createAccessFlagParser = (keyword) => promiseCompose(createTupleParser([
+    createExactSequenceParser(keyword),
+    createNegativeLookaheadParser(smaliIdentifierContinuationParser),
+]), ([flag]) => flag);
+const smaliAccessFlagsParser = promiseCompose(createSeparatedArrayParser(createUnionParser([
+    createAccessFlagParser('public'),
+    createAccessFlagParser('protected'),
+    createAccessFlagParser('private'),
+    createAccessFlagParser('final'),
+    createAccessFlagParser('bridge'),
+    createAccessFlagParser('synthetic'),
+    createAccessFlagParser('varargs'),
+    createAccessFlagParser('static'),
+    createAccessFlagParser('constructor'),
+    createAccessFlagParser('abstract'),
+    createAccessFlagParser('native'),
+    createAccessFlagParser('volatile'),
+    createAccessFlagParser('transient'),
+    createAccessFlagParser('synchronized'),
+    createAccessFlagParser('declared-synchronized'),
+    createAccessFlagParser('strict'),
+    createAccessFlagParser('interface'),
+    createAccessFlagParser('annotation'),
+    createAccessFlagParser('enum'),
+]), smaliSingleWhitespaceParser), accessFlagNames => {
+    const accessFlags = dalvikExecutableAccessFlagsDefault();
+    for (const accessFlagName of accessFlagNames) {
+        if (accessFlagName === 'declared-synchronized') {
+            accessFlags.declaredSynchronized = true;
+        }
+        else {
+            accessFlags[accessFlagName] = true;
+        }
+    }
+    return accessFlags;
+});
+const smaliClassDeclarationParser = promiseCompose(createTupleParser([
+    smaliCommentsOrNewlinesParser,
+    createExactSequenceParser('.class '),
+    createOptionalParser(promiseCompose(createTupleParser([
+        smaliAccessFlagsParser,
+        smaliSingleWhitespaceParser,
+    ]), ([accessFlags,]) => accessFlags)),
+    smaliTypeDescriptorParser,
+    smaliLineEndPraser,
+]), ([_commentsOrNewlines, _dotClass, accessFlags = dalvikExecutableAccessFlagsDefault(), classPath,]) => ({
+    accessFlags,
+    class: classPath,
+}));
+setParserName(smaliClassDeclarationParser, 'smaliClassDeclarationParser');
+const smaliSuperDeclarationParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.super '),
+    smaliTypeDescriptorParser,
+    smaliLineEndPraser,
+]), ([_super, superclass, _newline,]) => ({
+    superclass,
+}));
+setParserName(smaliSuperDeclarationParser, 'smaliSuperDeclarationParser');
+const smaliInterfaceDeclarationParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.implements '),
+    smaliTypeDescriptorParser,
+    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,
+}));
+setParserName(smaliEnumValueParser, 'smaliEnumValueParser');
+const smaliMethodPrototypeParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    createArrayParser(smaliTypeDescriptorParser),
+    createExactSequenceParser(')'),
+    smaliTypeDescriptorParser,
+]), ([_openParenthesis, parameters, _closeParenthesis, returnType,]) => ({
+    parameters,
+    returnType,
+    shorty: shortyFromLongy(returnType) + parameters.map(parameter => {
+        if (parameter === 'V') {
+            return '';
+        }
+        return shortyFromLongy(parameter);
+    }).join(''),
+}));
+setParserName(smaliMethodPrototypeParser, 'smaliMethodPrototypeParser');
+const smaliParametersMethodParser = promiseCompose(createTupleParser([
+    smaliTypeDescriptorParser,
+    createExactSequenceParser('->'),
+    smaliMemberNameParser,
+    smaliMethodPrototypeParser,
+]), ([classPath, _separator, methodName, prototype,]) => ({
+    class: classPath,
+    prototype,
+    name: methodName,
+}));
+setParserName(smaliParametersMethodParser, 'smaliParametersMethodParser');
+// Forward declaration to handle circular reference
+let smaliSubannotationParser;
+const smaliAnnotationElementParser = promiseCompose(createTupleParser([
+    smaliIndentationParser,
+    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 })),
+        promiseCompose(createExactSequenceParser('null'), () => ({ kind: 'raw', value: null })),
+        promiseCompose(createExactSequenceParser('{}'), () => ({ kind: 'raw', value: [] })),
+        promiseCompose(createTupleParser([
+            createExactSequenceParser('{\n'),
+            createSeparatedArrayParser(promiseCompose(createTupleParser([
+                smaliIndentationParser,
+                smaliEnumValueParser,
+            ]), ([_indentation, value,]) => value), createExactSequenceParser(',\n')),
+            smaliLineEndPraser,
+            smaliIndentationParser,
+            createExactSequenceParser('}'),
+        ]), ([_openBrace, value, _closeBrace,]) => ({ kind: 'enum', value })),
+        promiseCompose(createTupleParser([
+            createExactSequenceParser('{\n'),
+            createSeparatedArrayParser(promiseCompose(createTupleParser([
+                smaliIndentationParser,
+                smaliTypeDescriptorParser,
+            ]), ([_indentation, value,]) => value), createExactSequenceParser(',\n')),
+            smaliLineEndPraser,
+            smaliIndentationParser,
+            createExactSequenceParser('}'),
+        ]), ([_openBrace, value, _closeBrace,]) => ({ kind: 'type', value })),
+        promiseCompose(createTupleParser([
+            createExactSequenceParser('{\n'),
+            createSeparatedArrayParser(promiseCompose(createTupleParser([
+                smaliIndentationParser,
+                smaliQuotedStringParser,
+            ]), ([_indentation, value,]) => value), createExactSequenceParser(',\n')),
+            smaliLineEndPraser,
+            smaliIndentationParser,
+            createExactSequenceParser('}'),
+        ]), ([_openBrace, value, _closeBrace,]) => ({ kind: 'string', value })),
+        promiseCompose(createTupleParser([
+            createExactSequenceParser('{\n'),
+            createSeparatedArrayParser(promiseCompose(createTupleParser([
+                smaliIndentationParser,
+                smaliNumberParser,
+            ]), ([_indentation, value,]) => value), createExactSequenceParser(',\n')),
+            smaliLineEndPraser,
+            smaliIndentationParser,
+            createExactSequenceParser('}'),
+        ]), ([_openBrace, value, _closeBrace,]) => ({ kind: 'raw', value })),
+    ]),
+    smaliLineEndPraser,
+]), ([_indentation, name, _equalsSign, value, _newline,]) => ({
+    name,
+    value: value,
+}));
+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,
+}));
+setParserName(smaliSubannotationParser, 'smaliSubannotationParser');
+export const smaliAnnotationParser = promiseCompose(createTupleParser([
+    smaliIndentationParser,
+    createExactSequenceParser('.annotation '),
+    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,
+}));
+setParserName(smaliAnnotationParser, 'smaliAnnotationParser');
+export const smaliFieldParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.field '),
+    createOptionalParser(promiseCompose(createTupleParser([
+        smaliAccessFlagsParser,
+        smaliSingleWhitespaceParser,
+    ]), ([accessFlags, _space]) => accessFlags)),
+    smaliMemberNameParser,
+    createExactSequenceParser(':'),
+    smaliTypeDescriptorParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser(' = '),
+        createUnionParser([
+            smaliCharacterLiteralParser,
+            smaliFieldValueParser,
+            smaliQuotedStringParser,
+            promiseCompose(createExactSequenceParser('true'), () => true),
+            promiseCompose(createExactSequenceParser('false'), () => false),
+            promiseCompose(createExactSequenceParser('null'), () => null),
+        ]),
+    ]), ([_equals, value,]) => value)),
+    smaliLineEndPraser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        createSeparatedArrayParser(smaliAnnotationParser, smaliNewlinesParser),
+        createExactSequenceParser('.end field\n'),
+    ]), ([annotations, _endField,]) => annotations)),
+]), ([_field, accessFlags, name, _colon, type, initialValue, _newline, annotations,]) => ({
+    field: {
+        accessFlags: accessFlags ?? dalvikExecutableAccessFlagsDefault(),
+        field: {
+            class: 'FILLED_LATER',
+            type,
+            name,
+        },
+    },
+    annotations: annotations ?? [],
+    ...(initialValue !== undefined ? { initialValue } : {}),
+}));
+setParserName(smaliFieldParser, 'smaliFieldParser');
+const smaliFieldsParser = promiseCompose(createSeparatedNonEmptyArrayParser(smaliFieldParser, smaliCommentsOrNewlinesParser), fieldsAndComments => {
+    let type = 'instanceField';
+    const staticFields = [];
+    const instanceFields = [];
+    for (const fieldOrComment of fieldsAndComments) {
+        if (Array.isArray(fieldOrComment)) {
+            for (const comment of fieldOrComment) {
+                if (comment === ' static fields') {
+                    type = 'staticField';
+                }
+                if (comment === ' instance fields') {
+                    type = 'instanceField';
+                }
+            }
+            continue;
+        }
+        invariant(typeof fieldOrComment === 'object', 'Expected field or comment');
+        const field = fieldOrComment;
+        if (type === 'staticField'
+            || field.field.accessFlags.static) {
+            staticFields.push(field);
+            continue;
+        }
+        if (type === 'instanceField') {
+            instanceFields.push(field);
+            continue;
+        }
+        invariant(false, 'Expected field type');
+    }
+    return {
+        staticFields,
+        instanceFields,
+    };
+});
+setParserName(smaliFieldsParser, 'smaliFieldsParser');
+const smaliShortyFieldTypeParser = createUnionParser([
+    createExactSequenceParser('Z'),
+    createExactSequenceParser('B'),
+    createExactSequenceParser('S'),
+    createExactSequenceParser('C'),
+    createExactSequenceParser('I'),
+    createExactSequenceParser('J'),
+    createExactSequenceParser('F'),
+    createExactSequenceParser('D'),
+]);
+setParserName(smaliShortyFieldTypeParser, 'smaliShortyFieldTypeParser');
+const smaliShortyReturnTypeParser = createUnionParser([
+    createExactSequenceParser('V'),
+    smaliShortyFieldTypeParser,
+]);
+setParserName(smaliShortyReturnTypeParser, 'smaliShortyReturnTypeParser');
+function shortyGetInsSize(shorty) {
+    let size = 0;
+    for (const char of shorty.slice(1)) {
+        if (char === 'J' || char === 'D') {
+            size += 2;
+        }
+        else if (char !== 'V') {
+            size += 1;
+        }
+    }
+    return size;
+}
+const smaliCodeRegistersParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .registers '),
+    smaliNumberParser,
+    smaliLineEndPraser,
+]), ([_registers, registers, _newline,]) => registers);
+setParserName(smaliCodeRegistersParser, 'smaliCodeRegistersParser');
+const smaliCodeLineParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .line '),
+    smaliNumberParser,
+    smaliLineEndPraser,
+]), ([_line, line, _newline,]) => line);
+setParserName(smaliCodeLineParser, 'smaliCodeLineParser');
+function isSmaliRegister(value) {
+    return (value !== null
+        && typeof value === 'object'
+        && 'prefix' in value
+        && 'index' in 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,
+}));
+setParserName(smaliParametersRegisterParser, 'smaliParametersRegisterParser');
+const smaliCodeLocalParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .local '),
+    smaliParametersRegisterParser,
+    createOptionalParser(createTupleParser([
+        createExactSequenceParser(','),
+        smaliWhitespaceParser,
+        smaliQuotedStringParser,
+        createExactSequenceParser(':'),
+        smaliTypeDescriptorParser,
+    ])),
+    smaliLineEndPraser,
+]), ([_local, register, nameAndType,]) => ({
+    register,
+    name: nameAndType?.[2],
+    type: nameAndType?.[4],
+}));
+setParserName(smaliCodeLocalParser, 'smaliCodeLocalParser');
+const smaliCodeEndLocalParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .end local '),
+    smaliParametersRegisterParser,
+    smaliLineEndPraser,
+]), ([_endLocal, register, _newline,]) => register);
+setParserName(smaliCodeEndLocalParser, 'smaliCodeEndLocalParser');
+const smaliCodeRestartLocalParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .restart local '),
+    smaliParametersRegisterParser,
+    smaliLineEndPraser,
+]), ([_restartLocal, register, _newline,]) => register);
+setParserName(smaliCodeRestartLocalParser, 'smaliCodeRestartLocalParser');
+const smaliCodePrologueEndParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .prologue'),
+    smaliLineEndPraser,
+]), () => true);
+setParserName(smaliCodePrologueEndParser, 'smaliCodePrologueEndParser');
+const smaliCodeEpilogueBeginParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .epilogue'),
+    smaliLineEndPraser,
+]), () => true);
+setParserName(smaliCodeEpilogueBeginParser, 'smaliCodeEpilogueBeginParser');
+export const smaliCodeParameterParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .param '),
+    smaliParametersRegisterParser,
+    createOptionalParser(createTupleParser([
+        createExactSequenceParser(','),
+        smaliWhitespaceParser,
+        smaliQuotedStringParser,
+        smaliWhitespaceParser,
+    ])),
+    createOptionalParser(smaliWhitespaceParser),
+    smaliCommentsOrNewlinesParser,
+    createOptionalParser(createTupleParser([
+        smaliAnnotationParser,
+        smaliIndentationParser,
+        createExactSequenceParser('.end param\n'),
+    ])),
+]), ([_parameter, register, optionalCommaAndString, _whitespace, _commentOrNewline, optionalAnnotation,]) => {
+    let annotation;
+    if (optionalAnnotation) {
+        annotation = optionalAnnotation[0];
+    }
+    return {
+        register,
+        name: optionalCommaAndString?.[2],
+        annotation,
+    };
+});
+setParserName(smaliCodeParameterParser, 'smaliCodeParameterParser');
+const smaliCodeLabelParser = promiseCompose(createTupleParser([
+    createExactSequenceParser(':'),
+    smaliIdentifierParser,
+]), ([_label, label,]) => label);
+setParserName(smaliCodeLabelParser, 'smaliCodeLabelParser');
+const smaliCodeLabelLineParser = promiseCompose(createTupleParser([
+    smaliIndentationParser,
+    smaliCodeLabelParser,
+    smaliLineEndPraser,
+]), ([_label, label, _newlabel,]) => label);
+setParserName(smaliCodeLabelLineParser, 'smaliCodeLabelLineParser');
+const smaliCatchDirectiveParser = promiseCompose(createTupleParser([
+    smaliIndentationParser,
+    createExactSequenceParser('.catch'),
+    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,
+}));
+setParserName(smaliCatchDirectiveParser, 'smaliCatchDirectiveParser');
+const smaliLabeledCatchDirectiveParser = promiseCompose(createTupleParser([
+    createArrayParser(smaliCodeLineParser),
+    createOptionalParser(smaliCodeLocalParser),
+    createArrayParser(smaliCodeLabelLineParser),
+    smaliCatchDirectiveParser,
+]), ([_lines, _local, labels, catchDirective,]) => ({
+    labels,
+    catchDirective,
+}));
+setParserName(smaliLabeledCatchDirectiveParser, 'smaliLabeledCatchDirectiveParser');
+const smaliParametersRegisterRangeParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('{'),
+    smaliParametersRegisterParser,
+    createExactSequenceParser(' .. '),
+    smaliParametersRegisterParser,
+    createExactSequenceParser('}'),
+]), ([_openBrace, startRegister, _dotDot, endRegister, _closeBrace,]) => {
+    invariant(startRegister.prefix === endRegister.prefix, 'Register range must use the same prefix');
+    invariant(startRegister.index <= endRegister.index, 'Register range start must be less than or equal to end');
+    const registers = [];
+    for (let i = startRegister.index; i <= endRegister.index; i++) {
+        registers.push({
+            prefix: startRegister.prefix,
+            index: i,
+        });
+    }
+    return registers;
+});
+setParserName(smaliParametersRegisterRangeParser, 'smaliParametersRegisterRangeParser');
+const smaliParametersRegisterListParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('{'),
+    createArrayParser(promiseCompose(createTupleParser([
+        smaliParametersRegisterParser,
+        createOptionalParser(createExactSequenceParser(', ')),
+    ]), ([parameter, _comma,]) => parameter)),
+    createExactSequenceParser('}'),
+]), ([_openBrace, parameters, _closeBrace,]) => parameters);
+setParserName(smaliParametersRegisterListParser, 'smaliParametersRegisterListParser');
+const smaliParametersRegistersParser = createUnionParser([
+    smaliParametersRegisterRangeParser,
+    smaliParametersRegisterListParser,
+]);
+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,]) => {
+    if (optionalSuffix === 'L') {
+        const sign = optionalMinus ? -1n : 1n;
+        return sign * BigInt('0x' + value);
+    }
+    const sign = optionalMinus ? -1 : 1;
+    return sign * Number.parseInt(value, 16);
+});
+setParserName(smaliParametersIntegerParser, 'smaliParametersIntegerParser');
+const smaliParametersLabelParser = promiseCompose(createTupleParser([
+    createExactSequenceParser(':'),
+    smaliIdentifierParser,
+]), ([_label, label,]) => label);
+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,
+}));
+setParserName(smaliParametersFieldParser, 'smaliParametersFieldParser');
+const smaliCodeOperationParametersParser = createArrayParser(promiseCompose(createTupleParser([
+    createUnionParser([
+        smaliParametersRegisterParser,
+        smaliParametersRegistersParser,
+        smaliParametersStringParser,
+        smaliParametersIntegerParser,
+        promiseCompose(createTupleParser([
+            createNegativeLookaheadParser(smaliParametersIntegerParser),
+            smaliNumberParser,
+        ]), ([_notInteger, number]) => number),
+        smaliParametersLabelParser,
+        promiseCompose(createTupleParser([
+            createNegativeLookaheadParser(smaliParametersMethodParser),
+            createNegativeLookaheadParser(smaliParametersFieldParser),
+            smaliParametersTypeParser,
+        ]), ([_notMethod, _notField, type,]) => type),
+        smaliParametersMethodParser,
+        smaliParametersFieldParser,
+    ]),
+    createOptionalParser(createExactSequenceParser(', ')),
+]), ([parameter, _comma,]) => parameter));
+setParserName(smaliCodeOperationParametersParser, 'smaliCodeOperationParametersParser');
+const smaliCodeOperationNameParser = promiseCompose(createTupleParser([
+    promiseCompose(createSeparatedArrayParser(smaliIdentifierParser, createExactSequenceParser('-')), parts => parts.join('-')),
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('/'),
+        smaliIdentifierParser,
+    ]), ([slash, name]) => slash + name)),
+]), ([name, optionalSlashName,]) => name + (optionalSlashName || ''));
+setParserName(smaliCodeOperationNameParser, 'smaliCodeOperationNameParser');
+const smaliOneLineCodeOperationParser = promiseCompose(createTupleParser([
+    smaliSingleIndentationParser,
+    smaliCodeOperationNameParser,
+    promiseCompose(createOptionalParser(createTupleParser([
+        smaliSingleWhitespaceParser,
+        smaliCodeOperationParametersParser,
+    ])), undefinedOrParameters => undefinedOrParameters === undefined ? [] : undefinedOrParameters[1]),
+    smaliLineEndPraser,
+]), ([_indent, operation, parameters, _newline,]) => ({
+    operation,
+    parameters,
+}));
+setParserName(smaliOneLineCodeOperationParser, 'smaliOneLineCodeOperationParser');
+const createMultilineSmaliCodeOperationLabelsBodyParser = operationName => promiseCompose(createTupleParser([
+    createArrayParser(promiseCompose(createTupleParser([
+        smaliIndentationParser,
+        smaliCodeLabelParser,
+        smaliLineEndPraser,
+    ]), ([_indentation, label, _newline,]) => label)),
+    smaliIndentationParser,
+    createExactSequenceParser('.end '),
+    createExactSequenceParser(operationName),
+    smaliLineEndPraser,
+]), ([labels,]) => labels);
+const createMultilineSmaliCodeOperationLabelMapBodyParser = operationName => promiseCompose(createTupleParser([
+    createArrayParser(promiseCompose(createTupleParser([
+        smaliIndentationParser,
+        smaliParametersIntegerParser,
+        createExactSequenceParser(' -> '),
+        smaliCodeLabelParser,
+        smaliLineEndPraser,
+    ]), ([_indentation, key, _arrow, label, _newline,]) => [
+        key,
+        label,
+    ])),
+    smaliIndentationParser,
+    createExactSequenceParser('.end '),
+    createExactSequenceParser(operationName),
+    smaliLineEndPraser,
+]), ([labels,]) => labels);
+const createMultilineSmaliCodeOperationIntegersBodyParser = operationName => promiseCompose(createTupleParser([
+    createArrayParser(promiseCompose(createTupleParser([
+        smaliIndentationParser,
+        smaliParametersIntegerParser,
+        smaliLineEndPraser,
+    ]), ([_indentation, key,]) => key)),
+    smaliIndentationParser,
+    createExactSequenceParser('.end '),
+    createExactSequenceParser(operationName),
+    smaliLineEndPraser,
+]), ([labels,]) => labels);
+const createMultilineSmaliCodeOperationBodyParser = operationName => createUnionParser([
+    createMultilineSmaliCodeOperationLabelsBodyParser(operationName),
+    createMultilineSmaliCodeOperationIntegersBodyParser(operationName),
+    createMultilineSmaliCodeOperationLabelMapBodyParser(operationName),
+]);
+const smaliMultilineCodeOperationParser = parserCreatorCompose(() => promiseCompose(createTupleParser([
+    smaliSingleIndentationParser,
+    createExactSequenceParser('.'),
+    smaliCodeOperationNameParser,
+    promiseCompose(createOptionalParser(createTupleParser([
+        smaliSingleWhitespaceParser,
+        smaliCodeOperationParametersParser,
+    ])), undefinedOrParameters => undefinedOrParameters === undefined ? [] : undefinedOrParameters[1]),
+    smaliLineEndPraser,
+]), ([_indent, _dot, operation, parameters, _newline,]) => ({
+    operation,
+    parameters,
+})), ({ operation, parameters }) => promiseCompose(createMultilineSmaliCodeOperationBodyParser(operation), body => ({
+    operation,
+    parameters,
+    body,
+})))();
+setParserName(smaliMultilineCodeOperationParser, 'smaliMultilineCodeOperationParser');
+const smaliLooseCodeOperationParser = createUnionParser([
+    smaliOneLineCodeOperationParser,
+    smaliMultilineCodeOperationParser,
+]);
+setParserName(smaliLooseCodeOperationParser, 'smaliLooseCodeOperationParser');
+export const smaliCodeOperationParser = promiseCompose(smaliLooseCodeOperationParser, operation => {
+    const operation_ = {
+        operation: operation.operation,
+        // Line,
+        // local,
+        // parameters: (operation as any).parameters,
+    }; // TODO
+    if ('body' in operation) {
+        const operationDexName = payloadOperationSmaliNameToDexName.get(operation.operation);
+        invariant(operationDexName, 'Unknown payload operation for %s', operation.operation);
+        operation_.operation = operationDexName;
+        if (operationDexName === 'sparse-switch-payload') {
+            const map = new Map(operation.body);
+            operation_.keys = [...map.keys()];
+            operation_.branchLabels = [...map.values()];
+        }
+        else if (operationDexName === 'fill-array-data-payload') {
+            // Get elementWidth from parameters (first parameter)
+            const elementWidth = operation.parameters[0];
+            invariant(typeof elementWidth === 'number', 'Expected elementWidth to be a number');
+            operation_.elementWidth = elementWidth;
+            // Convert integer values to bytes (little-endian)
+            const values = operation.body;
+            const data = [];
+            for (const value of values) {
+                // Use BigInt for bitwise operations to preserve full precision
+                const bigIntValue = typeof value === 'bigint' ? value : BigInt(value);
+                // Convert to bytes based on elementWidth (little-endian)
+                for (let i = 0; i < elementWidth; i++) {
+                    data.push(Number((bigIntValue >> BigInt(i * 8)) & 0xffn));
+                }
+            }
+            operation_.data = data;
+        }
+        else {
+            operation_.branchLabels = operation.body;
+        }
+    }
+    const hasRegisters = Array.isArray(operation.parameters.at(0));
+    if (hasRegisters) {
+        operation_.registers = [];
+    }
+    for (const parameter of operation.parameters.flat() ?? []) {
+        if (isDalvikExecutableMethod(parameter)) {
+            operation_.method = parameter;
+            continue;
+        }
+        if (isDalvikExecutableField(parameter)) {
+            operation_.field = parameter;
+            continue;
+        }
+        if (isSmaliRegister(parameter)) {
+            operation_.registers ||= [];
+            operation_.registers.push(parameter);
+            continue;
+        }
+        if (typeof parameter === 'string') {
+            if (operationsWithTypeArgument.has(operation_.operation)) {
+                operation_.type = parameter;
+                continue;
+            }
+            if (operationsWithBranchLabelArgument.has(operation_.operation)) {
+                operation_.branchLabel = parameter;
+                continue;
+            }
+            operation_.string = parameter;
+            continue;
+        }
+        if (typeof parameter === 'number' || typeof parameter === 'bigint') {
+            // Skip for fill-array-data-payload, already handled in body processing
+            if (operation_.operation === 'fill-array-data-payload') {
+                continue;
+            }
+            // Const-wide operations always use bigint values
+            if (operationsWithBigintValue.has(operation_.operation)) {
+                operation_.value = typeof parameter === 'number' ? BigInt(parameter) : parameter;
+            }
+            else {
+                operation_.value = parameter;
+            }
+            continue;
+        }
+        invariant(false, 'TODO: parameter: %s, operation: %s', JSON.stringify(parameter), JSON.stringify(operation));
+    }
+    return operation_;
+});
+setParserName(smaliCodeOperationParser, 'smaliCodeOperationParser');
+const operationsWithTypeArgument = new Set([
+    'new-instance',
+    'new-array',
+    'filled-new-array',
+    'filled-new-array/range',
+    'check-cast',
+    'instance-of',
+    'const-class',
+]);
+const operationsWithBigintValue = new Set([
+    'const-wide/16',
+    'const-wide/32',
+    'const-wide',
+]);
+const operationsWithBranchLabelArgument = new Set([
+    'goto',
+    'goto/16',
+    'goto/32',
+    'if-eq',
+    'if-ne',
+    'if-lt',
+    'if-ge',
+    'if-gt',
+    'if-le',
+    'if-eqz',
+    'if-nez',
+    'if-ltz',
+    'if-gez',
+    'if-gtz',
+    'if-lez',
+    'packed-switch',
+    'sparse-switch',
+    'fill-array-data',
+]);
+const payloadOperationSmaliNameToDexName = new Map(Object.entries({
+    'packed-switch': 'packed-switch-payload',
+    'sparse-switch': 'sparse-switch-payload',
+    'array-data': 'fill-array-data-payload',
+}));
+function isOperationWithLabels(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && 'labels' in value
+        && value.labels instanceof Set);
+}
+const smaliAnnotatedCodeOperationParser = promiseCompose(createTupleParser([
+    createArrayParser(smaliCodeLineParser),
+    createOptionalParser(smaliCodeLocalParser),
+    createOptionalParser(smaliCodeEndLocalParser),
+    createOptionalParser(smaliCodeRestartLocalParser),
+    createOptionalParser(smaliCodePrologueEndParser),
+    createOptionalParser(smaliCodeEpilogueBeginParser),
+    createArrayParser(smaliCodeLabelLineParser),
+    smaliCodeOperationParser,
+]), ([lines, local, endLocal, restartLocal, prologueEnd, epilogueBegin, labels, operation,]) => {
+    const debugDirectives = [];
+    for (const line of lines) {
+        debugDirectives.push({ type: 'line', line });
+    }
+    if (local) {
+        debugDirectives.push({ type: 'startLocal', local });
+    }
+    if (endLocal) {
+        debugDirectives.push({ type: 'endLocal', register: endLocal });
+    }
+    if (restartLocal) {
+        debugDirectives.push({ type: 'restartLocal', register: restartLocal });
+    }
+    if (prologueEnd) {
+        debugDirectives.push({ type: 'setPrologueEnd' });
+    }
+    if (epilogueBegin) {
+        debugDirectives.push({ type: 'setEpilogueBegin' });
+    }
+    return {
+        debugDirectives,
+        labels,
+        operation,
+    };
+});
+setParserName(smaliAnnotatedCodeOperationParser, 'smaliAnnotatedCodeOperationParser');
+const smaliExecutableCodeParser = promiseCompose(createTupleParser([
+    createOptionalParser(smaliCodeRegistersParser),
+    createArrayParser(smaliAnnotationParser),
+    createArrayParser(smaliCodeParameterParser),
+    createOptionalParser(smaliCommentsOrNewlinesParser),
+    createSeparatedArrayParser(smaliAnnotationParser, smaliCommentsOrNewlinesParser),
+    createArrayParser(promiseCompose(createTupleParser([
+        createOptionalParser(smaliCommentsOrNewlinesParser),
+        createDisjunctionParser([
+            smaliIndentedCommentParser,
+            smaliAnnotatedCodeOperationParser,
+            smaliLabeledCatchDirectiveParser,
+        ]),
+    ]), ([_commentsOrNewlinesParser, operation,]) => operation)),
+]), ([registersSize, annotations1, parameters, _leadingCommentsOrNewlines, annotations2, instructionsAndCatchDirectives,]) => {
+    const annotations = [...annotations1, ...annotations2];
+    const instructions = [];
+    const annotatedOperations = [];
+    const catchDirectives = [];
+    const catchDirectiveLabels = new Map();
+    for (const item of instructionsAndCatchDirectives) {
+        if (item && typeof item === 'object') {
+            if ('labels' in item && 'catchDirective' in item) {
+                // This is a SmaliLabeledCatchDirective
+                const labeledCatch = item;
+                catchDirectives.push(labeledCatch.catchDirective);
+                catchDirectiveLabels.set(labeledCatch.catchDirective, labeledCatch.labels);
+            }
+            else if ('type' in item && 'startLabel' in item && 'endLabel' in item && 'handlerLabel' in item) {
+                // This is a bare SmaliCatchDirective (shouldn't happen with current parser structure)
+                catchDirectives.push(item);
+            }
+            else if ('debugDirectives' in item && 'labels' in item && 'operation' in item) {
+                // This is a SmaliAnnotatedCodeOperation
+                const annotated = item;
+                annotatedOperations.push(annotated);
+                const operation = annotated.operation;
+                if (annotated.labels.length > 0) {
+                    operation.labels = new Set(annotated.labels);
+                }
+                instructions.push(operation);
+            }
+            else if (item !== undefined) {
+                // This is a SmaliCodeOperation (fallback)
+                instructions.push(item);
+            }
+        }
+    }
+    if (registersSize === undefined
+        && parameters !== undefined) {
+        registersSize = parameters.length;
+    }
+    invariant(registersSize !== undefined, 'Expected registers size to be defined');
+    for (const [operationIndex, operation] of instructions.entries()) {
+        if ('branchLabel' in operation
+            && typeof operation.branchLabel === 'string') {
+            for (const [targetOperationIndex, targetOperation] of instructions.entries()) {
+                if (!isOperationWithLabels(targetOperation)) {
+                    continue;
+                }
+                if (!targetOperation.labels.has(operation.branchLabel)) {
+                    continue;
+                }
+                delete operation.branchLabel;
+                operation.branchOffsetIndex = targetOperationIndex - operationIndex;
+                break;
+            }
+        }
+        if ('branchLabels' in operation
+            && typeof operation.branchLabels === 'object'
+            && Array.isArray(operation.branchLabels)) {
+            const sourceOperations = instructions.filter((sourceOperation, sourceOperationIndex) => ('branchOffsetIndex' in sourceOperation
+                && typeof sourceOperation.branchOffsetIndex === 'number'
+                && sourceOperation.branchOffsetIndex + sourceOperationIndex === operationIndex));
+            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.branchOffsetIndices = operation.branchLabels.map((branchLabel) => {
+                for (const [targetOperationIndex, targetOperation] of instructions.entries()) {
+                    if (!isOperationWithLabels(targetOperation)) {
+                        continue;
+                    }
+                    if (!targetOperation.labels.has(branchLabel)) {
+                        continue;
+                    }
+                    return targetOperationIndex - sourceOperationIndex;
+                }
+                invariant(false, 'Expected to find branch label %s', branchLabel);
+            });
+            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;
+    }
+    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;
+        }
+        if ('branchOffsetIndices' in operation
+            && typeof operation.branchOffsetIndices === 'object'
+            && Array.isArray(operation.branchOffsetIndices)) {
+            const sourceOperations = instructions.filter((sourceOperation, sourceOperationIndex) => ('branchOffsetIndex' in sourceOperation
+                && typeof sourceOperation.branchOffsetIndex === 'number'
+                && sourceOperation.branchOffsetIndex + sourceOperationIndex === operationIndex));
+            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;
+            });
+        }
+    }
+    // Build label-to-index mapping
+    // Labels attached to instructions map to that instruction's index
+    // Labels before catch directives should map to the position they mark
+    const labelToIndexMap = new Map();
+    // First, map labels from instructions
+    for (const [operationIndex, operation] of instructions.entries()) {
+        if (operation
+            && typeof operation === 'object'
+            && 'labels' in operation
+            && operation.labels instanceof Set) {
+            for (const label of operation.labels) {
+                labelToIndexMap.set(label, operationIndex);
+            }
+        }
+    }
+    // Now handle labels from catch directives
+    // We need to figure out where each catch directive appears in the original sequence
+    let instructionArrayIndex = 0;
+    for (let i = 0; i < instructionsAndCatchDirectives.length; i++) {
+        const item = instructionsAndCatchDirectives[i];
+        if (item && typeof item === 'object' && 'labels' in item && 'catchDirective' in item) {
+            // This is a catch directive with labels
+            // These labels should map to the current instruction index
+            // (which is where the next instruction would be)
+            const labeledCatch = item;
+            for (const label of labeledCatch.labels) {
+                labelToIndexMap.set(label, instructionArrayIndex);
+            }
+        }
+        else if (item !== undefined && !(item && typeof item === 'object' && 'type' in item && 'startLabel' in item)) {
+            // This is an instruction, increment the counter
+            instructionArrayIndex++;
+        }
+    }
+    // Build tries array from catch directives
+    const triesByRange = new Map();
+    for (const catchDirective of catchDirectives) {
+        // Find the start and end instruction indices
+        const startIndex = labelToIndexMap.get(catchDirective.startLabel);
+        const endIndex = labelToIndexMap.get(catchDirective.endLabel);
+        const handlerIndex = labelToIndexMap.get(catchDirective.handlerLabel);
+        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}`;
+        let tryEntry = triesByRange.get(rangeKey);
+        if (!tryEntry) {
+            tryEntry = {
+                startAddress,
+                instructionCount,
+                handlers: [],
+                catchAllAddress: undefined,
+            };
+            triesByRange.set(rangeKey, tryEntry);
+        }
+        if (catchDirective.type === undefined) {
+            // .catchall
+            tryEntry.catchAllAddress = handlerAddress;
+        }
+        else {
+            // .catch Type
+            tryEntry.handlers.push({
+                type: catchDirective.type,
+                address: handlerAddress,
+            });
+        }
+    }
+    const tries = Array.from(triesByRange.values()).map(tryEntry => ({
+        startAddress: tryEntry.startAddress,
+        instructionCount: tryEntry.instructionCount,
+        handler: {
+            handlers: tryEntry.handlers,
+            catchAllAddress: tryEntry.catchAllAddress,
+        },
+    }));
+    for (const operation of instructions) {
+        delete operation.labels;
+        delete operation.branchOffsetIndex;
+        delete operation.branchOffsetIndices;
+    }
+    let debugInfo;
+    const debugBytecode = [];
+    let currentLine;
+    let lineStart;
+    // Helper to convert SmaliRegister to register number
+    const getRegisterNum = (register) => {
+        // In Smali, 'v' registers start from 0, 'p' registers are parameters
+        // For now, we'll just use the index. The actual conversion may need
+        // to account for registersSize and parameter mapping.
+        if (register.prefix === 'v') {
+            return register.index;
+        }
+        else {
+            // 'p' registers: need to map to actual register numbers
+            // p0 starts at (registersSize - insSize)
+            // For now, just use the index as we don't have accurate insSize
+            return register.index;
+        }
+    };
+    // Helper to emit accumulated line/address changes as special opcode or explicit opcodes
+    const emitPendingChanges = (lineDiff, addressDiff) => {
+        // Special opcode formula: opcode = 0x0A + (line_diff + 4) + 15 * addr_diff
+        // Valid when: line_diff ∈ [-4, 10] and addr_diff ∈ [0, 17] and result ≤ 0xFF
+        if (lineDiff >= -4 && lineDiff <= 10 && addressDiff >= 0) {
+            const adjusted = (lineDiff + 4) + 15 * addressDiff;
+            const opcode = 0x0A + adjusted;
+            if (opcode <= 0xFF) {
+                debugBytecode.push({
+                    type: 'special',
+                    value: opcode,
+                });
+                return;
+            }
+        }
+        // Fall back to explicit opcodes
+        if (addressDiff > 0) {
+            debugBytecode.push({
+                type: 'advancePc',
+                addressDiff,
+            });
+        }
+        if (lineDiff !== 0) {
+            debugBytecode.push({
+                type: 'advanceLine',
+                lineDiff,
+            });
+        }
+    };
+    let accumulatedAddressDiff = 0;
+    let accumulatedLineDiff = 0;
+    let lastAddress = 0;
+    let hasEmittedFirstDebugEvent = false;
+    for (let i = 0; i < annotatedOperations.length; i++) {
+        const annotated = annotatedOperations[i];
+        const operationAddress = branchOffsetByBranchOffsetIndex.get(i) ?? 0;
+        // Accumulate address difference (only after we've started tracking)
+        if (i > 0 && hasEmittedFirstDebugEvent) {
+            accumulatedAddressDiff += operationAddress - lastAddress;
+        }
+        lastAddress = operationAddress;
+        // Process line directives first to update accumulatedLineDiff
+        for (const directive of annotated.debugDirectives) {
+            if (directive.type === 'line') {
+                if (lineStart === undefined) {
+                    lineStart = directive.line;
+                    currentLine = directive.line;
+                }
+                else if (currentLine !== undefined) {
+                    accumulatedLineDiff += directive.line - currentLine;
+                    currentLine = directive.line;
+                }
+            }
+        }
+        // Emit accumulated changes before any other debug events
+        const hasOtherDebugEvents = annotated.debugDirectives.some(d => d.type !== 'line');
+        if (hasOtherDebugEvents && (accumulatedLineDiff !== 0 || accumulatedAddressDiff !== 0 || !hasEmittedFirstDebugEvent)) {
+            emitPendingChanges(accumulatedLineDiff, accumulatedAddressDiff);
+            accumulatedLineDiff = 0;
+            accumulatedAddressDiff = 0;
+            hasEmittedFirstDebugEvent = true;
+        }
+        // Emit other debug directives
+        for (const directive of annotated.debugDirectives) {
+            if (directive.type === 'startLocal') {
+                debugBytecode.push({
+                    type: 'startLocal',
+                    registerNum: getRegisterNum(directive.local.register),
+                    name: directive.local.name,
+                    type_: directive.local.type,
+                });
+            }
+            else if (directive.type === 'endLocal') {
+                debugBytecode.push({
+                    type: 'endLocal',
+                    registerNum: getRegisterNum(directive.register),
+                });
+            }
+            else if (directive.type === 'restartLocal') {
+                debugBytecode.push({
+                    type: 'restartLocal',
+                    registerNum: getRegisterNum(directive.register),
+                });
+            }
+            else if (directive.type === 'setPrologueEnd') {
+                debugBytecode.push({
+                    type: 'setPrologueEnd',
+                });
+            }
+            else if (directive.type === 'setEpilogueBegin') {
+                debugBytecode.push({
+                    type: 'setEpilogueBegin',
+                });
+            }
+        }
+    }
+    // Emit any remaining accumulated changes at the end
+    if (accumulatedLineDiff !== 0 || accumulatedAddressDiff !== 0) {
+        emitPendingChanges(accumulatedLineDiff, accumulatedAddressDiff);
+    }
+    if (lineStart !== undefined) {
+        // Extract parameter names from .param directives
+        const parameterNames = [];
+        // TODO: Extract from parameters array if needed
+        // If we have a lineStart but no bytecode, we need to emit a special opcode
+        // to establish the initial state. The special value 0x0E (14) means:
+        // adjusted = 14 - 10 = 4, line_diff = 4 % 15 - 4 = 0, pc_diff = 4 / 15 = 0
+        if (debugBytecode.length === 0) {
+            debugBytecode.push({
+                type: 'special',
+                value: 0x0A + 4, // 14 in decimal
+            });
+        }
+        debugInfo = {
+            lineStart,
+            parameterNames,
+            bytecode: debugBytecode,
+        };
+    }
+    return {
+        dalvikExecutableCode: {
+            registersSize,
+            insSize: -1, // TODO
+            outsSize: -1, // TODO
+            debugInfo,
+            instructions: instructions, // TODO
+            tries,
+            // _annotations,
+        },
+        parameters,
+        parameterAnnotations: parameters.filter(parameter => parameter.annotation !== undefined),
+        methodAnnotations: annotations,
+    };
+});
+setParserName(smaliExecutableCodeParser, 'smaliExecutableCodeParser');
+// TODO: ???
+const sortRegistersOperations = new Set([
+    'if-eq',
+    'if-ne',
+]);
+// All 12x format operations need register reversal because:
+// - Bytecode format is B|A (B in high nibble, A in low nibble)
+// - nibblesParser returns [B, A]
+// - Smali syntax is "op vA, vB" (destination first)
+// - So we need to reverse to get [A, B]
+const reverseRegistersOperations = new Set([
+    // Move operations
+    'move',
+    'move-wide',
+    'move-object',
+    // Unary operations (negation, bitwise not)
+    'neg-int',
+    'not-int',
+    'neg-long',
+    'not-long',
+    'neg-float',
+    'neg-double',
+    // Type conversion operations
+    'int-to-long',
+    'int-to-float',
+    'int-to-double',
+    'long-to-int',
+    'long-to-float',
+    'long-to-double',
+    'float-to-int',
+    'float-to-long',
+    'float-to-double',
+    'double-to-int',
+    'double-to-long',
+    'double-to-float',
+    'int-to-byte',
+    'int-to-char',
+    'int-to-short',
+    // Binary operations with /2addr suffix
+    'add-int/2addr',
+    'sub-int/2addr',
+    'mul-int/2addr',
+    'div-int/2addr',
+    'rem-int/2addr',
+    'and-int/2addr',
+    'or-int/2addr',
+    'xor-int/2addr',
+    'shl-int/2addr',
+    'shr-int/2addr',
+    'ushr-int/2addr',
+    'add-long/2addr',
+    'sub-long/2addr',
+    'mul-long/2addr',
+    'div-long/2addr',
+    'rem-long/2addr',
+    'and-long/2addr',
+    'or-long/2addr',
+    'xor-long/2addr',
+    'shl-long/2addr',
+    'shr-long/2addr',
+    'ushr-long/2addr',
+    'add-float/2addr',
+    'sub-float/2addr',
+    'mul-float/2addr',
+    'div-float/2addr',
+    'rem-float/2addr',
+    'add-double/2addr',
+    'sub-double/2addr',
+    'mul-double/2addr',
+    'div-double/2addr',
+    'rem-double/2addr',
+]);
+function normalizeOperation(operation) {
+    if (sortRegistersOperations.has(operation.operation)
+        && 'registers' in operation) {
+        operation.registers.sort((a, b) => a - b);
+    }
+    if (reverseRegistersOperations.has(operation.operation)
+        && 'registers' in operation) {
+        operation.registers.reverse();
+    }
+    return operation;
+}
+export const smaliMethodParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.method '),
+    createOptionalParser(promiseCompose(createTupleParser([
+        smaliAccessFlagsParser,
+        smaliSingleWhitespaceParser,
+    ]), ([accessFlags]) => accessFlags)),
+    smaliMemberNameParser,
+    smaliMethodPrototypeParser,
+    smaliLineEndPraser,
+    smaliExecutableCodeParser,
+    createArrayParser(smaliCodeLineParser),
+    createExactSequenceParser('.end method\n'),
+]), ([_method, accessFlagsOrUndefined, name, prototype, _newline, { dalvikExecutableCode, parameters, parameterAnnotations, methodAnnotations, }, _lines, _endMethod,]) => {
+    const accessFlags = accessFlagsOrUndefined ?? dalvikExecutableAccessFlagsDefault();
+    let code = dalvikExecutableCode;
+    if (accessFlags.native && code.instructions.length === 0) {
+        code = undefined;
+    }
+    if (code) {
+        const insSize = (accessFlags.static ? 0 : 1) + shortyGetInsSize(prototype.shorty);
+        code.insSize = insSize;
+        for (const operation of code.instructions) {
+            const smaliRegisters = dalvikBytecodeOperationCompanion.getRegisters(operation); // TODO
+            if (smaliRegisters.length === 0) {
+                continue;
+            }
+            const registers = smaliRegisters.map(({ prefix, index }) => {
+                if (prefix === 'v') {
+                    return index;
+                }
+                if (prefix === 'p') {
+                    return code.registersSize - insSize + index;
+                }
+                invariant(false, 'Expected prefix to be v or p');
+            });
+            operation.registers = registers; // TODO
+        }
+        let outsSize = 0;
+        for (const operation of code.instructions) {
+            if (!operation.operation.startsWith('invoke-')) {
+                continue;
+            }
+            const registers = dalvikBytecodeOperationCompanion.getRegisters(operation);
+            outsSize = Math.max(outsSize, registers.length); // TODO?: two words for wide types?
+        }
+        code.outsSize = outsSize;
+        // Populate debug info parameter names
+        // The parameter count is insSize minus 1 for non-static methods (to exclude 'this')
+        if (code.debugInfo) {
+            const paramCount = accessFlags.static ? insSize : insSize - 1;
+            const paramNames = Array(paramCount).fill(undefined);
+            // Map parameter names from .param directives
+            // For non-static methods: p0 is 'this', p1 is first param (index 0)
+            // For static methods: p0 is first param (index 0)
+            for (const param of parameters) {
+                if (param.register.prefix === 'p' && param.name) {
+                    const pRegister = param.register.index;
+                    // Adjust for 'this' parameter in non-static methods
+                    const paramIndex = accessFlags.static ? pRegister : pRegister - 1;
+                    if (paramIndex >= 0 && paramIndex < paramCount) {
+                        paramNames[paramIndex] = param.name;
+                    }
+                }
+            }
+            code.debugInfo.parameterNames = paramNames;
+        }
+    }
+    return {
+        dalvikExecutableMethodWithAccess: {
+            accessFlags,
+            method: {
+                class: 'FILLED_LATER',
+                prototype,
+                name,
+            },
+            code: code?.instructions.length
+                ? {
+                    ...code,
+                    instructions: code.instructions.map(normalizeOperation),
+                }
+                : undefined,
+        },
+        parameterAnnotations,
+        methodAnnotations,
+    };
+});
+setParserName(smaliMethodParser, 'smaliMethodParser');
+const smaliMethodsParser = promiseCompose(createArrayParser(createDisjunctionParser([
+    smaliMethodParser,
+    smaliCommentsOrNewlinesParser,
+])), methodsAndComments => {
+    let type = 'directMethod';
+    const directMethods = [];
+    const virtualMethods = [];
+    const parameterAnnotations = [];
+    const methodAnnotations = [];
+    function pushParameterAnnotation(annotation) {
+        if (annotation.annotations.length === 0) {
+            return;
+        }
+        const existingMethod = parameterAnnotations.find(parameterAnnotation => dalvikExecutableMethodEquals(parameterAnnotation.method, annotation.method));
+        if (existingMethod) {
+            for (const [index, parameterAnnotations_] of annotation.annotations.entries()) {
+                const existingParameterAnnotations = existingMethod.annotations.at(index);
+                if (existingParameterAnnotations) {
+                    existingParameterAnnotations.push(...parameterAnnotations_);
+                }
+                else {
+                    existingMethod.annotations[index] = parameterAnnotations_;
+                }
+            }
+            return;
+        }
+        parameterAnnotations.push(annotation);
+    }
+    for (const methodOrComment of methodsAndComments) {
+        if (Array.isArray(methodOrComment)) {
+            for (const comment of methodOrComment) {
+                if (comment === ' direct methods') {
+                    type = 'directMethod';
+                }
+                if (comment === ' virtual methods') {
+                    type = 'virtualMethod';
+                }
+            }
+            continue;
+        }
+        invariant(typeof methodOrComment === 'object', 'Expected method or comment');
+        const method = methodOrComment;
+        if (method.methodAnnotations.length > 0) {
+            methodAnnotations.push({
+                method: method.dalvikExecutableMethodWithAccess.method,
+                annotations: method.methodAnnotations.map(annotation => ({
+                    type: annotation.type,
+                    visibility: annotation.visibility,
+                    elements: annotation.elements.map(element => ({
+                        name: element.name,
+                        value: convertToTaggedEncodedValue(element.value),
+                    })),
+                })),
+            });
+        }
+        // Create an annotations array for all parameters, not just those with annotations
+        // In smali, instance methods have p0 as 'this', p1 as first param, etc.
+        // But DEX parameter annotations only include the actual parameters (not 'this')
+        const isStatic = method.dalvikExecutableMethodWithAccess.accessFlags.static;
+        const smaliRegisterOffset = isStatic ? 0 : 1; // P0 is 'this' for instance methods
+        const allParameterAnnotations = method.dalvikExecutableMethodWithAccess.method.prototype.parameters.map((_, parameterIndex) => {
+            const smaliRegisterIndex = parameterIndex + smaliRegisterOffset;
+            const parameterAnnotation = method.parameterAnnotations.find(pa => pa.register.prefix === 'p' && pa.register.index === smaliRegisterIndex);
+            if (parameterAnnotation?.annotation) {
+                return [{
+                        type: parameterAnnotation.annotation.type,
+                        visibility: parameterAnnotation.annotation.visibility,
+                        elements: parameterAnnotation.annotation.elements.map(element => ({
+                            name: element.name,
+                            value: convertToTaggedEncodedValue(element.value),
+                        })),
+                    }];
+            }
+            return [];
+        });
+        // Only push parameter annotations if there are some actual annotations
+        if (allParameterAnnotations.some(annotations => annotations.length > 0)) {
+            pushParameterAnnotation({
+                method: method.dalvikExecutableMethodWithAccess.method,
+                annotations: allParameterAnnotations,
+            });
+        }
+        if (type === 'directMethod') {
+            directMethods.push(method.dalvikExecutableMethodWithAccess);
+            continue;
+        }
+        if (type === 'virtualMethod') {
+            virtualMethods.push(method.dalvikExecutableMethodWithAccess);
+            continue;
+        }
+        invariant(false, 'Expected method type');
+    }
+    // Sort parameter annotations by method index in the combined method list
+    // to match the order in the DEX file's annotations directory
+    const allMethods = [...directMethods, ...virtualMethods];
+    parameterAnnotations.sort((a, b) => {
+        const indexA = allMethods.findIndex(m => dalvikExecutableMethodEquals(m.method, a.method));
+        const indexB = allMethods.findIndex(m => dalvikExecutableMethodEquals(m.method, b.method));
+        return indexA - indexB;
+    });
+    return {
+        directMethods,
+        virtualMethods,
+        parameterAnnotations,
+        methodAnnotations,
+    };
+});
+setParserName(smaliMethodsParser, 'smaliMethodsParser');
+export const smaliParser = promiseCompose(createTupleParser([
+    smaliClassDeclarationParser,
+    smaliSuperDeclarationParser,
+    createOptionalParser(smaliSourceDeclarationParser),
+    createOptionalParser(promiseCompose(createTupleParser([
+        smaliCommentsOrNewlinesParser,
+        createNonEmptyArrayParser(smaliInterfaceDeclarationParser),
+    ]), ([_commentsOrNewlines, interfaces,]) => interfaces)),
+    createOptionalParser(promiseCompose(createTupleParser([
+        smaliCommentsOrNewlinesParser,
+        createSeparatedNonEmptyArrayParser(smaliAnnotationParser, smaliCommentsOrNewlinesParser),
+    ]), ([_commentsOrNewlines, classAnnotations,]) => classAnnotations)),
+    createOptionalParser(promiseCompose(createTupleParser([
+        smaliCommentsOrNewlinesParser,
+        smaliFieldsParser,
+    ]), ([_commentsOrNewlines, fields,]) => fields)),
+    smaliMethodsParser,
+]), ([{ accessFlags, class: class_, }, { superclass, }, sourceFileObject, interfaces, classAnnotations, smaliFields, methods,]) => {
+    const sourceFile = sourceFileObject?.sourceFile;
+    // Create staticValues array matching DEX format:
+    // - Find the last static field with a non-default initializer
+    // - Create array up to that index with values/nulls
+    // - Fields after the last initializer are not included
+    // - Default values (false, null) are not considered initializers
+    const staticFieldsList = smaliFields?.staticFields ?? [];
+    let lastIndexWithInitializer = -1;
+    for (let i = staticFieldsList.length - 1; i >= 0; i--) {
+        const initValue = staticFieldsList[i].initialValue;
+        // Only consider non-default values as initializers
+        // Numbers, bigints, strings, and true are non-default
+        // false and null are default values
+        if (initValue !== undefined && typeof initValue === 'number') {
+            lastIndexWithInitializer = i;
+            break;
+        }
+        if (initValue !== undefined && typeof initValue === 'bigint') {
+            lastIndexWithInitializer = i;
+            break;
+        }
+        if (initValue !== undefined && typeof initValue === 'string') {
+            lastIndexWithInitializer = i;
+            break;
+        }
+        if (initValue === true) {
+            lastIndexWithInitializer = i;
+            break;
+        }
+    }
+    const staticValues = lastIndexWithInitializer === -1
+        ? []
+        : staticFieldsList
+            .slice(0, lastIndexWithInitializer + 1)
+            .map(smaliField => {
+            const fieldType = smaliField.field.field.type;
+            if (smaliField.initialValue === undefined) {
+                // For integer types without initializer, DEX stores 0
+                if (fieldType === 'I') {
+                    return { type: 'int', value: 0 };
+                }
+                if (fieldType === 'B') {
+                    return { type: 'byte', value: 0 };
+                }
+                if (fieldType === 'S') {
+                    return { type: 'short', value: 0 };
+                }
+                if (fieldType === 'C') {
+                    return { type: 'char', value: 0 };
+                }
+                // For long types without initializer, DEX stores 0n
+                if (fieldType === 'J') {
+                    return { type: 'long', value: 0n };
+                }
+                // For float/double types without initializer, DEX stores 0
+                if (fieldType === 'F') {
+                    return { type: 'float', value: 0 };
+                }
+                if (fieldType === 'D') {
+                    return { type: 'double', value: 0 };
+                }
+                // For boolean types without initializer, DEX stores false
+                if (fieldType === 'Z') {
+                    return { type: 'boolean', value: false };
+                }
+                // For other types (reference types, etc.), return null
+                return { type: 'null', value: null };
+            }
+            // Numeric values are stored in static values array
+            if (typeof smaliField.initialValue === 'number') {
+                // Convert to BigInt for long (J) types
+                if (fieldType === 'J') {
+                    return { type: 'long', value: BigInt(smaliField.initialValue) };
+                }
+                if (fieldType === 'B') {
+                    return { type: 'byte', value: smaliField.initialValue };
+                }
+                if (fieldType === 'S') {
+                    return { type: 'short', value: smaliField.initialValue };
+                }
+                if (fieldType === 'C') {
+                    return { type: 'char', value: smaliField.initialValue };
+                }
+                if (fieldType === 'F') {
+                    return { type: 'float', value: smaliField.initialValue };
+                }
+                if (fieldType === 'D') {
+                    return { type: 'double', value: smaliField.initialValue };
+                }
+                // Default to int for other numeric types
+                return { type: 'int', value: smaliField.initialValue };
+            }
+            // BigInt values for long (J) types
+            if (typeof smaliField.initialValue === 'bigint') {
+                return { type: 'long', value: smaliField.initialValue };
+            }
+            // String values should be stored as string type
+            if (typeof smaliField.initialValue === 'string') {
+                return { type: 'string', value: smaliField.initialValue };
+            }
+            // Boolean true is a non-default value and should be in staticValues
+            if (smaliField.initialValue === true) {
+                return { type: 'boolean', value: true };
+            }
+            // Boolean false and null are default values
+            // For boolean fields with explicit false, return false
+            if (smaliField.initialValue === false && fieldType === 'Z') {
+                return { type: 'boolean', value: false };
+            }
+            // For null or other default values, return null
+            return { type: 'null', value: null };
+        });
+    const fields = {
+        staticFields: smaliFields?.staticFields.map(({ field }) => field) ?? [],
+        instanceFields: smaliFields?.instanceFields.map(({ field }) => field) ?? [],
+    };
+    // Sort fields to match DEX file order (by field name, then type)
+    // This matches the field order in class_data_item in DEX files
+    // Use binary string comparison (case-sensitive) to match UTF-8 byte order
+    const sortFields = (fieldsList) => {
+        fieldsList.sort((a, b) => {
+            // First by field name (case-sensitive comparison)
+            if (a.field.name !== b.field.name) {
+                return a.field.name < b.field.name ? -1 : 1;
+            }
+            // Then by field type (case-sensitive comparison)
+            return a.field.type < b.field.type ? -1 : 1;
+        });
+    };
+    sortFields(fields.staticFields);
+    sortFields(fields.instanceFields);
+    const annotations = {
+        classAnnotations: (classAnnotations ?? []).map(annotation => ({
+            type: annotation.type,
+            visibility: annotation.visibility,
+            elements: annotation.elements.map(element => ({
+                name: element.name,
+                value: convertToTaggedEncodedValue(element.value),
+            })),
+        })),
+        fieldAnnotations: [],
+        methodAnnotations: methods.methodAnnotations,
+        parameterAnnotations: methods.parameterAnnotations,
+    };
+    for (const smaliField of [...(smaliFields?.staticFields ?? []), ...(smaliFields?.instanceFields ?? [])]) {
+        if (smaliField.annotations.length === 0) {
+            continue;
+        }
+        const existingFieldAnnotations = annotations.fieldAnnotations.find(fieldAnnotation => dalvikExecutableFieldEquals(fieldAnnotation.field, smaliField.field.field));
+        if (existingFieldAnnotations) {
+            existingFieldAnnotations.annotations ??= [];
+            existingFieldAnnotations.annotations.push(...smaliField.annotations.map(annotation => ({
+                type: annotation.type,
+                visibility: annotation.visibility,
+                elements: annotation.elements.map(element => ({
+                    name: element.name,
+                    value: convertToTaggedEncodedValue(element.value),
+                })),
+            })));
+            continue;
+        }
+        annotations.fieldAnnotations.push({
+            field: smaliField.field.field,
+            annotations: smaliField.annotations.map(annotation => ({
+                type: annotation.type,
+                visibility: annotation.visibility,
+                elements: annotation.elements.map(element => ({
+                    name: element.name,
+                    value: convertToTaggedEncodedValue(element.value),
+                })),
+            })),
+        });
+    }
+    // Sort field annotations to match DEX file order (by field name, then type)
+    // This matches the annotations_directory_item field_annotations order in DEX files
+    // Use binary string comparison (case-sensitive) to match UTF-8 byte order
+    annotations.fieldAnnotations.sort((a, b) => {
+        // First by field name (case-sensitive comparison)
+        if (a.field.name !== b.field.name) {
+            return a.field.name < b.field.name ? -1 : 1;
+        }
+        // Then by field type (case-sensitive comparison)
+        return a.field.type < b.field.type ? -1 : 1;
+    });
+    // Compute synthetic flag from members if not explicitly set
+    // This matches baksmali behavior where synthetic flag at class level is not output
+    // but can be inferred from all members being synthetic
+    const allMembers = [
+        ...fields.staticFields,
+        ...fields.instanceFields,
+        ...methods.directMethods,
+        // Note: virtualMethods are not included, matching DEX parser behavior
+    ];
+    const allMembersAreSynthetic = (allMembers.every(member => member.accessFlags.synthetic)
+        && allMembers.length > 0);
+    const finalAccessFlags = {
+        ...accessFlags,
+        // Use the synthetic flag from the class declaration, or compute it from members if not set
+        synthetic: accessFlags.synthetic || allMembersAreSynthetic,
+    };
+    return {
+        accessFlags: finalAccessFlags,
+        class: class_,
+        superclass,
+        sourceFile,
+        annotations: ((annotations.classAnnotations?.length
+            || annotations.fieldAnnotations?.length
+            || annotations.methodAnnotations?.length
+            || annotations.parameterAnnotations?.length)
+            ? ({
+                classAnnotations: annotations.classAnnotations,
+                fieldAnnotations: annotations.fieldAnnotations.map(fieldAnnotation => ({
+                    ...fieldAnnotation,
+                    field: {
+                        ...fieldAnnotation.field,
+                        class: class_,
+                    },
+                })),
+                methodAnnotations: annotations.methodAnnotations
+                    .map(methodAnnotation => ({
+                    ...methodAnnotation,
+                    method: {
+                        ...methodAnnotation.method,
+                        class: class_,
+                    },
+                }))
+                    // Sort method annotations to match DEX file order (lexicographic by method name, then prototype shorty)
+                    // This matches the method_idx order in the DEX file's method_id table
+                    .sort((a, b) => {
+                    // Sort by method name first (using code point comparison, not locale-aware)
+                    if (a.method.name !== b.method.name) {
+                        return a.method.name < b.method.name ? -1 : 1;
+                    }
+                    // Then by shorty (prototype signature)
+                    return a.method.prototype.shorty < b.method.prototype.shorty ? -1 : 1;
+                }),
+                parameterAnnotations: annotations.parameterAnnotations.map(parameterAnnotation => ({
+                    ...parameterAnnotation,
+                    method: {
+                        ...parameterAnnotation.method,
+                        class: class_,
+                    },
+                })),
+            })
+            : undefined),
+        classData: ((methods.directMethods.length > 0
+            || methods.virtualMethods.length > 0
+            || (fields?.staticFields.length ?? 0)
+            || (fields?.instanceFields.length ?? 0))
+            ? ({
+                directMethods: methods.directMethods.map(method => ({
+                    ...method,
+                    method: {
+                        ...method.method,
+                        class: class_,
+                    },
+                })),
+                virtualMethods: methods.virtualMethods.map(method => ({
+                    ...method,
+                    method: {
+                        ...method.method,
+                        class: class_,
+                    },
+                })),
+                staticFields: (fields?.staticFields ?? []).map(field => ({
+                    ...field,
+                    field: {
+                        ...field.field,
+                        class: class_,
+                    },
+                })),
+                instanceFields: (fields?.instanceFields ?? []).map(field => ({
+                    ...field,
+                    field: {
+                        ...field.field,
+                        class: class_,
+                    },
+                })),
+            })
+            : undefined),
+        interfaces: interfaces ?? [],
+        staticValues,
+    };
+});
+setParserName(smaliParser, 'smaliParser');