@futpib/parser 1.0.3 → 1.0.6

package/build/bashParserEdgeCases.test.js

@@ -0,0 +1,117 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { bashScriptParser } from './bashParser.js';
+// Braced variable expansion: ${VAR}
+test('braced variable expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo ${HOME}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'variableBraced');
+    }
+});
+// Braced variable with default: ${VAR:-default}
+test('braced variable with default value', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo ${VAR:-default}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'variableBraced');
+    }
+});
+// Arithmetic expansion: $((1+2))
+test('arithmetic expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $((1+2))', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'arithmeticExpansion');
+    }
+});
+// Bare $ at end of unquoted word
+test('bare dollar at end of unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo$', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [
+                { type: 'literal', value: 'foo' },
+                { type: 'literal', value: '$' },
+            ],
+        });
+    }
+});
+// Bare $ as its own unquoted word
+test('bare dollar as standalone unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [
+                { type: 'literal', value: '$' },
+            ],
+        });
+    }
+});
+// Comment after command
+test('comment after command', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello # this is a comment', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 1);
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'literal', value: 'hello' }],
+        });
+    }
+});
+// ANSI-C quoting: $'...'
+test('ansi-c quoting', async (t) => {
+    const result = await runParser(bashScriptParser, "echo $'hello\\nworld'", stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 1);
+    }
+});
+// Braced variable in double quotes: "${VAR}"
+test('braced variable in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "${HOME}"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        const dq = cmd.args[0].parts[0];
+        if (dq.type === 'doubleQuoted') {
+            t.is(dq.parts[0].type, 'variableBraced');
+        }
+    }
+});
+// Arithmetic expansion in double quotes
+test('arithmetic expansion in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "$((1+2))"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        const dq = cmd.args[0].parts[0];
+        if (dq.type === 'doubleQuoted') {
+            t.is(dq.parts[0].type, 'arithmeticExpansion');
+        }
+    }
+});
+// Process substitution: <(cmd)
+test('process substitution input', async (t) => {
+    const result = await runParser(bashScriptParser, 'diff <(sort file1) <(sort file2)', stringParserInputCompanion);
+    t.truthy(result);
+});
+// Line continuation (backslash-newline)
+test('line continuation', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello \\\nworld', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 2);
+    }
+});
+// Hash in middle of unquoted word is literal, not a comment
+test('hash in middle of unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo#bar', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'literal', value: 'foo#bar' }],
+        });
+    }
+});

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>;