@futpib/parser 1.0.1 → 1.0.3

package/build/dalvikExecutableParser.js

@@ -0,0 +1,1757 @@
+import invariant from 'invariant';
+import { MUtf8Decoder } from 'mutf-8';
+import { createExactElementParser } from './exactElementParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { cloneParser, setParserName } from './parser.js';
+import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createQuantifierParser } from './quantifierParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { createSkipToParser } from './skipToParser.js';
+import { createLookaheadParser } from './lookaheadParser.js';
+import { getIsoTypedNumberArray, isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoPrototypeIds, isoIndexIntoStringIds, isoIndexIntoTypeIds, isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler, isoOffsetToAnnotationItem, isoOffsetToAnnotationsDirectoryItem, isoOffsetToAnnotationSetItem, isoOffsetToAnnotationSetRefListItem, isoOffsetToClassDataItem, isoOffsetToCodeItem, isoOffsetToDebugInfoItem, isoOffsetToEncodedArrayItem, isoOffsetToStringDataItem, isoOffsetToTypeList, } from './dalvikExecutableParser/typedNumbers.js';
+import { sleb128NumberParser, uleb128NumberParser } from './leb128Parser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createElementTerminatedSequenceParser } from './elementTerminatedSequenceParser.js';
+import { createElementTerminatedArrayParserUnsafe } from './elementTerminatedArrayParser.js';
+import { createDalvikBytecodeParser, resolveDalvikBytecodeOperation, } from './dalvikBytecodeParser.js';
+import { byteParser, ubyteParser, uintParser, uleb128p1NumberParser, ushortParser, } from './dalvikExecutableParser/typeParsers.js';
+// https://source.android.com/docs/core/runtime/dex-format
+const createByteAlignParser = (byteAlignment) => async (parserContext) => {
+    const toSkip = (byteAlignment - (parserContext.position % byteAlignment)) % byteAlignment;
+    parserContext.skip(toSkip);
+};
+const byteAlign4Parser = createByteAlignParser(4);
+const dalvikExecutableHeaderVersionParser = promiseCompose(createTupleParser([
+    createExactSequenceParser(Buffer.from('dex\n', 'utf8')),
+    createFixedLengthSequenceParser(3),
+    createExactElementParser(0),
+]), ([_magic1, versionUint8Array, _magic2]) => {
+    const versionBuffer = Buffer.from(versionUint8Array);
+    const versionString = versionBuffer.toString('utf8');
+    const version = Number.parseInt(versionString, 10);
+    return version;
+});
+const sizeOffsetParser = promiseCompose(createTupleParser([
+    uintParser,
+    uintParser,
+]), ([size, offset]) => ({ size, offset }));
+const dalvikExecutableHeaderItemParser = promiseCompose(createTupleParser([
+    dalvikExecutableHeaderVersionParser,
+    uintParser,
+    createFixedLengthSequenceParser(20),
+    uintParser,
+    uintParser,
+    uintParser,
+    sizeOffsetParser,
+    uintParser,
+    sizeOffsetParser,
+    sizeOffsetParser,
+    sizeOffsetParser,
+    sizeOffsetParser,
+    sizeOffsetParser,
+    sizeOffsetParser,
+    sizeOffsetParser,
+]), ([version, checksum, sha1Hash, fileSize, headerSize, endianTag, link, mapOffset, stringIds, typeIds, prototypeIds, fieldIds, methodIds, classDefinitions, data,]) => ({
+    version,
+    checksum,
+    sha1Hash,
+    fileSize,
+    headerSize,
+    endianTag,
+    link,
+    mapOffset,
+    stringIds,
+    typeIds,
+    prototypeIds,
+    fieldIds,
+    methodIds,
+    classDefinitions,
+    data,
+}));
+const dalvikExecutableStringIdItemParser = promiseCompose(cloneParser(uintParser), offset => isoOffsetToStringDataItem.wrap(offset));
+const isoDalvikExecutableStringIdItems = getIsoTypedNumberArray();
+const createSkipToThenStringIdItemsParser = ({ size, offset }) => (size === 0
+    ? (() => isoDalvikExecutableStringIdItems.wrap([]))
+    : promiseCompose(createTupleParser([
+        createSkipToParser(offset),
+        createQuantifierParser(dalvikExecutableStringIdItemParser, size),
+    ]), ([_, stringIds]) => isoDalvikExecutableStringIdItems.wrap(stringIds)));
+const dalvikExecutableTypeIdItemParser = promiseCompose(cloneParser(uintParser), index => isoIndexIntoStringIds.wrap(index));
+const isoDalvikExecutableTypeIdItems = getIsoTypedNumberArray();
+const createSkipToThenTypeIdItemsParser = ({ size, offset }) => (size === 0
+    ? (() => isoDalvikExecutableTypeIdItems.wrap([]))
+    : promiseCompose(createTupleParser([
+        createSkipToParser(offset),
+        createQuantifierParser(dalvikExecutableTypeIdItemParser, size),
+    ]), ([_, typeIds]) => isoDalvikExecutableTypeIdItems.wrap(typeIds)));
+const prototypeIdItemParser = promiseCompose(createTupleParser([
+    byteAlign4Parser,
+    uintParser,
+    uintParser,
+    uintParser,
+]), ([_, shortyIndex, returnTypeIndex, parametersOffset]) => ({
+    shortyIndex: isoIndexIntoStringIds.wrap(shortyIndex),
+    returnTypeIndex: isoIndexIntoTypeIds.wrap(returnTypeIndex),
+    parametersOffset: isoOffsetToTypeList.wrap(parametersOffset),
+}));
+const isoDalvikExecutablePrototypeIdItems = getIsoTypedNumberArray();
+const createSkipToThenPrototypeIdItemsParser = ({ size, offset }) => (size === 0
+    ? (() => isoDalvikExecutablePrototypeIdItems.wrap([]))
+    : promiseCompose(createTupleParser([
+        createSkipToParser(offset),
+        createQuantifierParser(prototypeIdItemParser, size),
+    ]), ([_, prototypeIds]) => isoDalvikExecutablePrototypeIdItems.wrap(prototypeIds)));
+const createSkipToThenItemByOffsetParser = ({ sizeOffset: { size, offset }, itemParser, byteAlign4, isoOffset, parserName, }) => {
+    const skipToThenItemByOffsetParser = async (parserContext) => {
+        const itemByOffset = new Map();
+        if (size === 0) {
+            return itemByOffset;
+        }
+        await createSkipToParser(offset)(parserContext);
+        for (let i = 0; i < size; i++) {
+            if (byteAlign4) {
+                await byteAlign4Parser(parserContext);
+            }
+            const offset = parserContext.position;
+            const item = await itemParser(parserContext);
+            itemByOffset.set(isoOffset.wrap(offset), item);
+        }
+        return itemByOffset;
+    };
+    setParserName(skipToThenItemByOffsetParser, parserName);
+    return skipToThenItemByOffsetParser;
+};
+const dalvikExecutableFieldIdItemParser = promiseCompose(createTupleParser([
+    ushortParser,
+    ushortParser,
+    uintParser,
+]), ([classIndex, typeIndex, nameIndex]) => ({
+    classIndex: isoIndexIntoTypeIds.wrap(classIndex),
+    typeIndex: isoIndexIntoTypeIds.wrap(typeIndex),
+    nameIndex: isoIndexIntoStringIds.wrap(nameIndex),
+}));
+const isoDalvikExecutableFieldIdItems = getIsoTypedNumberArray();
+const createSkipToThenFieldIdItemsParser = ({ size, offset }) => (size === 0
+    ? (() => isoDalvikExecutableFieldIdItems.wrap([]))
+    : promiseCompose(createTupleParser([
+        createSkipToParser(offset),
+        createQuantifierParser(dalvikExecutableFieldIdItemParser, size),
+    ]), ([_, fieldIds]) => isoDalvikExecutableFieldIdItems.wrap(fieldIds)));
+const dalvikExecutableMethodIdItemParser = promiseCompose(createTupleParser([
+    ushortParser,
+    ushortParser,
+    uintParser,
+]), ([classIndex, prototypeIndex, nameIndex]) => ({
+    classIndex: isoIndexIntoTypeIds.wrap(classIndex),
+    prototypeIndex: isoIndexIntoPrototypeIds.wrap(prototypeIndex),
+    nameIndex: isoIndexIntoStringIds.wrap(nameIndex),
+}));
+const isoDalvikExecutableMethodIdItems = getIsoTypedNumberArray();
+const createSkipToThenMethodIdItemsParser = ({ size, offset }) => (size === 0
+    ? (() => isoDalvikExecutableMethodIdItems.wrap([]))
+    : promiseCompose(createTupleParser([
+        createSkipToParser(offset),
+        createQuantifierParser(dalvikExecutableMethodIdItemParser, size),
+    ]), ([_, methodIds]) => isoDalvikExecutableMethodIdItems.wrap(methodIds)));
+const parseAccessFlagsCommon = (flags) => ({
+    public: Boolean(flags & 0b0000_0001),
+    private: Boolean(flags & 0b0000_0010),
+    protected: Boolean(flags & 0b0000_0100),
+    static: Boolean(flags & 0b0000_1000),
+    final: Boolean(flags & 0b0001_0000),
+    synchronized: Boolean(flags & 0b0010_0000),
+    volatile: false,
+    bridge: false,
+    transient: Boolean(flags & 0b1000_0000),
+    varargs: Boolean(flags & 0b1000_0000),
+    native: Boolean(flags & 0b0000_0001_0000_0000),
+    interface: Boolean(flags & 0b0000_0010_0000_0000),
+    abstract: Boolean(flags & 0b0000_0100_0000_0000),
+    strict: Boolean(flags & 0b0000_1000_0000_0000),
+    synthetic: Boolean(flags & 0b0001_0000_0000_0000),
+    annotation: Boolean(flags & 0b0010_0000_0000_0000),
+    enum: Boolean(flags & 0b0100_0000_0000_0000),
+    constructor: Boolean(flags & 0b0000_0001_0000_0000_0000_0000),
+    declaredSynchronized: Boolean(flags & 0b0000_0010_0000_0000_0000_0000),
+});
+const parseAccessFlags = (flags) => parseAccessFlagsCommon(flags);
+const parseFieldAccessFlags = (flags) => ({
+    ...parseAccessFlagsCommon(flags),
+    volatile: Boolean(flags & 0b0100_0000),
+    varargs: false, // Varargs is only for methods, not fields
+    bridge: false,
+});
+const parseMethodAccessFlags = (flags) => ({
+    ...parseAccessFlagsCommon(flags),
+    volatile: false,
+    transient: false, // Transient is only for fields, not methods
+    bridge: Boolean(flags & 0b0100_0000),
+});
+const uintAccessFlagsParser = promiseCompose(uintParser, parseAccessFlags);
+const uleb128AccessFlagsParser = promiseCompose(uleb128NumberParser, parseAccessFlags);
+const uleb128FieldAccessFlagsParser = promiseCompose(uleb128NumberParser, parseFieldAccessFlags);
+const uleb128MethodAccessFlagsParser = promiseCompose(uleb128NumberParser, parseMethodAccessFlags);
+const DEX_CLASS_DEFINITION_ITEM_SOURCE_FILE_NO_INDEX = 0xFF_FF_FF_FF;
+const createSkipToThenClassDefinitionItemsParser = ({ size, offset }) => (size === 0
+    ? (() => [])
+    : promiseCompose(createTupleParser([
+        createSkipToParser(offset),
+        createQuantifierParser(promiseCompose(createTupleParser([
+            uintParser,
+            uintAccessFlagsParser,
+            uintParser,
+            uintParser,
+            uintParser,
+            uintParser,
+            uintParser,
+            uintParser,
+        ]), ([classIndex, accessFlags, superclassIndex, interfacesOffset, sourceFileIndex, annotationsOffset, classDataOffset, staticValuesOffset,]) => ({
+            classIndex: isoIndexIntoTypeIds.wrap(classIndex),
+            accessFlags,
+            superclassIndex: isoIndexIntoTypeIds.wrap(superclassIndex),
+            interfacesOffset: isoOffsetToTypeList.wrap(interfacesOffset),
+            sourceFileIndex: (sourceFileIndex === DEX_CLASS_DEFINITION_ITEM_SOURCE_FILE_NO_INDEX
+                ? undefined
+                : isoIndexIntoStringIds.wrap(sourceFileIndex)),
+            annotationsOffset: isoOffsetToAnnotationsDirectoryItem.wrap(annotationsOffset),
+            classDataOffset: isoOffsetToClassDataItem.wrap(classDataOffset),
+            staticValuesOffset: isoOffsetToEncodedArrayItem.wrap(staticValuesOffset),
+        })), size),
+    ]), ([_, classDefinitions]) => classDefinitions));
+const createRawDataParser = ({ size, offset }) => (size === 0
+    ? (() => undefined)
+    : promiseCompose(createTupleParser([
+        createSkipToParser(offset),
+        createFixedLengthSequenceParser(size),
+    ]), ([_, data]) => data));
+const stringDataItemParser = promiseCompose(createTupleParser([
+    uleb128NumberParser,
+    createElementTerminatedSequenceParser(0),
+]), ([utf16Size, data]) => ({
+    utf16Size,
+    data: new Uint8Array(data),
+}));
+const stringDataItemStringParser = promiseCompose(stringDataItemParser, ({ utf16Size, data }) => {
+    const mutf8Decoder = new MUtf8Decoder();
+    const string = mutf8Decoder.decode(data);
+    invariant(string.length === utf16Size, 'String length mismatch. Expected: %s, actual: %s', utf16Size, string.length);
+    return string;
+});
+const createSkipToThenStringsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
+    sizeOffset,
+    itemParser: stringDataItemStringParser,
+    byteAlign4: false,
+    isoOffset: isoOffsetToStringDataItem,
+    parserName: 'skipToThenStringsParser',
+});
+const dalvikExecutableTypeItemParser = promiseCompose(cloneParser(ushortParser), index => isoIndexIntoTypeIds.wrap(index));
+const isoDalvikExecutableTypeList = getIsoTypedNumberArray();
+const dalvikExecutableTypeListParser = parserCreatorCompose(() => createTupleParser([
+    byteAlign4Parser,
+    uintParser,
+]), ([_, size]) => promiseCompose(createQuantifierParser(dalvikExecutableTypeItemParser, size), typeItems => isoDalvikExecutableTypeList.wrap(typeItems)))();
+const createSkipToThenTypeListByOffsetParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
+    sizeOffset,
+    itemParser: dalvikExecutableTypeListParser,
+    byteAlign4: true,
+    isoOffset: isoOffsetToTypeList,
+    parserName: 'skipToThenTypeListByOffsetParser',
+});
+const fieldAnnotationParser = promiseCompose(createTupleParser([
+    uintParser,
+    uintParser,
+]), ([fieldIndex, annotationsOffset,]) => ({
+    fieldIndex: isoIndexIntoFieldIds.wrap(fieldIndex),
+    annotationsOffset: isoOffsetToAnnotationSetItem.wrap(annotationsOffset),
+}));
+const createFieldAnnotationsParser = (fieldsSize) => createQuantifierParser(fieldAnnotationParser, fieldsSize);
+const methodAnnotationParser = promiseCompose(createTupleParser([
+    uintParser,
+    uintParser,
+]), ([methodIndex, annotationsOffset,]) => ({
+    methodIndex: isoIndexIntoMethodIds.wrap(methodIndex),
+    annotationsOffset: isoOffsetToAnnotationSetItem.wrap(annotationsOffset),
+}));
+const createMethodAnnotationsParser = (methodsSize) => createQuantifierParser(methodAnnotationParser, methodsSize);
+const parameterAnnotationParser = promiseCompose(createTupleParser([
+    uintParser,
+    uintParser,
+]), ([methodIndex, annotationsOffset,]) => ({
+    methodIndex: isoIndexIntoMethodIds.wrap(methodIndex),
+    annotationsOffset: isoOffsetToAnnotationSetRefListItem.wrap(annotationsOffset),
+}));
+const createParameterAnnotationsParser = (parametersSize) => createQuantifierParser(parameterAnnotationParser, parametersSize);
+const annotationsDirectoryItemParser = parserCreatorCompose(() => createTupleParser([
+    byteAlign4Parser,
+    uintParser,
+    uintParser,
+    uintParser,
+    uintParser,
+]), ([_, classAnnotationsOffset, fieldsSize, annotatedMethodsSize, annotatedParametersSize,]) => promiseCompose(createTupleParser([
+    () => isoOffsetToAnnotationSetItem.wrap(classAnnotationsOffset),
+    createFieldAnnotationsParser(fieldsSize),
+    createMethodAnnotationsParser(annotatedMethodsSize),
+    createParameterAnnotationsParser(annotatedParametersSize),
+]), ([classAnnotationsOffset, fieldAnnotations, methodAnnotations, parameterAnnotations,]) => ({
+    classAnnotationsOffset,
+    fieldAnnotations,
+    methodAnnotations,
+    parameterAnnotations,
+})))();
+const createSkipToThenAnnotationsDirectoryItemsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
+    sizeOffset,
+    itemParser: annotationsDirectoryItemParser,
+    byteAlign4: true,
+    isoOffset: isoOffsetToAnnotationsDirectoryItem,
+    parserName: 'skipToThenAnnotationsDirectoryItemsParser',
+});
+const encodedFieldParser = promiseCompose(createTupleParser([
+    uleb128NumberParser,
+    uleb128FieldAccessFlagsParser,
+]), ([fieldIndexDiff, accessFlags]) => ({ fieldIndexDiff, accessFlags }));
+const createEncodedFieldsParser = (fieldsSize) => promiseCompose(createQuantifierParser(encodedFieldParser, fieldsSize), encodedFields => {
+    let previousFieldIndex = 0;
+    return encodedFields.map(({ fieldIndexDiff, accessFlags }) => {
+        previousFieldIndex += fieldIndexDiff;
+        return {
+            fieldIndex: isoIndexIntoFieldIds.wrap(previousFieldIndex),
+            accessFlags,
+        };
+    });
+});
+const encodedMethodParser = promiseCompose(createTupleParser([
+    uleb128NumberParser,
+    uleb128MethodAccessFlagsParser,
+    uleb128NumberParser,
+]), ([methodIndexDiff, accessFlags, codeOffset,]) => ({
+    methodIndexDiff,
+    accessFlags,
+    codeOffset: isoOffsetToCodeItem.wrap(codeOffset),
+}));
+const createEncodedMethodsParser = (methodsSize) => promiseCompose(createQuantifierParser(encodedMethodParser, methodsSize), encodedMethods => {
+    let previousMethodIndex = 0;
+    return encodedMethods.map(({ methodIndexDiff, accessFlags, codeOffset }) => {
+        previousMethodIndex += methodIndexDiff;
+        return {
+            methodIndex: isoIndexIntoMethodIds.wrap(previousMethodIndex),
+            accessFlags,
+            codeOffset,
+        };
+    });
+});
+const classDataItemParser = parserCreatorCompose(() => createTupleParser([
+    uleb128NumberParser,
+    uleb128NumberParser,
+    uleb128NumberParser,
+    uleb128NumberParser,
+]), ([staticFieldsSize, instanceFieldsSize, directMethodsSize, virtualMethodsSize,]) => promiseCompose(createTupleParser([
+    createEncodedFieldsParser(staticFieldsSize),
+    createEncodedFieldsParser(instanceFieldsSize),
+    createEncodedMethodsParser(directMethodsSize),
+    createEncodedMethodsParser(virtualMethodsSize),
+]), ([staticFields, instanceFields, directMethods, virtualMethods,]) => ({
+    staticFields,
+    instanceFields,
+    directMethods,
+    virtualMethods,
+})))();
+const createSkipToThenClassDataItemsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
+    sizeOffset,
+    itemParser: classDataItemParser,
+    byteAlign4: false,
+    isoOffset: isoOffsetToClassDataItem,
+    parserName: 'skipToThenClassDataItemsParser',
+});
+const createByteWith5LeastSignificantBitsEqualParser = (leastSignificant5) => {
+    const byteWith5LeastSignificantBitsEqualParser = async (parserContext) => {
+        const byte = await parserContext.read(0);
+        parserContext.invariant((byte & 0b0001_1111) === leastSignificant5, 'Expected byte with 5 least significant bits equal to %s, but got %s', leastSignificant5.toString(2).padStart(8, '0'), byte.toString(2).padStart(8, '0'));
+        return byte;
+    };
+    setParserName(byteWith5LeastSignificantBitsEqualParser, `createByteWith5LeastSignificantBitsEqualParser(${leastSignificant5.toString(2).padStart(5, '0')})`);
+    return byteWith5LeastSignificantBitsEqualParser;
+};
+const createEncodedValueArgParser = (valueType) => promiseCompose(createByteWith5LeastSignificantBitsEqualParser(valueType), byte => byte >> 5);
+const encodedValueByteParser = promiseCompose(createTupleParser([
+    createExactElementParser(0),
+    byteParser,
+]), ([_, value]) => ({ type: 'byte', value }));
+setParserName(encodedValueByteParser, 'encodedValueByteParser');
+const encodedValueShortParser = parserCreatorCompose(() => createEncodedValueArgParser(0x02), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'short', value: buffer.readInt8(0) };
+        });
+    }
+    invariant(size === 2, '(encodedValueShortParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'short', value: buffer.readInt16LE(0) };
+    });
+})();
+setParserName(encodedValueShortParser, 'encodedValueShortParser');
+const encodedValueCharParser = parserCreatorCompose(() => createEncodedValueArgParser(0x03), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size == 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([...uint8Array, 0]);
+            return { type: 'char', value: buffer.readUInt16LE(0) };
+        });
+    }
+    invariant(size === 2, '(encodedValueCharParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'char', value: buffer.readUInt16LE(0) };
+    });
+})();
+setParserName(encodedValueCharParser, 'encodedValueCharParser');
+const encodedValueIntParser = parserCreatorCompose(() => createEncodedValueArgParser(0x04), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'int', value: buffer.readInt8(0) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'int', value: buffer.readInt16LE(0) };
+        });
+    }
+    if (size === 3) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const lastByte = uint8Array[uint8Array.length - 1];
+            const signBit = (lastByte & 0b1000_0000) >> 7;
+            const extensionByte = signBit === 1 ? 0xFF : 0x00;
+            const buffer = Buffer.from([...uint8Array, extensionByte]);
+            return { type: 'int', value: buffer.readInt32LE(0) };
+        });
+    }
+    invariant(size === 4, '(encodedValueIntParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'int', value: buffer.readInt32LE(0) };
+    });
+})();
+setParserName(encodedValueIntParser, 'encodedValueIntParser');
+const encodedValueLongParser = parserCreatorCompose(() => createEncodedValueArgParser(0x06), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'long', value: BigInt(buffer.readInt8(0)) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'long', value: BigInt(buffer.readInt16LE(0)) };
+        });
+    }
+    if (size === 3) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const lastByte = uint8Array[size - 1];
+            const firstBit = (lastByte & 0b1000_0000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xFF : 0x00;
+            const buffer = Buffer.from([...uint8Array, extensionByte]);
+            return { type: 'long', value: BigInt(buffer.readInt32LE(0)) };
+        });
+    }
+    if (size === 4) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'long', value: BigInt(buffer.readInt32LE(0)) };
+        });
+    }
+    if (size === 5) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const lastByte = uint8Array[size - 1];
+            const firstBit = (lastByte & 0b1000_0000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xFF : 0x00;
+            const buffer = Buffer.from([...uint8Array, extensionByte, extensionByte, extensionByte]);
+            return { type: 'long', value: BigInt(buffer.readBigInt64LE(0)) };
+        });
+    }
+    if (size === 6) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const lastByte = uint8Array[size - 1];
+            const firstBit = (lastByte & 0b1000_0000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xFF : 0x00;
+            const buffer = Buffer.from([...uint8Array, extensionByte, extensionByte]);
+            return { type: 'long', value: BigInt(buffer.readBigInt64LE(0)) };
+        });
+    }
+    if (size === 7) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const lastByte = uint8Array[size - 1];
+            const firstBit = (lastByte & 0b1000_0000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xFF : 0x00;
+            const buffer = Buffer.from([...uint8Array, extensionByte]);
+            return { type: 'long', value: BigInt(buffer.readBigInt64LE(0)) };
+        });
+    }
+    invariant(size === 8, '(encodedValueLongParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'long', value: buffer.readBigInt64LE(0) };
+    });
+})();
+setParserName(encodedValueLongParser, 'encodedValueLongParser');
+const encodedValueFloatParser = parserCreatorCompose(() => createEncodedValueArgParser(0x10), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, ...uint8Array]);
+            return { type: 'float', value: buffer.readFloatLE(0) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, ...uint8Array]);
+            return { type: 'float', value: buffer.readFloatLE(0) };
+        });
+    }
+    if (size === 3) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, ...uint8Array]);
+            return { type: 'float', value: buffer.readFloatLE(0) };
+        });
+    }
+    invariant(size === 4, '(encodedValueFloatParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'float', value: buffer.readFloatLE(0) };
+    });
+})();
+setParserName(encodedValueFloatParser, 'encodedValueFloatParser');
+const encodedValueDoubleParser = parserCreatorCompose(() => createEncodedValueArgParser(0x11), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, 0, 0, 0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, 0, 0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    if (size === 3) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, 0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    if (size === 4) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    if (size === 5) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    if (size === 6) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, 0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    if (size === 7) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from([0, ...uint8Array]);
+            return { type: 'double', value: buffer.readDoubleLE(0) };
+        });
+    }
+    invariant(size === 8, '(encodedValueDoubleParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'double', value: buffer.readDoubleLE(0) };
+    });
+})();
+setParserName(encodedValueDoubleParser, 'encodedValueDoubleParser');
+const encodedValueMethodTypeParser = parserCreatorCompose(() => createEncodedValueArgParser(0x15), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'methodType', value: isoIndexIntoPrototypeIds.wrap(buffer.readUint8(0)) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'methodType', value: isoIndexIntoPrototypeIds.wrap(buffer.readUInt16LE(0)) };
+        });
+    }
+    invariant(size === 4, '(encodedValueMethodTypeParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'methodType', value: isoIndexIntoPrototypeIds.wrap(buffer.readUInt32LE(0)) };
+    });
+})();
+setParserName(encodedValueMethodTypeParser, 'encodedValueMethodTypeParser');
+const encodedValueMethodHandleParser = parserCreatorCompose(() => createEncodedValueArgParser(0x16), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'methodHandle', value: buffer.readUInt8(0) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'methodHandle', value: buffer.readUInt16LE(0) };
+        });
+    }
+    invariant(size === 4, '(encodedValueMethodHandleParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'methodHandle', value: buffer.readUInt32LE(0) };
+    });
+})();
+setParserName(encodedValueMethodHandleParser, 'encodedValueMethodHandleParser');
+const encodedValueStringParser = parserCreatorCompose(() => createEncodedValueArgParser(0x17), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'string', value: isoIndexIntoStringIds.wrap(buffer.readUInt8(0)) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'string', value: isoIndexIntoStringIds.wrap(buffer.readUInt16LE(0)) };
+        });
+    }
+    invariant(size === 4, '(encodedValueStringParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'string', value: isoIndexIntoStringIds.wrap(buffer.readUInt32LE(0)) };
+    });
+})();
+setParserName(encodedValueStringParser, 'encodedValueStringParser');
+const encodedValueTypeParser = parserCreatorCompose(() => createEncodedValueArgParser(0x18), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'type', value: isoIndexIntoTypeIds.wrap(buffer.readUInt8(0)) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'type', value: isoIndexIntoTypeIds.wrap(buffer.readUInt16LE(0)) };
+        });
+    }
+    invariant(size === 4, '(encodedValueTypeParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'type', value: isoIndexIntoTypeIds.wrap(buffer.readUInt32LE(0)) };
+    });
+})();
+setParserName(encodedValueTypeParser, 'encodedValueTypeParser');
+const encodedValueFieldParser = parserCreatorCompose(() => createEncodedValueArgParser(0x19), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'field', value: isoIndexIntoFieldIds.wrap(buffer.readUInt8(0)) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'field', value: isoIndexIntoFieldIds.wrap(buffer.readUInt16LE(0)) };
+        });
+    }
+    invariant(size === 4, '(encodedValueFieldParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'field', value: isoIndexIntoFieldIds.wrap(buffer.readUInt32LE(0)) };
+    });
+})();
+setParserName(encodedValueFieldParser, 'encodedValueFieldParser');
+const encodedValueMethodParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1A), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'method', value: isoIndexIntoMethodIds.wrap(buffer.readUInt8(0)) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'method', value: isoIndexIntoMethodIds.wrap(buffer.readUInt16LE(0)) };
+        });
+    }
+    invariant(size === 4, '(encodedValueMethodParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'method', value: isoIndexIntoMethodIds.wrap(buffer.readUInt32LE(0)) };
+    });
+})();
+setParserName(encodedValueMethodParser, 'encodedValueMethodParser');
+const encodedValueEnumParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1B), sizeSubOne => {
+    const size = sizeSubOne + 1;
+    if (size === 1) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'enum', value: isoIndexIntoFieldIds.wrap(buffer.readUInt8(0)) };
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+            const buffer = Buffer.from(uint8Array);
+            return { type: 'enum', value: isoIndexIntoFieldIds.wrap(buffer.readUInt16LE(0)) };
+        });
+    }
+    invariant(size === 4, '(encodedValueEnumParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), uint8Array => {
+        const buffer = Buffer.from(uint8Array);
+        return { type: 'enum', value: isoIndexIntoFieldIds.wrap(buffer.readUInt32LE(0)) };
+    });
+})();
+setParserName(encodedValueEnumParser, 'encodedValueEnumParser');
+const encodedArrayParser = parserCreatorCompose(() => uleb128NumberParser, size => createQuantifierParser(encodedValueParser, size))();
+setParserName(encodedArrayParser, 'encodedArrayParser');
+const encodedValueArrayParser = promiseCompose(createTupleParser([
+    parserCreatorCompose(() => createEncodedValueArgParser(0x1C), valueArg => parserContext => {
+        parserContext.invariant(valueArg === 0, '(encodedValueArrayParser) valueArg: %s', valueArg);
+    })(),
+    encodedArrayParser,
+]), ([_, array]) => ({ type: 'array', value: array }));
+setParserName(encodedValueArrayParser, 'encodedValueArrayParser');
+const annotationElementParser = promiseCompose(createTupleParser([
+    uleb128NumberParser,
+    createParserAccessorParser(() => encodedValueParser),
+]), ([nameIndex, value,]) => ({
+    nameIndex: isoIndexIntoStringIds.wrap(nameIndex),
+    value,
+}));
+setParserName(annotationElementParser, 'annotationElementParser');
+const encodedAnnotationParser = promiseCompose(parserCreatorCompose(() => createTupleParser([
+    uleb128NumberParser,
+    uleb128NumberParser,
+]), ([typeIndex, size,]) => createTupleParser([
+    () => typeIndex,
+    createQuantifierParser(annotationElementParser, size),
+]))(), ([typeIndex, elements,]) => ({
+    typeIndex: isoIndexIntoTypeIds.wrap(typeIndex),
+    elements,
+}));
+setParserName(encodedAnnotationParser, 'encodedAnnotationParser');
+const encodedValueAnnotationParser = promiseCompose(createTupleParser([
+    parserCreatorCompose(() => createEncodedValueArgParser(0x1D), valueArg => parserContext => {
+        parserContext.invariant(valueArg === 0, '(encodedValueAnnotationParser) valueArg: %s', valueArg);
+    })(),
+    encodedAnnotationParser,
+]), ([_, annotation]) => ({ type: 'annotation', value: annotation }));
+setParserName(encodedValueAnnotationParser, 'encodedValueAnnotationParser');
+const encodedValueNullParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1E), valueArg => parserContext => {
+    parserContext.invariant(valueArg === 0, '(encodedValueNullParser) valueArg: %s', valueArg);
+    return ({ type: 'null', value: null });
+})();
+setParserName(encodedValueNullParser, 'encodedValueNullParser');
+const encodedValueBooleanParser = promiseCompose(createEncodedValueArgParser(0x1F), valueArg => ({ type: 'boolean', value: Boolean(valueArg) }));
+setParserName(encodedValueBooleanParser, 'encodedValueBooleanParser');
+const encodedValueParser = createDisjunctionParser([
+    encodedValueByteParser,
+    encodedValueShortParser,
+    encodedValueCharParser,
+    encodedValueIntParser,
+    encodedValueLongParser,
+    encodedValueFloatParser,
+    encodedValueDoubleParser,
+    encodedValueMethodTypeParser,
+    encodedValueMethodHandleParser,
+    encodedValueStringParser,
+    encodedValueTypeParser,
+    encodedValueFieldParser,
+    encodedValueMethodParser,
+    encodedValueEnumParser,
+    encodedValueArrayParser,
+    encodedValueAnnotationParser,
+    encodedValueNullParser,
+    encodedValueBooleanParser,
+]);
+setParserName(encodedValueParser, 'encodedValueParser');
+const tryItemParser = promiseCompose(createTupleParser([
+    uintParser,
+    ushortParser,
+    ushortParser,
+]), ([startAddress, instructionCount, handlerOffset,]) => ({
+    startAddress,
+    instructionCount,
+    handlerOffset: isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler.wrap(handlerOffset),
+}));
+setParserName(tryItemParser, 'tryItemParser');
+const encodedTypeAddressPairParser = promiseCompose(createTupleParser([
+    uleb128NumberParser,
+    uleb128NumberParser,
+]), ([typeIndex, address,]) => ({
+    typeIndex: isoIndexIntoTypeIds.wrap(typeIndex),
+    address,
+}));
+const encodedCatchHandlerParser = parserCreatorCompose(() => sleb128NumberParser, size => promiseCompose(createTupleParser([
+    createQuantifierParser(encodedTypeAddressPairParser, Math.abs(size)),
+    size <= 0 ? uleb128NumberParser : () => undefined,
+]), ([handlers, catchAllAddress,]) => ({
+    size,
+    handlers,
+    catchAllAddress,
+})))();
+setParserName(encodedCatchHandlerParser, 'encodedCatchHandlerParser');
+const encodedCatchHandlerListParser = async (parserContext) => {
+    const listOffset = parserContext.position;
+    const handlers = new Map();
+    const size = await uleb128NumberParser(parserContext);
+    for (let i = 0; i < size; i += 1) {
+        const handlerRelativeOffset = isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler.wrap(parserContext.position - listOffset);
+        const handler = await encodedCatchHandlerParser(parserContext);
+        handlers.set(handlerRelativeOffset, handler);
+    }
+    return handlers;
+};
+setParserName(encodedCatchHandlerListParser, 'encodedCatchHandlerListParser');
+const createDalvikExecutableCodeItemParser = ({ createInstructionsParser, }) => {
+    const dalvikExecutableCodeItemParser = parserCreatorCompose(() => createTupleParser([
+        byteAlign4Parser,
+        ushortParser,
+        ushortParser,
+        ushortParser,
+        ushortParser,
+        uintParser,
+        uintParser,
+    ]), ([_, registersSize, insSize, outsSize, triesSize, debugInfoOffset, instructionsSize,]) => promiseCompose(createTupleParser([
+        createInstructionsParser(instructionsSize * 2),
+        ((triesSize !== 0
+            && instructionsSize % 2 === 1)
+            ? byteAlign4Parser
+            : () => undefined),
+        (triesSize === 0
+            ? () => []
+            : createQuantifierParser(tryItemParser, triesSize)),
+        (triesSize === 0
+            ? () => new Map()
+            : encodedCatchHandlerListParser),
+    ]), ([instructions, _padding, tryItems, handlers,]) => ({
+        registersSize,
+        insSize,
+        outsSize,
+        triesSize,
+        debugInfoOffset: isoOffsetToDebugInfoItem.wrap(debugInfoOffset),
+        instructions,
+        tryItems,
+        handlers,
+    })))();
+    setParserName(dalvikExecutableCodeItemParser, 'dalvikExecutableCodeItemParser');
+    return dalvikExecutableCodeItemParser;
+};
+const createSkipToThenCodeItemsParser = ({ sizeOffset, createInstructionsParser, }) => createSkipToThenItemByOffsetParser({
+    sizeOffset,
+    itemParser: createDalvikExecutableCodeItemParser({
+        createInstructionsParser,
+    }),
+    byteAlign4: true,
+    isoOffset: isoOffsetToCodeItem,
+    parserName: 'skipToThenCodeItemsParser',
+});
+const dalvikExecutableDebugByteCodeValueParser = parserCreatorCompose(() => ubyteParser, (value) => {
+    switch (value) {
+        case 0x01: {
+            return promiseCompose(uleb128NumberParser, addressDiff => ({ type: 'advancePc', addressDiff }));
+        }
+        case 0x02: {
+            return promiseCompose(sleb128NumberParser, lineDiff => ({ type: 'advanceLine', lineDiff }));
+        }
+        case 0x03: {
+            return promiseCompose(createTupleParser([
+                uleb128NumberParser,
+                uleb128p1NumberParser,
+                uleb128p1NumberParser,
+            ]), ([registerNumber, nameIndex, typeIndex]) => ({
+                type: 'startLocal',
+                registerNum: registerNumber,
+                nameIndex: nameIndex === -1 ? undefined : isoIndexIntoStringIds.wrap(nameIndex),
+                typeIndex: typeIndex === -1 ? undefined : isoIndexIntoTypeIds.wrap(typeIndex),
+            }));
+        }
+        case 0x04: {
+            return promiseCompose(createTupleParser([
+                uleb128NumberParser,
+                uleb128p1NumberParser,
+                uleb128p1NumberParser,
+                uleb128p1NumberParser,
+            ]), ([registerNumber, nameIndex, typeIndex, signatureIndex]) => ({
+                type: 'startLocalExtended',
+                registerNum: registerNumber,
+                nameIndex: nameIndex === -1 ? undefined : isoIndexIntoStringIds.wrap(nameIndex),
+                typeIndex: typeIndex === -1 ? undefined : isoIndexIntoTypeIds.wrap(typeIndex),
+                signatureIndex: signatureIndex === -1 ? undefined : isoIndexIntoStringIds.wrap(signatureIndex),
+            }));
+        }
+        case 0x05: {
+            return promiseCompose(uleb128NumberParser, registerNumber => ({ type: 'endLocal', registerNum: registerNumber }));
+        }
+        case 0x06: {
+            return promiseCompose(uleb128NumberParser, registerNumber => ({ type: 'restartLocal', registerNum: registerNumber }));
+        }
+        case 0x07: {
+            return () => ({ type: 'setPrologueEnd' });
+        }
+        case 0x08: {
+            return () => ({ type: 'setEpilogueBegin' });
+        }
+        case 0x09: {
+            return promiseCompose(uleb128p1NumberParser, nameIndex => ({ type: 'setFile', nameIndex: nameIndex === -1 ? undefined : isoIndexIntoStringIds.wrap(nameIndex) }));
+        }
+        default: {
+            return parserContext => {
+                parserContext.invariant(value >= 0x0A, 'Unexpected special value: %s', value);
+                return { type: 'special', value };
+            };
+        }
+    }
+})();
+setParserName(dalvikExecutableDebugByteCodeValueParser, 'dalvikExecutableDebugByteCodeValueParser');
+const debugByteCodeParser = createElementTerminatedArrayParserUnsafe(dalvikExecutableDebugByteCodeValueParser, 0);
+setParserName(debugByteCodeParser, 'debugByteCodeParser');
+const DEX_DEBUG_INFO_ITEM_PARAMETER_NAME_NO_INDEX = -1;
+const debugInfoItemParser = parserCreatorCompose(() => createTupleParser([
+    uleb128NumberParser,
+    uleb128NumberParser,
+]), ([lineStart, parametersSize,]) => promiseCompose(createTupleParser([
+    createQuantifierParser(uleb128p1NumberParser, parametersSize),
+    debugByteCodeParser,
+]), ([parameterNames, bytecode]) => ({
+    lineStart,
+    parameterNames: parameterNames.map(parameterName => parameterName === DEX_DEBUG_INFO_ITEM_PARAMETER_NAME_NO_INDEX ? undefined : isoIndexIntoStringIds.wrap(parameterName)),
+    bytecode,
+})))();
+setParserName(debugInfoItemParser, 'debugInfoItemParser');
+const createSkipToThenDebugInfoItemsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
+    sizeOffset,
+    itemParser: debugInfoItemParser,
+    byteAlign4: false,
+    isoOffset: isoOffsetToDebugInfoItem,
+    parserName: 'skipToThenDebugInfoItemsParser',
+});
+const dalvikExecutableAnnotationItemVisibilityParser = promiseCompose(ubyteParser, visibility => {
+    switch (visibility) {
+        case 0x00: {
+            return 'build';
+        }
+        case 0x01: {
+            return 'runtime';
+        }
+        case 0x02: {
+            return 'system';
+        }
+        default: {
+            invariant(false, 'Unexpected visibility: %s', visibility);
+        }
+    }
+});
+setParserName(dalvikExecutableAnnotationItemVisibilityParser, 'dalvikExecutableAnnotationItemVisibilityParser');
+const dalvikExecutableAnnotationItemParser = promiseCompose(createTupleParser([
+    dalvikExecutableAnnotationItemVisibilityParser,
+    encodedAnnotationParser,
+]), ([visibility, encodedAnnotation]) => ({ visibility, encodedAnnotation }));
+setParserName(dalvikExecutableAnnotationItemParser, 'dalvikExecutableAnnotationItemParser');
+const createSkipToThenAnnotationItemsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
+    sizeOffset,
+    itemParser: dalvikExecutableAnnotationItemParser,
+    byteAlign4: false,
+    isoOffset: isoOffsetToAnnotationItem,
+    parserName: 'skipToThenAnnotationItemsParser',
+});
+const dalvikExecutableHeaderAndMapParser = parserCreatorCompose(() => dalvikExecutableHeaderItemParser, headerItem => promiseCompose(createLookaheadParser(createDalvikExecutableMapListParser(headerItem.mapOffset)), mapList => ({ headerItem, mapList })))();
+const dalvikExecutableAnnotationOffsetItemParser = promiseCompose(uintParser, annotationOffset => ({
+    annotationOffset: isoOffsetToAnnotationItem.wrap(annotationOffset),
+}));
+const dalvikExecutableAnnotationSetItemParser = parserCreatorCompose(() => createTupleParser([
+    byteAlign4Parser,
+    uintParser,
+]), ([_, size]) => promiseCompose(createQuantifierParser(dalvikExecutableAnnotationOffsetItemParser, size), entries => ({ entries })))();
+const createSkipToThenAnnotationSetItemsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
+    sizeOffset,
+    itemParser: dalvikExecutableAnnotationSetItemParser,
+    byteAlign4: true,
+    isoOffset: isoOffsetToAnnotationSetItem,
+    parserName: 'skipToThenAnnotationSetItemsParser',
+});
+const dalvikExecutableAnnotationSetRefItemParser = promiseCompose(uintParser, annotationsOffset => isoOffsetToAnnotationSetItem.wrap(annotationsOffset));
+const dalvikExecutableAnnotationSetRefListParser = parserCreatorCompose(() => createTupleParser([
+    byteAlign4Parser,
+    uintParser,
+]), ([_, size]) => promiseCompose(createQuantifierParser(dalvikExecutableAnnotationSetRefItemParser, size), list => ({ list })))();
+const createSkipToThenAnnotationSetRefListsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
+    sizeOffset,
+    itemParser: dalvikExecutableAnnotationSetRefListParser,
+    byteAlign4: true,
+    isoOffset: isoOffsetToAnnotationSetRefListItem,
+    parserName: 'skipToThenAnnotationSetRefListsParser',
+});
+const dalvikExecutableMapItemTypeParser = promiseCompose(ushortParser, type => {
+    switch (type) {
+        case 0x00_00: {
+            return 'headerItem';
+        }
+        case 0x00_01: {
+            return 'stringIdItem';
+        }
+        case 0x00_02: {
+            return 'typeIdItem';
+        }
+        case 0x00_03: {
+            return 'prototypeIdItem';
+        }
+        case 0x00_04: {
+            return 'fieldIdItem';
+        }
+        case 0x00_05: {
+            return 'methodIdItem';
+        }
+        case 0x00_06: {
+            return 'classDefinitionItem';
+        }
+        case 0x00_07: {
+            return 'callSiteIdItem';
+        }
+        case 0x00_08: {
+            return 'methodHandleItem';
+        }
+        case 0x10_00: {
+            return 'mapList';
+        }
+        case 0x10_01: {
+            return 'typeList';
+        }
+        case 0x10_02: {
+            return 'annotationSetRefList';
+        }
+        case 0x10_03: {
+            return 'annotationSetItem';
+        }
+        case 0x20_00: {
+            return 'classDataItem';
+        }
+        case 0x20_01: {
+            return 'codeItem';
+        }
+        case 0x20_02: {
+            return 'stringDataItem';
+        }
+        case 0x20_03: {
+            return 'debugInfoItem';
+        }
+        case 0x20_04: {
+            return 'annotationItem';
+        }
+        case 0x20_05: {
+            return 'encodedArrayItem';
+        }
+        case 0x20_06: {
+            return 'annotationsDirectoryItem';
+        }
+        case 0xF0_00: {
+            return 'hiddenApiClassDataItem';
+        }
+        default: {
+            invariant(false, 'Unexpected map item type: %s', type);
+        }
+    }
+});
+const dalvikExecutableMapItemParser = promiseCompose(createTupleParser([
+    dalvikExecutableMapItemTypeParser,
+    ushortParser,
+    uintParser,
+    uintParser,
+]), ([type, _unused, size, offset]) => ({ type, size, offset }));
+const dalvikExecutableMapListParser = parserCreatorCompose(() => uintParser, size => createQuantifierParser(dalvikExecutableMapItemParser, size))();
+setParserName(dalvikExecutableMapListParser, 'dalvikExecutableMapListParser');
+const createDalvikExecutableMapListParser = (mapOffset) => {
+    const dalvikExecutableMapParser = promiseCompose(createTupleParser([
+        createSkipToParser(mapOffset),
+        dalvikExecutableMapListParser,
+    ]), ([_, map]) => map);
+    setParserName(dalvikExecutableMapParser, 'dalvikExecutableMapParser');
+    return dalvikExecutableMapParser;
+};
+const createSkipToThenEncodedArrayItemsParser = (sizeOffset) => createSkipToThenItemByOffsetParser({
+    sizeOffset,
+    itemParser: encodedArrayParser,
+    byteAlign4: false,
+    isoOffset: isoOffsetToEncodedArrayItem,
+    parserName: 'skipToThenEncodedArrayItemsParser',
+});
+const createDalvikExecutableDataParser = ({ headerItem, mapList, createInstructionsParser, }) => {
+    const dalvikExecutableDataParser = async (parserContext) => {
+        let stringIdItems = isoDalvikExecutableStringIdItems.wrap([]);
+        let typeIdItems = isoDalvikExecutableTypeIdItems.wrap([]);
+        let prototypeIdItems = isoDalvikExecutablePrototypeIdItems.wrap([]);
+        let fieldIdItems = isoDalvikExecutableFieldIdItems.wrap([]);
+        let methodIdItems = isoDalvikExecutableMethodIdItems.wrap([]);
+        let classDefinitionItems = [];
+        const callSiteIdItems = [];
+        const methodHandleItems = [];
+        let typeListByOffset = new Map();
+        let annotationSetRefListItemByOffset = new Map();
+        let annotationSetItemByOffset = new Map();
+        let classDataItemByOffset = new Map();
+        let codeItemByOffset = new Map();
+        let stringDataItemStringByOffset = new Map();
+        let debugInfoItemByOffset = new Map();
+        let annotationItemByOffset = new Map();
+        let encodedArrayItemByOffset = new Map();
+        let annotationsDirectoryItemByOffset = new Map();
+        const hiddenApiClassDataItems = [];
+        // Track if link has been parsed
+        let link = undefined;
+        let linkParsed = false;
+        for (const dexMapItem of mapList) {
+            // Parse link data before any map item that comes after it in the file
+            // Link data is not included in the map items, but is referenced in the header
+            if (!linkParsed && headerItem.link.size > 0 && headerItem.link.offset < dexMapItem.offset) {
+                link = await createRawDataParser(headerItem.link)(parserContext);
+                linkParsed = true;
+            }
+            if (dexMapItem.type === 'headerItem') {
+                continue;
+            }
+            if (dexMapItem.type === 'stringIdItem') {
+                stringIdItems = await createSkipToThenStringIdItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'typeIdItem') {
+                typeIdItems = await createSkipToThenTypeIdItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'prototypeIdItem') {
+                prototypeIdItems = await createSkipToThenPrototypeIdItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'fieldIdItem') {
+                fieldIdItems = await createSkipToThenFieldIdItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'methodIdItem') {
+                methodIdItems = await createSkipToThenMethodIdItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'classDefinitionItem') {
+                classDefinitionItems = await createSkipToThenClassDefinitionItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'callSiteIdItem') {
+                // TODO
+            }
+            if (dexMapItem.type === 'methodHandleItem') {
+                // TODO
+            }
+            if (dexMapItem.type === 'mapList') {
+                // Re-parse the map itself to consume it from the input
+                await createDalvikExecutableMapListParser(dexMapItem.offset)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'typeList') {
+                typeListByOffset = await createSkipToThenTypeListByOffsetParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'annotationSetRefList') {
+                annotationSetRefListItemByOffset = await createSkipToThenAnnotationSetRefListsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'annotationSetItem') {
+                annotationSetItemByOffset = await createSkipToThenAnnotationSetItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'classDataItem') {
+                classDataItemByOffset = await createSkipToThenClassDataItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'codeItem') {
+                codeItemByOffset = await createSkipToThenCodeItemsParser({
+                    sizeOffset: dexMapItem,
+                    createInstructionsParser,
+                })(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'stringDataItem') {
+                stringDataItemStringByOffset = await createSkipToThenStringsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'debugInfoItem') {
+                debugInfoItemByOffset = await createSkipToThenDebugInfoItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'annotationItem') {
+                annotationItemByOffset = await createSkipToThenAnnotationItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'encodedArrayItem') {
+                encodedArrayItemByOffset = await createSkipToThenEncodedArrayItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'annotationsDirectoryItem') {
+                annotationsDirectoryItemByOffset = await createSkipToThenAnnotationsDirectoryItemsParser(dexMapItem)(parserContext);
+                continue;
+            }
+            if (dexMapItem.type === 'hiddenApiClassDataItem') {
+                // TODO
+            }
+            invariant(false, 'Unexpected map item type: %s', dexMapItem.type);
+        }
+        // Parse link data after the loop if it hasn't been parsed yet
+        // This handles the case where link comes after all map items
+        if (!linkParsed && headerItem.link.size > 0) {
+            link = await createRawDataParser(headerItem.link)(parserContext);
+        }
+        return {
+            headerItem,
+            stringIdItems,
+            typeIdItems,
+            prototypeIdItems,
+            fieldIdItems,
+            methodIdItems,
+            classDefinitionItems,
+            callSiteIdItems,
+            methodHandleItems,
+            mapList,
+            typeListByOffset,
+            annotationSetRefListItemByOffset,
+            annotationSetItemByOffset,
+            classDataItemByOffset,
+            codeItemByOffset,
+            stringDataItemStringByOffset,
+            debugInfoItemByOffset,
+            annotationItemByOffset,
+            encodedArrayItemByOffset,
+            annotationsDirectoryItemByOffset,
+            hiddenApiClassDataItems,
+            link,
+        };
+    };
+    setParserName(dalvikExecutableDataParser, 'dalvikExecutableDataParser');
+    return dalvikExecutableDataParser;
+};
+const createDalvikExecutableParser = ({ createInstructionsParser, }) => parserCreatorCompose(() => dalvikExecutableHeaderAndMapParser, ({ headerItem, mapList, }) => promiseCompose(createDalvikExecutableDataParser({
+    headerItem,
+    mapList,
+    createInstructionsParser,
+}), async ({ headerItem: _headerItem, stringIdItems, typeIdItems, prototypeIdItems, fieldIdItems, methodIdItems, classDefinitionItems, 
+// CallSiteIdItems,
+// methodHandleItems,
+mapList: _mapList, typeListByOffset, annotationSetRefListItemByOffset, annotationSetItemByOffset, classDataItemByOffset, codeItemByOffset, stringDataItemStringByOffset, debugInfoItemByOffset, annotationItemByOffset, encodedArrayItemByOffset, annotationsDirectoryItemByOffset, 
+// HiddenApiClassDataItems,
+link, }) => {
+    const strings = stringIdItems.map(stringId => {
+        const stringOffset = stringId;
+        const string = stringDataItemStringByOffset.get(stringOffset);
+        invariant(string !== undefined, 'String must be there. String offset: %s', stringOffset);
+        return string;
+    });
+    const types = typeIdItems.map(typeId => {
+        const type = strings.at(typeId);
+        invariant(type, 'Type string must be there. Type id: %s', typeId);
+        return type;
+    });
+    const resolvedTypeListByOffset = new Map([
+        [isoOffsetToTypeList.wrap(0), []],
+    ]);
+    for (const [offset, typeIndexes] of typeListByOffset) {
+        const typeNames = isoDalvikExecutableTypeList.unwrap(typeIndexes).map(typeIndex => {
+            const type = types.at(typeIndex);
+            invariant(type, 'Type must be there. Type id: %s', typeIndex);
+            return type;
+        });
+        resolvedTypeListByOffset.set(offset, typeNames);
+    }
+    const prototypes = prototypeIdItems.map(prototypeId => {
+        const shorty = strings.at(prototypeId.shortyIndex);
+        invariant(shorty, 'Shorty must be there. Shorty id: %s', prototypeId.shortyIndex);
+        const returnType = types.at(prototypeId.returnTypeIndex);
+        invariant(returnType, 'Return type must be there. Return type id: %s', prototypeId.returnTypeIndex);
+        const parameters = resolvedTypeListByOffset.get(prototypeId.parametersOffset);
+        invariant(parameters !== undefined, 'Parameters must be there. Parameters offset: %s', prototypeId.parametersOffset);
+        return { shorty, returnType, parameters };
+    });
+    const fields = fieldIdItems.map(fieldId => {
+        const class_ = types.at(fieldId.classIndex);
+        invariant(class_, 'Class must be there. Class id: %s', fieldId.classIndex);
+        const type = types.at(fieldId.typeIndex);
+        invariant(type, 'Type must be there. Type id: %s', fieldId.typeIndex);
+        const name = strings.at(fieldId.nameIndex);
+        invariant(name, 'Name string must be there. String offset: %s', fieldId.nameIndex);
+        return { class: class_, type, name };
+    });
+    const methods = methodIdItems.map(methodId => {
+        const class_ = types.at(methodId.classIndex);
+        invariant(class_, 'Class must be there. Class id: %s', methodId.classIndex);
+        const prototype = prototypes.at(methodId.prototypeIndex);
+        invariant(prototype, 'Prototype must be there. Prototype id: %s', methodId.prototypeIndex);
+        const name = strings.at(methodId.nameIndex);
+        invariant(name, 'Name string must be there. String offset: %s', methodId.nameIndex);
+        return { class: class_, prototype, name };
+    });
+    const debugInfoByOffset = new Map([
+        [isoOffsetToDebugInfoItem.wrap(0), undefined],
+    ]);
+    for (const [offset, debugInfoItem] of debugInfoItemByOffset) {
+        debugInfoByOffset.set(offset, {
+            lineStart: debugInfoItem.lineStart,
+            parameterNames: debugInfoItem.parameterNames.map(index => {
+                if (index === undefined) {
+                    return undefined;
+                }
+                const string = strings.at(index);
+                invariant(string !== undefined, 'String must be there. String id: %s', index);
+                return string;
+            }),
+            bytecode: debugInfoItem.bytecode.map(value => {
+                switch (value.type) {
+                    case 'startLocal': {
+                        return {
+                            type: 'startLocal',
+                            registerNum: value.registerNum,
+                            name: value.nameIndex === undefined ? undefined : strings.at(value.nameIndex),
+                            type_: value.typeIndex === undefined ? undefined : types.at(value.typeIndex),
+                        };
+                    }
+                    case 'startLocalExtended': {
+                        return {
+                            type: 'startLocalExtended',
+                            registerNum: value.registerNum,
+                            name: value.nameIndex === undefined ? undefined : strings.at(value.nameIndex),
+                            type_: value.typeIndex === undefined ? undefined : types.at(value.typeIndex),
+                            signature: value.signatureIndex === undefined ? undefined : strings.at(value.signatureIndex),
+                        };
+                    }
+                    case 'setFile': {
+                        return { type: 'setFile', name: value.nameIndex === undefined ? undefined : strings.at(value.nameIndex) };
+                    }
+                    default: {
+                        return value;
+                    }
+                }
+            }),
+        });
+    }
+    const codeByOffset = new Map([
+        [isoOffsetToCodeItem.wrap(0), undefined],
+    ]);
+    for (const [offset, codeItem] of codeItemByOffset) {
+        const debugInfo = debugInfoByOffset.get(codeItem.debugInfoOffset);
+        codeByOffset.set(offset, {
+            registersSize: codeItem.registersSize,
+            insSize: codeItem.insSize,
+            outsSize: codeItem.outsSize,
+            debugInfo,
+            instructions: codeItem.instructions,
+            tries: codeItem.tryItems.map(tryItem => {
+                const handler_ = codeItem.handlers.get(tryItem.handlerOffset);
+                invariant(handler_, 'Handler must be there. Handler offset: %s', tryItem.handlerOffset);
+                const handler = {
+                    handlers: handler_.handlers.map(encodedHandler => {
+                        const type = types.at(encodedHandler.typeIndex);
+                        invariant(type, 'Type must be there. Type id: %s', encodedHandler.typeIndex);
+                        return {
+                            type,
+                            address: encodedHandler.address,
+                        };
+                    }),
+                    catchAllAddress: handler_.catchAllAddress,
+                };
+                return {
+                    startAddress: tryItem.startAddress,
+                    instructionCount: tryItem.instructionCount,
+                    handler,
+                };
+            }),
+        });
+    }
+    const classDataByOffset = new Map([
+        [isoOffsetToClassDataItem.wrap(0), undefined],
+    ]);
+    const resolvers = {
+        resolveIndexIntoStringIds(indexIntoStringIds) {
+            const string = strings.at(indexIntoStringIds);
+            invariant(string !== undefined, 'String must be there. String id: %s', indexIntoStringIds);
+            return string;
+        },
+        resolveIndexIntoTypeIds(indexIntoTypeIds) {
+            const type = types.at(indexIntoTypeIds);
+            invariant(type !== undefined, 'Type must be there. Type id: %s', indexIntoTypeIds);
+            return type;
+        },
+        resolveIndexIntoMethodIds(indexIntoMethodIds) {
+            const method = methods.at(indexIntoMethodIds);
+            invariant(method !== undefined, 'Method must be there. Method id: %s', indexIntoMethodIds);
+            return method;
+        },
+        resolveIndexIntoFieldIds(indexIntoFieldIds) {
+            const field = fields.at(indexIntoFieldIds);
+            invariant(field !== undefined, 'Field must be there. Field id: %s', indexIntoFieldIds);
+            return field;
+        },
+    };
+    function resolveCode(code) {
+        if (!code) {
+            return code;
+        }
+        const { instructions, ...rest } = code;
+        if (!Array.isArray(instructions)) {
+            return code;
+        }
+        return {
+            ...rest,
+            instructions: instructions.map((instruction) => resolveDalvikBytecodeOperation(instruction, resolvers)),
+        };
+    }
+    for (const [offset, classDataItem] of classDataItemByOffset) {
+        classDataByOffset.set(offset, {
+            staticFields: classDataItem.staticFields.map(encodedField => {
+                const field = fields.at(encodedField.fieldIndex);
+                invariant(field, 'Field must be there. Field id: %s', encodedField.fieldIndex);
+                return {
+                    field,
+                    accessFlags: encodedField.accessFlags,
+                };
+            }),
+            instanceFields: classDataItem.instanceFields.map(encodedField => {
+                const field = fields.at(encodedField.fieldIndex);
+                invariant(field, 'Field must be there. Field id: %s', encodedField.fieldIndex);
+                return {
+                    field,
+                    accessFlags: encodedField.accessFlags,
+                };
+            }),
+            directMethods: classDataItem.directMethods.map(method => {
+                const method_ = methods.at(method.methodIndex);
+                invariant(method_, 'Method must be there. Method id: %s', method.methodIndex);
+                const code = codeByOffset.get(method.codeOffset);
+                invariant(!method.codeOffset || code, 'Code must be there. Code offset: %s', method.codeOffset);
+                return {
+                    method: method_,
+                    accessFlags: method.accessFlags,
+                    code: resolveCode(code),
+                };
+            }),
+            virtualMethods: classDataItem.virtualMethods.map(method => {
+                const method_ = methods.at(method.methodIndex);
+                invariant(method_, 'Method must be there. Method id: %s', method.methodIndex);
+                const code = codeByOffset.get(method.codeOffset);
+                invariant(!method.codeOffset || code, 'Code must be there. Code offset: %s', method.codeOffset);
+                return {
+                    method: method_,
+                    accessFlags: method.accessFlags,
+                    code: resolveCode(code),
+                };
+            }),
+        });
+    }
+    // Resolve TaggedEncodedValue to DalvikExecutableEncodedValue for static values
+    // Resolves internal index types to actual values while preserving type tags
+    function resolveTaggedEncodedValueForStaticValues(taggedValue) {
+        const { type, value } = taggedValue;
+        // For primitive types, keep the type tag and value
+        if (type === 'byte'
+            || type === 'short'
+            || type === 'char'
+            || type === 'int'
+            || type === 'float'
+            || type === 'double'
+            || type === 'long'
+            || type === 'boolean'
+            || type === 'null'
+            || type === 'methodHandle') {
+            return { type, value };
+        }
+        // For types that reference the pool, resolve the index to the actual value
+        if (type === 'methodType') {
+            const prototype = prototypes.at(value);
+            invariant(prototype, 'Prototype must be there. Prototype id: %s', isoIndexIntoPrototypeIds.unwrap(value));
+            return { type, value: prototype };
+        }
+        if (type === 'string') {
+            const string = strings.at(value);
+            invariant(string !== undefined, 'String must be there. String id: %s', isoIndexIntoStringIds.unwrap(value));
+            return { type, value: string };
+        }
+        if (type === 'type') {
+            const typeString = types.at(value);
+            invariant(typeString !== undefined, 'Type must be there. Type id: %s', isoIndexIntoTypeIds.unwrap(value));
+            return { type, value: typeString };
+        }
+        if (type === 'field' || type === 'enum') {
+            const field = fields.at(value);
+            invariant(field, 'Field must be there. Field id: %s', isoIndexIntoFieldIds.unwrap(value));
+            return { type, value: field };
+        }
+        if (type === 'method') {
+            const method = methods.at(value);
+            invariant(method, 'Method must be there. Method id: %s', isoIndexIntoMethodIds.unwrap(value));
+            return { type, value: method };
+        }
+        if (type === 'array') {
+            return { type, value: value.map(resolveTaggedEncodedValueForStaticValues) };
+        }
+        if (type === 'annotation') {
+            // Resolve the encoded annotation
+            const annotationType = types.at(value.typeIndex);
+            invariant(annotationType, 'Type must be there. Type id: %s', isoIndexIntoTypeIds.unwrap(value.typeIndex));
+            const resolvedElements = value.elements.map(element => {
+                const name = strings.at(element.nameIndex);
+                invariant(name, 'Name string must be there. String offset: %s', element.nameIndex);
+                return {
+                    name,
+                    value: resolveTaggedEncodedValueForAnnotations(element.value),
+                };
+            });
+            const annotation = {
+                visibility: 'build', // Default visibility for embedded annotations
+                type: annotationType,
+                elements: resolvedElements,
+            };
+            return { type, value: annotation };
+        }
+        // This should never happen
+        throw new Error(`Unknown encoded value type: ${type}`);
+    }
+    // Resolve TaggedEncodedValue to DalvikExecutableEncodedValue for annotation elements
+    // Resolves internal index types to actual values while preserving type tags
+    function resolveTaggedEncodedValueForAnnotations(taggedValue) {
+        const { type, value } = taggedValue;
+        // For primitive types, keep the type tag and value
+        if (type === 'byte'
+            || type === 'short'
+            || type === 'char'
+            || type === 'int'
+            || type === 'float'
+            || type === 'double'
+            || type === 'long'
+            || type === 'boolean'
+            || type === 'null'
+            || type === 'methodHandle') {
+            return { type, value };
+        }
+        // For types that reference the pool, resolve the index to the actual value
+        if (type === 'methodType') {
+            const prototype = prototypes.at(value);
+            invariant(prototype, 'Prototype must be there. Prototype id: %s', isoIndexIntoPrototypeIds.unwrap(value));
+            return { type, value: prototype };
+        }
+        if (type === 'string') {
+            const string = strings.at(value);
+            invariant(string !== undefined, 'String must be there. String id: %s', isoIndexIntoStringIds.unwrap(value));
+            return { type, value: string };
+        }
+        if (type === 'type') {
+            const typeString = types.at(value);
+            invariant(typeString !== undefined, 'Type must be there. Type id: %s', isoIndexIntoTypeIds.unwrap(value));
+            return { type, value: typeString };
+        }
+        if (type === 'field' || type === 'enum') {
+            const field = fields.at(value);
+            invariant(field, 'Field must be there. Field id: %s', isoIndexIntoFieldIds.unwrap(value));
+            return { type, value: field };
+        }
+        if (type === 'method') {
+            const method = methods.at(value);
+            invariant(method, 'Method must be there. Method id: %s', isoIndexIntoMethodIds.unwrap(value));
+            return { type, value: method };
+        }
+        // For arrays, recursively resolve elements
+        if (type === 'array') {
+            return { type, value: value.map(resolveTaggedEncodedValueForAnnotations) };
+        }
+        // For annotations
+        if (type === 'annotation') {
+            // Resolve the encoded annotation (subannotation)
+            const annotationType = types.at(value.typeIndex);
+            invariant(annotationType, 'Type must be there. Type id: %s', isoIndexIntoTypeIds.unwrap(value.typeIndex));
+            const resolvedElements = value.elements.map(element => {
+                const name = strings.at(element.nameIndex);
+                invariant(name, 'Name string must be there. String offset: %s', element.nameIndex);
+                return {
+                    name,
+                    value: resolveTaggedEncodedValueForAnnotations(element.value),
+                };
+            });
+            const annotation = {
+                visibility: 'build', // Default visibility for embedded annotations
+                type: annotationType,
+                elements: resolvedElements,
+            };
+            return { type, value: annotation };
+        }
+        // This should never happen
+        throw new Error(`Unknown encoded value type: ${type}`);
+    }
+    function resolveAnnotationOffsetItem({ annotationOffset }) {
+        const annotationItem = annotationItemByOffset.get(annotationOffset);
+        invariant(annotationItem, 'Annotation must be there. Annotation offset: %s', annotationOffset);
+        const type = types.at(annotationItem.encodedAnnotation.typeIndex);
+        invariant(type, 'Type must be there. Type id: %s', annotationItem.encodedAnnotation.typeIndex);
+        const elements = annotationItem.encodedAnnotation.elements.map(element => {
+            const name = strings.at(element.nameIndex);
+            invariant(name, 'Name string must be there. String offset: %s', element.nameIndex);
+            return {
+                name,
+                value: resolveTaggedEncodedValueForAnnotations(element.value),
+            };
+        });
+        return {
+            visibility: annotationItem.visibility,
+            type,
+            elements,
+        };
+    }
+    function resolveAnnotationSetItem(annotationSetItem) {
+        if (!annotationSetItem) {
+            return undefined;
+        }
+        const annotationSet = annotationSetItem.entries.map(resolveAnnotationOffsetItem);
+        if (!annotationSet.length) {
+            return [];
+        }
+        return annotationSet;
+    }
+    const classDefinitions = classDefinitionItems.map(classDefinitionItem => {
+        const class_ = types.at(classDefinitionItem.classIndex);
+        invariant(class_, 'Class must be there. Class id: %s', classDefinitionItem.classIndex);
+        const superclass = types.at(classDefinitionItem.superclassIndex);
+        invariant(superclass, 'Superclass must be there. Superclass id: %s', classDefinitionItem.superclassIndex);
+        const interfaces = resolvedTypeListByOffset.get(classDefinitionItem.interfacesOffset);
+        invariant(interfaces !== undefined, 'Interfaces must be there. Interfaces offset: %s', classDefinitionItem.interfacesOffset);
+        const sourceFile = classDefinitionItem.sourceFileIndex === undefined ? undefined : strings.at(classDefinitionItem.sourceFileIndex);
+        const annotationsDirectoryItem = annotationsDirectoryItemByOffset.get(classDefinitionItem.annotationsOffset);
+        invariant(isoOffsetToAnnotationsDirectoryItem.unwrap(classDefinitionItem.annotationsOffset) === 0 || annotationsDirectoryItem, 'Annotations directory item must be there. Annotations offset: %s', classDefinitionItem.annotationsOffset);
+        const annotations = (() => {
+            if (!annotationsDirectoryItem) {
+                return undefined;
+            }
+            const classAnnotationSetItem = annotationSetItemByOffset.get(annotationsDirectoryItem.classAnnotationsOffset);
+            invariant(isoOffsetToAnnotationSetItem.unwrap(annotationsDirectoryItem.classAnnotationsOffset) === 0 || classAnnotationSetItem, 'Class annotations must be there. Class annotations offset: %s', annotationsDirectoryItem.classAnnotationsOffset);
+            const classAnnotations = (classAnnotationSetItem
+                ? resolveAnnotationSetItem(classAnnotationSetItem)
+                : undefined) ?? [];
+            const fieldAnnotations = annotationsDirectoryItem.fieldAnnotations.flatMap(fieldAnnotation => {
+                const field = fields.at(fieldAnnotation.fieldIndex);
+                invariant(field, 'Field must be there. Field id: %s', fieldAnnotation.fieldIndex);
+                const annotationSetItem = annotationSetItemByOffset.get(fieldAnnotation.annotationsOffset);
+                invariant(isoOffsetToAnnotationSetItem.unwrap(fieldAnnotation.annotationsOffset) === 0 || annotationSetItem, 'Annotations must be there. Annotations offset: %s', fieldAnnotation.annotationsOffset);
+                const annotations = resolveAnnotationSetItem(annotationSetItem);
+                // Skip fields with no annotations (undefined or empty array)
+                if (!annotations || annotations.length === 0) {
+                    return [];
+                }
+                return [{
+                        field,
+                        annotations,
+                    }];
+            });
+            const methodAnnotations = annotationsDirectoryItem.methodAnnotations.flatMap(methodAnnotation => {
+                const method = methods.at(methodAnnotation.methodIndex);
+                invariant(method, 'Method must be there. Method id: %s', methodAnnotation.methodIndex);
+                const annotationSetItem = annotationSetItemByOffset.get(methodAnnotation.annotationsOffset);
+                invariant(isoOffsetToAnnotationSetItem.unwrap(methodAnnotation.annotationsOffset) === 0 || annotationSetItem, 'Annotations must be there. Annotations offset: %s', methodAnnotation.annotationsOffset);
+                const annotations = resolveAnnotationSetItem(annotationSetItem) ?? [];
+                // Skip methods with no annotations
+                if (annotations.length === 0) {
+                    return [];
+                }
+                return [{
+                        method,
+                        annotations,
+                    }];
+            });
+            const parameterAnnotations = annotationsDirectoryItem.parameterAnnotations.flatMap(parameterAnnotation => {
+                const method = methods.at(parameterAnnotation.methodIndex);
+                invariant(method, 'Method must be there. Method id: %s', parameterAnnotation.methodIndex);
+                const annotationSetRefList = annotationSetRefListItemByOffset.get(parameterAnnotation.annotationsOffset);
+                invariant(isoOffsetToAnnotationSetRefListItem.unwrap(parameterAnnotation.annotationsOffset) === 0 || annotationSetRefList, 'Annotations must be there. Annotations offset: %s', parameterAnnotation.annotationsOffset);
+                const annotations = annotationSetRefList?.list.map(annotationSetRefItem => {
+                    const annotationSetItem = annotationSetItemByOffset.get(annotationSetRefItem);
+                    invariant(isoOffsetToAnnotationSetItem.unwrap(annotationSetRefItem) === 0 || annotationSetItem, 'Annotations must be there. Annotations offset: %s', annotationSetRefItem);
+                    const annotationSet = resolveAnnotationSetItem(annotationSetItem);
+                    return annotationSet ?? [];
+                }) ?? [];
+                return { method, annotations };
+            });
+            return {
+                classAnnotations,
+                fieldAnnotations,
+                methodAnnotations,
+                parameterAnnotations,
+            };
+        })();
+        const classData = classDataByOffset.get(classDefinitionItem.classDataOffset);
+        const staticValuesTagged = isoOffsetToEncodedArrayItem.unwrap(classDefinitionItem.staticValuesOffset) === 0 ? [] : encodedArrayItemByOffset.get(classDefinitionItem.staticValuesOffset);
+        invariant(staticValuesTagged, 'Static values must be there. Static values offset: %s', classDefinitionItem.staticValuesOffset);
+        const staticValues = staticValuesTagged.map(resolveTaggedEncodedValueForStaticValues);
+        const allMembers = [
+            ...classData?.staticFields ?? [],
+            ...classData?.instanceFields ?? [],
+            ...classData?.directMethods ?? [],
+            // ...classData?.virtualMethods ?? [], // TODO?
+        ];
+        const allMembersAreSynthetic = (allMembers.every(member => member.accessFlags.synthetic)
+            && allMembers.length > 0);
+        const accessFlags = {
+            ...classDefinitionItem.accessFlags,
+            // Use the synthetic flag from the class definition, or compute it from members if not set
+            synthetic: classDefinitionItem.accessFlags.synthetic || allMembersAreSynthetic,
+        };
+        return {
+            class: class_,
+            accessFlags,
+            superclass,
+            interfaces,
+            sourceFile,
+            annotations,
+            classData,
+            staticValues,
+        };
+    });
+    // Sort parameter annotations in each class by method index in classData
+    for (const classDef of classDefinitions) {
+        if (classDef.annotations?.parameterAnnotations && classDef.classData) {
+            const allMethods = [...(classDef.classData.directMethods ?? []), ...(classDef.classData.virtualMethods ?? [])];
+            classDef.annotations.parameterAnnotations.sort((a, b) => {
+                const indexA = allMethods.findIndex(m => m.method.name === a.method.name &&
+                    m.method.prototype.shorty === a.method.prototype.shorty);
+                const indexB = allMethods.findIndex(m => m.method.name === b.method.name &&
+                    m.method.prototype.shorty === b.method.prototype.shorty);
+                return indexA - indexB;
+            });
+        }
+    }
+    return {
+        classDefinitions,
+        link,
+    };
+}))();
+export const dalvikExecutableParser = createDalvikExecutableParser({
+    createInstructionsParser: createDalvikBytecodeParser,
+});
+setParserName(dalvikExecutableParser, 'dalvikExecutableParser');
+export const dalvikExecutableWithRawInstructionsParser = createDalvikExecutableParser({
+    createInstructionsParser: createFixedLengthSequenceParser,
+});