@futpib/parser 1.0.4 → 1.0.6

package/build/dalvikBytecodeParser/addressConversion.d.ts

@@ -0,0 +1,110 @@
+import { type RawDalvikBytecodeOperation, type IndexResolvedOperation } from '../dalvikBytecodeParser.js';
+import { type CodeUnit, type InstructionIndex } from '../dalvikExecutableParser/typedNumbers.js';
+/**
+ * Map from code unit offset to instruction index.
+ * Keys are raw code unit offsets, values are instruction indices.
+ */
+export type CodeUnitToIndexMap = Map<CodeUnit, InstructionIndex>;
+/**
+ * Map from instruction index to code unit offset.
+ * Keys are instruction indices, values are raw code unit offsets.
+ */
+export type IndexToCodeUnitMap = Map<InstructionIndex, CodeUnit>;
+/**
+ * Calculate the size of an operation in code units (16-bit words).
+ * Works with any tier of operation (Tier 1, 2, 3, or SmaliCodeOperation).
+ */
+export declare function getOperationSizeInCodeUnits(operation: {
+    operation: string;
+    data?: Uint8Array | number[];
+}): number;
+/**
+ * Build mapping from code unit offset to instruction index.
+ * Also maps the end position (total code units) to instructions.length.
+ */
+export declare function buildCodeUnitToIndexMap(instructions: RawDalvikBytecodeOperation[]): CodeUnitToIndexMap;
+/**
+ * Build mapping from instruction index to code unit offset.
+ * Also maps instructions.length to the total code units.
+ */
+export declare function buildIndexToCodeUnitMap(instructions: RawDalvikBytecodeOperation[]): IndexToCodeUnitMap;
+/**
+ * Convert a code unit offset to an instruction index.
+ */
+export declare function codeUnitToInstructionIndex(codeUnitOffset: CodeUnit, codeUnitToIndexMap: CodeUnitToIndexMap): InstructionIndex;
+/**
+ * Convert an instruction index to a code unit offset.
+ */
+export declare function instructionIndexToCodeUnit(instructionIndex: InstructionIndex, indexToCodeUnitMap: IndexToCodeUnitMap): CodeUnit;
+/**
+ * Convert a relative branch offset (in code units) to a relative instruction offset.
+ * The offset is relative to the source instruction.
+ */
+export declare function convertBranchOffsetToInstructionOffset(branchOffsetInCodeUnits: CodeUnit, sourceInstructionIndex: InstructionIndex, indexToCodeUnitMap: IndexToCodeUnitMap, codeUnitToIndexMap: CodeUnitToIndexMap): InstructionIndex;
+/**
+ * Convert a relative instruction offset back to a code unit offset.
+ * The offset is relative to the source instruction.
+ */
+export declare function convertInstructionOffsetToBranchOffset(instructionOffset: InstructionIndex, sourceInstructionIndex: InstructionIndex, indexToCodeUnitMap: IndexToCodeUnitMap): CodeUnit;
+/**
+ * Find the switch instruction that references a payload at the given index.
+ * Returns the index of the switch instruction.
+ */
+export declare function findSwitchInstructionForPayload(instructions: RawDalvikBytecodeOperation[], payloadIndex: InstructionIndex, indexToCodeUnitMap: IndexToCodeUnitMap): InstructionIndex;
+export type ConvertedBranchOffsetOperation<T> = T extends {
+    branchOffsetCodeUnit: CodeUnit;
+} ? Omit<T, 'branchOffsetCodeUnit'> & {
+    branchOffsetIndex: InstructionIndex;
+} : T extends {
+    branchOffsetsCodeUnit: CodeUnit[];
+} ? Omit<T, 'branchOffsetsCodeUnit'> & {
+    branchOffsetsIndex: InstructionIndex[];
+} : T;
+export type ConvertedRawDalvikBytecodeOperation = ConvertedBranchOffsetOperation<RawDalvikBytecodeOperation>;
+export type ResolvedBranchOffsetOperation<T> = T extends {
+    branchOffsetIndex: InstructionIndex;
+} ? Omit<T, 'branchOffsetIndex'> & {
+    targetInstructionIndex: number;
+} : T extends {
+    branchOffsetsIndex: InstructionIndex[];
+} ? Omit<T, 'branchOffsetsIndex'> & {
+    targetInstructionIndices: number[];
+} : T;
+export type DalvikBytecodeOperation = IndexResolvedOperation<ResolvedBranchOffsetOperation<ConvertedRawDalvikBytecodeOperation>>;
+export type DalvikBytecode = DalvikBytecodeOperation[];
+/**
+ * Convert all branch offsets in instructions from code units to instruction offsets.
+ * Tier 1 (CodeUnit) -> Tier 2 (InstructionIndex)
+ */
+export declare function convertBranchOffsetsToInstructionOffsets(instructions: RawDalvikBytecodeOperation[]): ConvertedRawDalvikBytecodeOperation[];
+/**
+ * Unwrap instruction indices to plain numbers and convert relative to absolute.
+ * Tier 2 (InstructionIndex, relative) -> Tier 3 (plain number, absolute)
+ */
+export declare function unwrapBranchOffsets(instructions: ConvertedRawDalvikBytecodeOperation[]): DalvikBytecodeOperation[];
+/**
+ * Wrap plain numbers to instruction indices and convert absolute to relative.
+ * Tier 3 (plain number, absolute) -> Tier 2 (InstructionIndex, relative)
+ */
+export declare function wrapBranchOffsets(instructions: DalvikBytecodeOperation[]): ConvertedRawDalvikBytecodeOperation[];
+/**
+ * Build mapping from instruction index to code unit offset.
+ * Works with any tier of operations.
+ */
+export declare function buildIndexToCodeUnitMapGeneric(instructions: Array<{
+    operation: string;
+    data?: Uint8Array | number[];
+}>): IndexToCodeUnitMap;
+/**
+ * Build mapping from instruction index to code unit offset for Tier 2 operations.
+ */
+export declare function buildIndexToCodeUnitMapFromConverted(instructions: ConvertedRawDalvikBytecodeOperation[]): IndexToCodeUnitMap;
+/**
+ * Build mapping from instruction index to code unit offset for Tier 3 operations.
+ */
+export declare function buildIndexToCodeUnitMapFromResolved(instructions: DalvikBytecodeOperation[]): IndexToCodeUnitMap;
+/**
+ * Convert all branch offsets in instructions from instruction offsets back to code units.
+ * Tier 2 (InstructionIndex) -> Tier 1 (CodeUnit)
+ */
+export declare function convertInstructionOffsetsToBranchOffsets(instructions: ConvertedRawDalvikBytecodeOperation[]): RawDalvikBytecodeOperation[];

package/build/dalvikBytecodeParser/addressConversion.js

@@ -0,0 +1,334 @@
+import { isoCodeUnit, isoInstructionIndex, } from '../dalvikExecutableParser/typedNumbers.js';
+import { operationFormats } from './operationFormats.js';
+import { formatSizes } from './formatSizes.js';
+/**
+ * Get the branch offsets array length from an operation, regardless of tier.
+ * Works with all field name variants: branchOffsetsCodeUnit, branchOffsetsIndex, targetInstructionIndices, branchOffsetIndices.
+ */
+function getBranchOffsetsLength(operation) {
+    const op = operation;
+    return op.branchOffsetsCodeUnit?.length
+        ?? op.branchOffsetsIndex?.length
+        ?? op.targetInstructionIndices?.length
+        ?? op.branchOffsetIndices?.length;
+}
+/**
+ * Calculate the size of an operation in code units (16-bit words).
+ * Works with any tier of operation (Tier 1, 2, 3, or SmaliCodeOperation).
+ */
+export function getOperationSizeInCodeUnits(operation) {
+    if (operation.operation === 'packed-switch-payload') {
+        const length = getBranchOffsetsLength(operation);
+        if (length === undefined) {
+            throw new Error('packed-switch-payload missing branch offsets array');
+        }
+        // Header (4 code units) + targets (2 code units each)
+        return (length * 2) + 4;
+    }
+    if (operation.operation === 'sparse-switch-payload') {
+        const length = getBranchOffsetsLength(operation);
+        if (length === undefined) {
+            throw new Error('sparse-switch-payload missing branch offsets array');
+        }
+        // Header (2 code units) + keys (2 code units each) + targets (2 code units each)
+        return (length * 4) + 2;
+    }
+    if (operation.operation === 'fill-array-data-payload') {
+        // data.length is already the total number of bytes (size * elementWidth)
+        const dataSize = operation.data.length;
+        const paddingSize = dataSize % 2;
+        const totalBytes = 8 + dataSize + paddingSize; // header (8 bytes) + data + padding
+        return totalBytes / 2; // Convert to code units
+    }
+    const format = operationFormats[operation.operation];
+    if (!format) {
+        throw new Error(`Unknown operation format: ${operation.operation}`);
+    }
+    return formatSizes[format];
+}
+/**
+ * Build mapping from code unit offset to instruction index.
+ * Also maps the end position (total code units) to instructions.length.
+ */
+export function buildCodeUnitToIndexMap(instructions) {
+    const map = new Map();
+    let codeUnitOffset = 0;
+    for (let index = 0; index < instructions.length; index++) {
+        map.set(isoCodeUnit.wrap(codeUnitOffset), isoInstructionIndex.wrap(index));
+        codeUnitOffset += getOperationSizeInCodeUnits(instructions[index]);
+    }
+    // Map the end position
+    map.set(isoCodeUnit.wrap(codeUnitOffset), isoInstructionIndex.wrap(instructions.length));
+    return map;
+}
+/**
+ * Build mapping from instruction index to code unit offset.
+ * Also maps instructions.length to the total code units.
+ */
+export function buildIndexToCodeUnitMap(instructions) {
+    const map = new Map();
+    let codeUnitOffset = 0;
+    for (let index = 0; index < instructions.length; index++) {
+        map.set(isoInstructionIndex.wrap(index), isoCodeUnit.wrap(codeUnitOffset));
+        codeUnitOffset += getOperationSizeInCodeUnits(instructions[index]);
+    }
+    // Map the end position
+    map.set(isoInstructionIndex.wrap(instructions.length), isoCodeUnit.wrap(codeUnitOffset));
+    return map;
+}
+/**
+ * Convert a code unit offset to an instruction index.
+ */
+export function codeUnitToInstructionIndex(codeUnitOffset, codeUnitToIndexMap) {
+    const index = codeUnitToIndexMap.get(codeUnitOffset);
+    if (index === undefined) {
+        throw new Error(`Invalid code unit offset: ${isoCodeUnit.unwrap(codeUnitOffset)}. Valid offsets: ${[...codeUnitToIndexMap.keys()].map(k => isoCodeUnit.unwrap(k)).join(', ')}`);
+    }
+    return index;
+}
+/**
+ * Convert an instruction index to a code unit offset.
+ */
+export function instructionIndexToCodeUnit(instructionIndex, indexToCodeUnitMap) {
+    const offset = indexToCodeUnitMap.get(instructionIndex);
+    if (offset === undefined) {
+        throw new Error(`Invalid instruction index: ${isoInstructionIndex.unwrap(instructionIndex)}. Valid indices: ${[...indexToCodeUnitMap.keys()].map(k => isoInstructionIndex.unwrap(k)).join(', ')}`);
+    }
+    return offset;
+}
+/**
+ * Convert a relative branch offset (in code units) to a relative instruction offset.
+ * The offset is relative to the source instruction.
+ */
+export function convertBranchOffsetToInstructionOffset(branchOffsetInCodeUnits, sourceInstructionIndex, indexToCodeUnitMap, codeUnitToIndexMap) {
+    const sourceCodeUnit = indexToCodeUnitMap.get(sourceInstructionIndex);
+    if (sourceCodeUnit === undefined) {
+        throw new Error(`Invalid source instruction index: ${isoInstructionIndex.unwrap(sourceInstructionIndex)}`);
+    }
+    const targetCodeUnit = isoCodeUnit.wrap(isoCodeUnit.unwrap(sourceCodeUnit) + isoCodeUnit.unwrap(branchOffsetInCodeUnits));
+    const targetIndex = codeUnitToIndexMap.get(targetCodeUnit);
+    if (targetIndex === undefined) {
+        throw new Error(`Invalid branch target code unit: ${isoCodeUnit.unwrap(targetCodeUnit)} (from source ${isoCodeUnit.unwrap(sourceCodeUnit)} + offset ${isoCodeUnit.unwrap(branchOffsetInCodeUnits)})`);
+    }
+    return isoInstructionIndex.wrap(isoInstructionIndex.unwrap(targetIndex) - isoInstructionIndex.unwrap(sourceInstructionIndex));
+}
+/**
+ * Convert a relative instruction offset back to a code unit offset.
+ * The offset is relative to the source instruction.
+ */
+export function convertInstructionOffsetToBranchOffset(instructionOffset, sourceInstructionIndex, indexToCodeUnitMap) {
+    const sourceCodeUnit = indexToCodeUnitMap.get(sourceInstructionIndex);
+    if (sourceCodeUnit === undefined) {
+        throw new Error(`Invalid source instruction index: ${isoInstructionIndex.unwrap(sourceInstructionIndex)}`);
+    }
+    const targetInstructionIndex = isoInstructionIndex.wrap(isoInstructionIndex.unwrap(sourceInstructionIndex) + isoInstructionIndex.unwrap(instructionOffset));
+    const targetCodeUnit = indexToCodeUnitMap.get(targetInstructionIndex);
+    if (targetCodeUnit === undefined) {
+        throw new Error(`Invalid target instruction index: ${isoInstructionIndex.unwrap(targetInstructionIndex)}`);
+    }
+    return isoCodeUnit.wrap(isoCodeUnit.unwrap(targetCodeUnit) - isoCodeUnit.unwrap(sourceCodeUnit));
+}
+/**
+ * Find the switch instruction that references a payload at the given index.
+ * Returns the index of the switch instruction.
+ */
+export function findSwitchInstructionForPayload(instructions, payloadIndex, indexToCodeUnitMap) {
+    const payloadCodeUnit = indexToCodeUnitMap.get(payloadIndex);
+    if (payloadCodeUnit === undefined) {
+        throw new Error(`Invalid payload index: ${isoInstructionIndex.unwrap(payloadIndex)}`);
+    }
+    for (let i = 0; i < instructions.length; i++) {
+        const inst = instructions[i];
+        if ((inst.operation === 'packed-switch' || inst.operation === 'sparse-switch')
+            && 'branchOffsetCodeUnit' in inst) {
+            const sourceCodeUnit = indexToCodeUnitMap.get(isoInstructionIndex.wrap(i));
+            if (sourceCodeUnit !== undefined && isoCodeUnit.unwrap(sourceCodeUnit) + isoCodeUnit.unwrap(inst.branchOffsetCodeUnit) === isoCodeUnit.unwrap(payloadCodeUnit)) {
+                return isoInstructionIndex.wrap(i);
+            }
+        }
+    }
+    throw new Error(`No switch instruction found for payload at index ${isoInstructionIndex.unwrap(payloadIndex)}`);
+}
+/**
+ * Convert all branch offsets in instructions from code units to instruction offsets.
+ * Tier 1 (CodeUnit) -> Tier 2 (InstructionIndex)
+ */
+export function convertBranchOffsetsToInstructionOffsets(instructions) {
+    const codeUnitToIndexMap = buildCodeUnitToIndexMap(instructions);
+    const indexToCodeUnitMap = buildIndexToCodeUnitMap(instructions);
+    return instructions.map((instruction, index) => {
+        // Handle single branchOffsetCodeUnit (goto, if-*, packed-switch, sparse-switch, fill-array-data)
+        if ('branchOffsetCodeUnit' in instruction) {
+            const { branchOffsetCodeUnit, ...rest } = instruction;
+            return {
+                ...rest,
+                branchOffsetIndex: convertBranchOffsetToInstructionOffset(branchOffsetCodeUnit, isoInstructionIndex.wrap(index), indexToCodeUnitMap, codeUnitToIndexMap),
+            };
+        }
+        // Handle branchOffsetsCodeUnit array (packed-switch-payload, sparse-switch-payload)
+        if ('branchOffsetsCodeUnit' in instruction) {
+            const { branchOffsetsCodeUnit, ...rest } = instruction;
+            // For payload instructions, find the referring switch instruction
+            const sourceIndex = findSwitchInstructionForPayload(instructions, isoInstructionIndex.wrap(index), indexToCodeUnitMap);
+            return {
+                ...rest,
+                branchOffsetsIndex: branchOffsetsCodeUnit.map(offset => convertBranchOffsetToInstructionOffset(offset, sourceIndex, indexToCodeUnitMap, codeUnitToIndexMap)),
+            };
+        }
+        return instruction;
+    });
+}
+/**
+ * Unwrap instruction indices to plain numbers and convert relative to absolute.
+ * Tier 2 (InstructionIndex, relative) -> Tier 3 (plain number, absolute)
+ */
+export function unwrapBranchOffsets(instructions) {
+    // First pass: find switch instruction indices for payloads
+    const payloadToSwitchIndex = new Map();
+    for (let i = 0; i < instructions.length; i++) {
+        const inst = instructions[i];
+        if ((inst.operation === 'packed-switch' || inst.operation === 'sparse-switch')
+            && 'branchOffsetIndex' in inst) {
+            const payloadIndex = i + isoInstructionIndex.unwrap(inst.branchOffsetIndex);
+            payloadToSwitchIndex.set(payloadIndex, i);
+        }
+    }
+    return instructions.map((instruction, index) => {
+        if ('branchOffsetIndex' in instruction) {
+            const { branchOffsetIndex, ...rest } = instruction;
+            // Convert relative offset to absolute index
+            const targetInstructionIndex = index + isoInstructionIndex.unwrap(branchOffsetIndex);
+            return {
+                ...rest,
+                targetInstructionIndex,
+            };
+        }
+        if ('branchOffsetsIndex' in instruction) {
+            const { branchOffsetsIndex, ...rest } = instruction;
+            // For payloads, the offsets are relative to the switch instruction, not the payload
+            const switchIndex = payloadToSwitchIndex.get(index);
+            if (switchIndex === undefined) {
+                throw new Error(`No switch instruction found for payload at index ${index}`);
+            }
+            // Convert relative offsets to absolute indices
+            const targetInstructionIndices = branchOffsetsIndex.map(offset => switchIndex + isoInstructionIndex.unwrap(offset));
+            return {
+                ...rest,
+                targetInstructionIndices,
+            };
+        }
+        return instruction;
+    });
+}
+/**
+ * Wrap plain numbers to instruction indices and convert absolute to relative.
+ * Tier 3 (plain number, absolute) -> Tier 2 (InstructionIndex, relative)
+ */
+export function wrapBranchOffsets(instructions) {
+    // First pass: find switch instruction indices for payloads
+    const payloadToSwitchIndex = new Map();
+    for (let i = 0; i < instructions.length; i++) {
+        const inst = instructions[i];
+        if ((inst.operation === 'packed-switch' || inst.operation === 'sparse-switch')
+            && 'targetInstructionIndex' in inst) {
+            const payloadIndex = inst.targetInstructionIndex;
+            payloadToSwitchIndex.set(payloadIndex, i);
+        }
+    }
+    return instructions.map((instruction, index) => {
+        if ('targetInstructionIndex' in instruction) {
+            const { targetInstructionIndex, ...rest } = instruction;
+            // Convert absolute index to relative offset
+            const branchOffsetIndex = isoInstructionIndex.wrap(targetInstructionIndex - index);
+            return {
+                ...rest,
+                branchOffsetIndex,
+            };
+        }
+        if ('targetInstructionIndices' in instruction) {
+            const { targetInstructionIndices, ...rest } = instruction;
+            // For payloads, the offsets are relative to the switch instruction, not the payload
+            const switchIndex = payloadToSwitchIndex.get(index);
+            if (switchIndex === undefined) {
+                throw new Error(`No switch instruction found for payload at index ${index}`);
+            }
+            // Convert absolute indices to relative offsets from switch instruction
+            const branchOffsetsIndex = targetInstructionIndices.map(target => isoInstructionIndex.wrap(target - switchIndex));
+            return {
+                ...rest,
+                branchOffsetsIndex,
+            };
+        }
+        return instruction;
+    });
+}
+/**
+ * Build mapping from instruction index to code unit offset.
+ * Works with any tier of operations.
+ */
+export function buildIndexToCodeUnitMapGeneric(instructions) {
+    const map = new Map();
+    let codeUnitOffset = 0;
+    for (let index = 0; index < instructions.length; index++) {
+        map.set(isoInstructionIndex.wrap(index), isoCodeUnit.wrap(codeUnitOffset));
+        codeUnitOffset += getOperationSizeInCodeUnits(instructions[index]);
+    }
+    // Map the end position
+    map.set(isoInstructionIndex.wrap(instructions.length), isoCodeUnit.wrap(codeUnitOffset));
+    return map;
+}
+/**
+ * Build mapping from instruction index to code unit offset for Tier 2 operations.
+ */
+export function buildIndexToCodeUnitMapFromConverted(instructions) {
+    return buildIndexToCodeUnitMapGeneric(instructions);
+}
+/**
+ * Build mapping from instruction index to code unit offset for Tier 3 operations.
+ */
+export function buildIndexToCodeUnitMapFromResolved(instructions) {
+    return buildIndexToCodeUnitMapGeneric(instructions);
+}
+/**
+ * Find the switch instruction that references a payload at the given index,
+ * when branch offsets are in instruction indices (Tier 2).
+ */
+function findSwitchInstructionForPayloadByInstructionIndex(instructions, payloadIndex) {
+    for (let i = 0; i < instructions.length; i++) {
+        const inst = instructions[i];
+        if ((inst.operation === 'packed-switch' || inst.operation === 'sparse-switch')
+            && 'branchOffsetIndex' in inst
+            && i + isoInstructionIndex.unwrap(inst.branchOffsetIndex) === isoInstructionIndex.unwrap(payloadIndex)) {
+            return isoInstructionIndex.wrap(i);
+        }
+    }
+    throw new Error(`No switch instruction found for payload at index ${isoInstructionIndex.unwrap(payloadIndex)}`);
+}
+/**
+ * Convert all branch offsets in instructions from instruction offsets back to code units.
+ * Tier 2 (InstructionIndex) -> Tier 1 (CodeUnit)
+ */
+export function convertInstructionOffsetsToBranchOffsets(instructions) {
+    const indexToCodeUnitMap = buildIndexToCodeUnitMapFromConverted(instructions);
+    return instructions.map((instruction, index) => {
+        // Handle single branchOffsetIndex
+        if ('branchOffsetIndex' in instruction) {
+            const { branchOffsetIndex, ...rest } = instruction;
+            return {
+                ...rest,
+                branchOffsetCodeUnit: convertInstructionOffsetToBranchOffset(branchOffsetIndex, isoInstructionIndex.wrap(index), indexToCodeUnitMap),
+            };
+        }
+        // Handle branchOffsetsIndex array
+        if ('branchOffsetsIndex' in instruction) {
+            const { branchOffsetsIndex, ...rest } = instruction;
+            // For payload instructions, find the referring switch instruction
+            const sourceIndex = findSwitchInstructionForPayloadByInstructionIndex(instructions, isoInstructionIndex.wrap(index));
+            return {
+                ...rest,
+                branchOffsetsCodeUnit: branchOffsetsIndex.map(offset => convertInstructionOffsetToBranchOffset(offset, sourceIndex, indexToCodeUnitMap)),
+            };
+        }
+        return instruction;
+    });
+}

package/build/dalvikBytecodeParser/formatParsers.d.ts

@@ -1,8 +1,9 @@
 import { type Iso } from 'monocle-ts';
+import { type CodeUnit } from '../dalvikExecutableParser/typedNumbers.js';
 import { type Parser } from '../parser.js';
 export declare const nibblesParser: Parser<[number, number], Uint8Array>;
 type DalvikBytecodeFormat10t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 };
 export declare const dalvikBytecodeFormat10tParser: Parser<DalvikBytecodeFormat10t, Uint8Array>;
 type DalvikBytecodeFormat10x = void;
@@ -21,7 +22,7 @@ type DalvikBytecodeFormat12x = {
 };
 export declare const dalvikBytecodeFormat12xParser: Parser<DalvikBytecodeFormat12x, Uint8Array>;
 type DalvikBytecodeFormat20t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 };
 export declare const dalvikBytecodeFormat20tParser: Parser<DalvikBytecodeFormat20t, Uint8Array>;
 type DalvikBytecodeFormat21c<Index> = {
@@ -37,7 +38,7 @@ type DalvikBytecodeFormat21h = {
 };
 export declare const dalvikBytecodeFormat21hParser: Parser<DalvikBytecodeFormat21h, Uint8Array>;
 type DalvikBytecodeFormat21t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
     registers: number[];
 };
 export declare const createDalvikBytecodeFormat21tParser: () => Parser<DalvikBytecodeFormat21t, Uint8Array>;
@@ -64,7 +65,7 @@ type DalvikBytecodeFormat22s = {
 };
 export declare const createDalvikBytecodeFormat22sParser: () => Parser<DalvikBytecodeFormat22s, Uint8Array>;
 type DalvikBytecodeFormat22t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
     registers: number[];
 };
 export declare const createDalvikBytecodeFormat22tParser: () => Parser<DalvikBytecodeFormat22t, Uint8Array>;
@@ -77,7 +78,7 @@ type DalvikBytecodeFormat23x = {
 };
 export declare const dalvikBytecodeFormat23xParser: Parser<DalvikBytecodeFormat23x, Uint8Array>;
 type DalvikBytecodeFormat30t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 };
 export declare const dalvikBytecodeFormat30tParser: Parser<DalvikBytecodeFormat30t, Uint8Array>;
 type DalvikBytecodeFormat31i = {
@@ -93,7 +94,7 @@ export declare const createDalvikBytecodeFormat31cParser: <Index>({ isoIndex, }:
     isoIndex: Iso<Index, number>;
 }) => Parser<DalvikBytecodeFormat31c<Index>, Uint8Array>;
 type DalvikBytecodeFormat31t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
     registers: number[];
 };
 export declare const dalvikBytecodeFormat31tParser: Parser<DalvikBytecodeFormat31t, Uint8Array>;

package/build/dalvikBytecodeParser/formatParsers.js

@@ -1,5 +1,7 @@
 import { byteParser, intParser, longParser, shortParser, ubyteParser, uintParser, ushortParser, } from '../dalvikExecutableParser/typeParsers.js';
+import { isoCodeUnit } from '../dalvikExecutableParser/typedNumbers.js';
 import { createElementParser } from '../elementParser.js';
+import { createObjectParser } from '../objectParser.js';
 import { setParserName } from '../parser.js';
 import { promiseCompose } from '../promiseCompose.js';
 import { createTupleParser } from '../tupleParser.js';
@@ -10,7 +12,7 @@ export const nibblesParser = promiseCompose(createElementParser(), byte => [
 ]);
 setParserName(nibblesParser, 'nibblesParser');
 export const dalvikBytecodeFormat10tParser = promiseCompose(byteParser, branchOffset => ({
-    branchOffset,
+    branchOffsetCodeUnit: isoCodeUnit.wrap(branchOffset),
 }));
 export const dalvikBytecodeFormat10xParser = promiseCompose(createElementParser(), () => undefined);
 export const dalvikBytecodeFormat11xParser = promiseCompose(ubyteParser, register0 => ({
@@ -33,8 +35,8 @@ export const dalvikBytecodeFormat12xParser = promiseCompose(nibblesParser, ([reg
 export const dalvikBytecodeFormat20tParser = promiseCompose(createTupleParser([
     ubyteParser,
     shortParser,
-]), ([_zero, branchOffset,]) => ({
-    branchOffset,
+]), ([_zero, branchOffset]) => ({
+    branchOffsetCodeUnit: isoCodeUnit.wrap(branchOffset),
 }));
 export const createDalvikBytecodeFormat21cParser = ({ isoIndex, }) => promiseCompose(createTupleParser([
     ubyteParser,
@@ -58,7 +60,7 @@ export const createDalvikBytecodeFormat21tParser = () => promiseCompose(createTu
     ubyteParser,
     shortParser,
 ]), ([register0, branchOffset,]) => ({
-    branchOffset,
+    branchOffsetCodeUnit: isoCodeUnit.wrap(branchOffset),
     registers: [
         register0,
     ],
@@ -107,7 +109,7 @@ export const createDalvikBytecodeFormat22tParser = () => promiseCompose(createTu
     nibblesParser,
     shortParser,
 ]), ([[register0, register1,], branchOffset,]) => ({
-    branchOffset,
+    branchOffsetCodeUnit: isoCodeUnit.wrap(branchOffset),
     registers: [
         register0,
         register1,
@@ -134,7 +136,7 @@ export const dalvikBytecodeFormat23xParser = promiseCompose(createTupleParser([
     ],
 }));
 export const dalvikBytecodeFormat30tParser = promiseCompose(intParser, branchOffset => ({
-    branchOffset,
+    branchOffsetCodeUnit: isoCodeUnit.wrap(branchOffset),
 }));
 export const dalvikBytecodeFormat31iParser = promiseCompose(createTupleParser([
     ubyteParser,
@@ -158,7 +160,7 @@ export const dalvikBytecodeFormat31tParser = promiseCompose(createTupleParser([
     ubyteParser,
     intParser,
 ]), ([register0, branchOffset,]) => ({
-    branchOffset,
+    branchOffsetCodeUnit: isoCodeUnit.wrap(branchOffset),
     registers: [
         register0,
     ],
@@ -206,13 +208,10 @@ export const dalvikBytecodeFormat51lParser = promiseCompose(createTupleParser([
         register0,
     ],
 }));
-export const dalvikBytecodeFormat20bcParser = promiseCompose(createTupleParser([
-    ubyteParser,
-    ushortParser,
-]), ([kind, index,]) => ({
-    kind,
-    index,
-}));
+export const dalvikBytecodeFormat20bcParser = createObjectParser({
+    kind: ubyteParser,
+    index: ushortParser,
+});
 export const dalvikBytecodeFormat22csParser = promiseCompose(createTupleParser([
     nibblesParser,
     ushortParser,