@futpib/parser 1.0.0 → 1.0.2

package/build/dalvikExecutableParser.js

@@ -0,0 +1,1439 @@
+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 { 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 uintAccessFlagsParser = promiseCompose(uintParser, (flags) => ({
+    public: Boolean(flags & 0b00000001),
+    private: Boolean(flags & 0b00000010),
+    protected: Boolean(flags & 0b00000100),
+    static: Boolean(flags & 0b00001000),
+    final: Boolean(flags & 0b00010000),
+    synchronized: Boolean(flags & 0b00100000),
+    volatile: Boolean(flags & 0b01000000),
+    bridge: Boolean(flags & 0b01000000),
+    transient: Boolean(flags & 0b10000000),
+    varargs: Boolean(flags & 0b10000000),
+    native: false,
+    interface: false,
+    abstract: false,
+    strict: false,
+    synthetic: false,
+    annotation: false,
+    enum: false,
+    constructor: false,
+    declaredSynchronized: false,
+}));
+const uleb128AccessFlagsParser = promiseCompose(uleb128NumberParser, flags => ({
+    public: Boolean(flags & 0b00000001),
+    private: Boolean(flags & 0b00000010),
+    protected: Boolean(flags & 0b00000100),
+    static: Boolean(flags & 0b00001000),
+    final: Boolean(flags & 0b00010000),
+    synchronized: Boolean(flags & 0b00100000),
+    volatile: Boolean(flags & 0b01000000),
+    bridge: Boolean(flags & 0b01000000),
+    transient: Boolean(flags & 0b10000000),
+    varargs: Boolean(flags & 0b10000000),
+    native: Boolean(flags & 0b00000001_00000000),
+    interface: Boolean(flags & 0b00000010_00000000),
+    abstract: Boolean(flags & 0b00000100_00000000),
+    strict: Boolean(flags & 0b00001000_00000000),
+    synthetic: Boolean(flags & 0b00010000_00000000),
+    annotation: Boolean(flags & 0b00100000_00000000),
+    enum: Boolean(flags & 0b01000000_00000000),
+    constructor: Boolean(flags & 0b00000001_00000000_00000000),
+    declaredSynchronized: Boolean(flags & 0b00000010_00000000_00000000),
+}));
+const DEX_CLASS_DEFINITION_ITEM_SOURCE_FILE_NO_INDEX = 0xffffffff;
+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,
+    uleb128AccessFlagsParser,
+]), ([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,
+    uleb128AccessFlagsParser,
+    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 & 0b00011111) === 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),
+    ubyteParser,
+]), ([_, value]) => 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 buffer.readInt8(0);
+        });
+    }
+    invariant(size === 2, '(encodedValueShortParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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([0, ...uint8Array]);
+            return buffer.readUInt16LE(0);
+        });
+    }
+    invariant(size === 2, '(encodedValueCharParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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 buffer.readInt8(0);
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from(uint8Array);
+            return buffer.readInt16LE(0);
+        });
+    }
+    if (size === 3) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const firstByte = uint8Array[0];
+            const firstBit = (firstByte & 0b10000000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xff : 0x00;
+            const buffer = Buffer.from([extensionByte, ...uint8Array]);
+            return buffer.readInt32LE(0);
+        });
+    }
+    invariant(size === 4, '(encodedValueIntParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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 BigInt(buffer.readInt8(0));
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from(uint8Array);
+            return BigInt(buffer.readInt16LE(0));
+        });
+    }
+    if (size === 3) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const firstByte = uint8Array[0];
+            const firstBit = (firstByte & 0b10000000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xff : 0x00;
+            const buffer = Buffer.from([extensionByte, ...uint8Array]);
+            return BigInt(buffer.readInt32LE(0));
+        });
+    }
+    if (size === 4) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from(uint8Array);
+            return BigInt(buffer.readInt32LE(0));
+        });
+    }
+    if (size === 5) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const firstByte = uint8Array[0];
+            const firstBit = (firstByte & 0b10000000) >> 7;
+            const extensionByte = firstBit === 1 ? 0xff : 0x00;
+            const buffer = Buffer.from([extensionByte, extensionByte, extensionByte, ...uint8Array]);
+            return BigInt(buffer.readBigInt64LE(0));
+        });
+    }
+    invariant(size === 8, '(encodedValueLongParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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([...uint8Array, 0, 0, 0]);
+            return buffer.readFloatLE(0);
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from([...uint8Array, 0, 0]);
+            return buffer.readFloatLE(0);
+        });
+    }
+    invariant(size === 4, '(encodedValueFloatParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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([...uint8Array, 0, 0, 0, 0, 0, 0, 0]);
+            return buffer.readDoubleLE(0);
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from([...uint8Array, 0, 0, 0, 0, 0, 0]);
+            return buffer.readDoubleLE(0);
+        });
+    }
+    if (size === 4) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from([...uint8Array, 0, 0, 0, 0]);
+            return buffer.readDoubleLE(0);
+        });
+    }
+    invariant(size === 8, '(encodedValueDoubleParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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 buffer.readUint8(0);
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from(uint8Array);
+            return buffer.readUInt16LE(0);
+        });
+    }
+    invariant(size === 4, '(encodedValueMethodTypeParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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 buffer.readUInt8(0);
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from(uint8Array);
+            return buffer.readUInt16LE(0);
+        });
+    }
+    invariant(size === 4, '(encodedValueMethodHandleParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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 buffer.readUInt8(0);
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from(uint8Array);
+            return buffer.readUInt16LE(0);
+        });
+    }
+    invariant(size === 4, '(encodedValueStringParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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 buffer.readUInt8(0);
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from(uint8Array);
+            return buffer.readUInt16LE(0);
+        });
+    }
+    invariant(size === 4, '(encodedValueTypeParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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 buffer.readUInt8(0);
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from(uint8Array);
+            return buffer.readUInt16LE(0);
+        });
+    }
+    invariant(size === 4, '(encodedValueFieldParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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 buffer.readUInt8(0);
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from(uint8Array);
+            return buffer.readUInt16LE(0);
+        });
+    }
+    invariant(size === 4, '(encodedValueMethodParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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 buffer.readUInt8(0);
+        });
+    }
+    if (size === 2) {
+        return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+            const buffer = Buffer.from(uint8Array);
+            return buffer.readUInt16LE(0);
+        });
+    }
+    invariant(size === 4, '(encodedValueEnumParser) Unexpected size: %s', size);
+    return promiseCompose(createFixedLengthSequenceParser(size), (uint8Array) => {
+        const buffer = Buffer.from(uint8Array);
+        return 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]) => 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]) => annotation);
+setParserName(encodedValueAnnotationParser, 'encodedValueAnnotationParser');
+const encodedValueNullParser = parserCreatorCompose(() => createEncodedValueArgParser(0x1e), valueArg => parserContext => {
+    parserContext.invariant(valueArg === 0, '(encodedValueNullParser) valueArg: %s', valueArg);
+    return null;
+})();
+setParserName(encodedValueNullParser, 'encodedValueNullParser');
+const encodedValueBooleanParser = promiseCompose(createEncodedValueArgParser(0x1f), (value) => Boolean(value));
+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,]) => {
+        return promiseCompose(createTupleParser([
+            createInstructionsParser(instructionsSize * 2),
+            ((triesSize !== 0
+                && instructionsSize % 2 === 1)
+                ? byteAlign4Parser
+                : () => undefined),
+            (triesSize !== 0
+                ? createQuantifierParser(tryItemParser, triesSize)
+                : () => []),
+            (triesSize !== 0
+                ? encodedCatchHandlerListParser
+                : () => new Map()),
+        ]), ([instructions, _padding, tryItems, handlers,]) => {
+            return {
+                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,
+            uleb128NumberParser,
+            uleb128NumberParser,
+        ]), ([registerNum, nameIndex, typeIndex]) => ({
+            type: 'startLocal',
+            registerNum,
+            nameIndex: isoIndexIntoStringIds.wrap(nameIndex),
+            typeIndex: isoIndexIntoTypeIds.wrap(typeIndex),
+        }));
+        case 0x04: return promiseCompose(createTupleParser([
+            uleb128NumberParser,
+            uleb128NumberParser,
+            uleb128NumberParser,
+            uleb128NumberParser,
+        ]), ([registerNum, nameIndex, typeIndex, signatureIndex]) => ({
+            type: 'startLocalExtended',
+            registerNum,
+            nameIndex: isoIndexIntoStringIds.wrap(nameIndex),
+            typeIndex: isoIndexIntoTypeIds.wrap(typeIndex),
+            signatureIndex: isoIndexIntoStringIds.wrap(signatureIndex),
+        }));
+        case 0x05: return promiseCompose(uleb128NumberParser, (registerNum) => ({ type: 'endLocal', registerNum }));
+        case 0x06: return promiseCompose(uleb128NumberParser, (registerNum) => ({ type: 'restartLocal', registerNum }));
+        case 0x07: return () => ({ type: 'setPrologueEnd' });
+        case 0x08: return () => ({ type: 'setEpilogueBegin' });
+        case 0x09: return promiseCompose(uleb128NumberParser, (nameIndex) => ({ type: 'setFile', nameIndex: 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 0x0000: return 'headerItem';
+        case 0x0001: return 'stringIdItem';
+        case 0x0002: return 'typeIdItem';
+        case 0x0003: return 'prototypeIdItem';
+        case 0x0004: return 'fieldIdItem';
+        case 0x0005: return 'methodIdItem';
+        case 0x0006: return 'classDefinitionItem';
+        case 0x0007: return 'callSiteIdItem';
+        case 0x0008: return 'methodHandleItem';
+        case 0x1000: return 'mapList';
+        case 0x1001: return 'typeList';
+        case 0x1002: return 'annotationSetRefList';
+        case 0x1003: return 'annotationSetItem';
+        case 0x2000: return 'classDataItem';
+        case 0x2001: return 'codeItem';
+        case 0x2002: return 'stringDataItem';
+        case 0x2003: return 'debugInfoItem';
+        case 0x2004: return 'annotationItem';
+        case 0x2005: return 'encodedArrayItem';
+        case 0x2006: return 'annotationsDirectoryItem';
+        case 0xF000: 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 => {
+    return 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 = [];
+        let callSiteIdItems = [];
+        let 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();
+        let hiddenApiClassDataItems = [];
+        for (const dexMapItem of mapList) {
+            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') {
+                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);
+        }
+        return {
+            headerItem,
+            stringIdItems,
+            typeIdItems,
+            prototypeIdItems,
+            fieldIdItems,
+            methodIdItems,
+            classDefinitionItems,
+            callSiteIdItems,
+            methodHandleItems,
+            mapList,
+            typeListByOffset,
+            annotationSetRefListItemByOffset,
+            annotationSetItemByOffset,
+            classDataItemByOffset,
+            codeItemByOffset,
+            stringDataItemStringByOffset,
+            debugInfoItemByOffset,
+            annotationItemByOffset,
+            encodedArrayItemByOffset,
+            annotationsDirectoryItemByOffset,
+            hiddenApiClassDataItems,
+        };
+    };
+    setParserName(dalvikExecutableDataParser, 'dalvikExecutableDataParser');
+    return dalvikExecutableDataParser;
+};
+const createDalvikExecutableParser = ({ createInstructionsParser, }) => parserCreatorCompose(() => dalvikExecutableHeaderAndMapParser, ({ headerItem, mapList, }) => promiseCompose(createTupleParser([
+    createDalvikExecutableDataParser({
+        headerItem,
+        mapList,
+        createInstructionsParser,
+    }),
+    createRawDataParser(headerItem.link),
+]), 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: 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: 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 = {
+                    ...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,
+                        };
+                    }),
+                };
+                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, 'String must be there. String id: %s', indexIntoStringIds);
+            return string;
+        },
+        resolveIndexIntoTypeIds(indexIntoTypeIds) {
+            const type = types.at(indexIntoTypeIds);
+            invariant(type, 'Type must be there. Type id: %s', indexIntoTypeIds);
+            return type;
+        },
+        resolveIndexIntoMethodIds(indexIntoMethodIds) {
+            const method = methods.at(indexIntoMethodIds);
+            invariant(method, 'Method must be there. Method id: %s', indexIntoMethodIds);
+            return method;
+        },
+        resolveIndexIntoFieldIds(indexIntoFieldIds) {
+            const field = fields.at(indexIntoFieldIds);
+            invariant(field, '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) => {
+                return 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),
+                };
+            }),
+        });
+    }
+    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: element.value,
+            };
+        });
+        return {
+            visibility: annotationItem.visibility,
+            type,
+            elements,
+        };
+    }
+    function resolveAnnotationSetItem(annotationSetItem) {
+        return annotationSetItem?.entries.map(resolveAnnotationOffsetItem);
+    }
+    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.map((fieldAnnotation) => {
+                const field = fields.at(fieldAnnotation.fieldIndex);
+                invariant(field, 'Field must be there. Field id: %s', fieldAnnotation.fieldIndex);
+                const annotations = annotationSetItemByOffset.get(fieldAnnotation.annotationsOffset);
+                invariant(isoOffsetToAnnotationSetItem.unwrap(fieldAnnotation.annotationsOffset) === 0 || annotations, 'Annotations must be there. Annotations offset: %s', fieldAnnotation.annotationsOffset);
+                return { field, annotations: annotations?.entries.map(resolveAnnotationOffsetItem) };
+            });
+            const methodAnnotations = annotationsDirectoryItem.methodAnnotations.map((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);
+                return { method, annotations: resolveAnnotationSetItem(annotationSetItem) };
+            });
+            const parameterAnnotations = annotationsDirectoryItem.parameterAnnotations.map((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);
+                    return resolveAnnotationSetItem(annotationSetItem);
+                });
+                return { method, annotations };
+            });
+            return {
+                classAnnotations,
+                fieldAnnotations,
+                methodAnnotations,
+                parameterAnnotations,
+            };
+        })();
+        const classData = classDataByOffset.get(classDefinitionItem.classDataOffset);
+        const staticValues = isoOffsetToEncodedArrayItem.unwrap(classDefinitionItem.staticValuesOffset) === 0 ? [] : encodedArrayItemByOffset.get(classDefinitionItem.staticValuesOffset);
+        invariant(staticValues, 'Static values must be there. Static values offset: %s', classDefinitionItem.staticValuesOffset);
+        return {
+            class: class_,
+            accessFlags: classDefinitionItem.accessFlags,
+            superclass,
+            interfaces,
+            sourceFile,
+            annotations,
+            classData,
+            staticValues,
+        };
+    });
+    return {
+        classDefinitions,
+        link,
+    };
+}))();
+export const dalvikExecutableParser = createDalvikExecutableParser({
+    createInstructionsParser: createDalvikBytecodeParser,
+});
+setParserName(dalvikExecutableParser, 'dalvikExecutableParser');
+export const dalvikExecutableWithRawInstructionsParser = createDalvikExecutableParser({
+    createInstructionsParser: createFixedLengthSequenceParser,
+});