@futpib/parser 1.0.3 → 1.0.6

package/build/dalvikBytecodeParser.test-d.js

@@ -0,0 +1,268 @@
+// Helper to check that a literal type is assignable to the operation name union
+const _checkOperation = (_) => { };
+// nop
+_checkOperation('nop');
+// move operations
+_checkOperation('move');
+_checkOperation('move/from16');
+_checkOperation('move/16');
+_checkOperation('move-wide');
+_checkOperation('move-wide/from16');
+_checkOperation('move-wide/16');
+_checkOperation('move-object');
+_checkOperation('move-object/from16');
+_checkOperation('move-object/16');
+// move-result operations
+_checkOperation('move-result');
+_checkOperation('move-result-wide');
+_checkOperation('move-result-object');
+_checkOperation('move-exception');
+// return operations
+_checkOperation('return-void');
+_checkOperation('return');
+_checkOperation('return-wide');
+_checkOperation('return-object');
+// const operations
+_checkOperation('const/4');
+_checkOperation('const/16');
+_checkOperation('const');
+_checkOperation('const/high16');
+_checkOperation('const-wide/16');
+_checkOperation('const-wide/32');
+_checkOperation('const-wide');
+_checkOperation('const-wide/high16');
+_checkOperation('const-string');
+_checkOperation('const-string/jumbo');
+_checkOperation('const-class');
+_checkOperation('const-method-handle');
+_checkOperation('const-method-type');
+// monitor operations
+_checkOperation('monitor-enter');
+_checkOperation('monitor-exit');
+// type operations
+_checkOperation('check-cast');
+_checkOperation('instance-of');
+// array operations
+_checkOperation('array-length');
+_checkOperation('new-instance');
+_checkOperation('new-array');
+_checkOperation('filled-new-array');
+_checkOperation('filled-new-array/range');
+_checkOperation('fill-array-data');
+_checkOperation('fill-array-data-payload');
+// throw
+_checkOperation('throw');
+// goto operations
+_checkOperation('goto');
+_checkOperation('goto/16');
+_checkOperation('goto/32');
+// switch operations
+_checkOperation('packed-switch');
+_checkOperation('packed-switch-payload');
+_checkOperation('sparse-switch');
+_checkOperation('sparse-switch-payload');
+// compare operations
+_checkOperation('cmpl-float');
+_checkOperation('cmpg-float');
+_checkOperation('cmpl-double');
+_checkOperation('cmpg-double');
+_checkOperation('cmp-long');
+// if-test operations
+_checkOperation('if-eq');
+_checkOperation('if-ne');
+_checkOperation('if-lt');
+_checkOperation('if-ge');
+_checkOperation('if-gt');
+_checkOperation('if-le');
+// if-testz operations
+_checkOperation('if-eqz');
+_checkOperation('if-nez');
+_checkOperation('if-ltz');
+_checkOperation('if-gez');
+_checkOperation('if-gtz');
+_checkOperation('if-lez');
+// aget operations
+_checkOperation('aget');
+_checkOperation('aget-wide');
+_checkOperation('aget-object');
+_checkOperation('aget-boolean');
+_checkOperation('aget-byte');
+_checkOperation('aget-char');
+_checkOperation('aget-short');
+// aput operations
+_checkOperation('aput');
+_checkOperation('aput-wide');
+_checkOperation('aput-object');
+_checkOperation('aput-boolean');
+_checkOperation('aput-byte');
+_checkOperation('aput-char');
+_checkOperation('aput-short');
+// iget operations
+_checkOperation('iget');
+_checkOperation('iget-wide');
+_checkOperation('iget-object');
+_checkOperation('iget-boolean');
+_checkOperation('iget-byte');
+_checkOperation('iget-char');
+_checkOperation('iget-short');
+// iput operations
+_checkOperation('iput');
+_checkOperation('iput-wide');
+_checkOperation('iput-object');
+_checkOperation('iput-boolean');
+_checkOperation('iput-byte');
+_checkOperation('iput-char');
+_checkOperation('iput-short');
+// sget operations
+_checkOperation('sget');
+_checkOperation('sget-wide');
+_checkOperation('sget-object');
+_checkOperation('sget-boolean');
+_checkOperation('sget-byte');
+_checkOperation('sget-char');
+_checkOperation('sget-short');
+// sput operations
+_checkOperation('sput');
+_checkOperation('sput-wide');
+_checkOperation('sput-object');
+_checkOperation('sput-boolean');
+_checkOperation('sput-byte');
+_checkOperation('sput-char');
+_checkOperation('sput-short');
+// invoke operations
+_checkOperation('invoke-virtual');
+_checkOperation('invoke-super');
+_checkOperation('invoke-direct');
+_checkOperation('invoke-static');
+_checkOperation('invoke-interface');
+// invoke/range operations
+_checkOperation('invoke-virtual/range');
+_checkOperation('invoke-super/range');
+_checkOperation('invoke-direct/range');
+_checkOperation('invoke-static/range');
+_checkOperation('invoke-interface/range');
+// invoke-polymorphic operations
+_checkOperation('invoke-polymorphic');
+_checkOperation('invoke-polymorphic/range');
+// invoke-custom operations
+_checkOperation('invoke-custom');
+_checkOperation('invoke-custom/range');
+// unary operations
+_checkOperation('neg-int');
+_checkOperation('not-int');
+_checkOperation('neg-long');
+_checkOperation('not-long');
+_checkOperation('neg-float');
+_checkOperation('neg-double');
+_checkOperation('int-to-long');
+_checkOperation('int-to-float');
+_checkOperation('int-to-double');
+_checkOperation('long-to-int');
+_checkOperation('long-to-float');
+_checkOperation('long-to-double');
+_checkOperation('float-to-int');
+_checkOperation('float-to-long');
+_checkOperation('float-to-double');
+_checkOperation('double-to-int');
+_checkOperation('double-to-long');
+_checkOperation('double-to-float');
+_checkOperation('int-to-byte');
+_checkOperation('int-to-char');
+_checkOperation('int-to-short');
+// binary int operations
+_checkOperation('add-int');
+_checkOperation('sub-int');
+_checkOperation('mul-int');
+_checkOperation('div-int');
+_checkOperation('rem-int');
+_checkOperation('and-int');
+_checkOperation('or-int');
+_checkOperation('xor-int');
+_checkOperation('shl-int');
+_checkOperation('shr-int');
+_checkOperation('ushr-int');
+// binary long operations
+_checkOperation('add-long');
+_checkOperation('sub-long');
+_checkOperation('mul-long');
+_checkOperation('div-long');
+_checkOperation('rem-long');
+_checkOperation('and-long');
+_checkOperation('or-long');
+_checkOperation('xor-long');
+_checkOperation('shl-long');
+_checkOperation('shr-long');
+_checkOperation('ushr-long');
+// binary float operations
+_checkOperation('add-float');
+_checkOperation('sub-float');
+_checkOperation('mul-float');
+_checkOperation('div-float');
+_checkOperation('rem-float');
+// binary double operations
+_checkOperation('add-double');
+_checkOperation('sub-double');
+_checkOperation('mul-double');
+_checkOperation('div-double');
+_checkOperation('rem-double');
+// binary int/2addr operations
+_checkOperation('add-int/2addr');
+_checkOperation('sub-int/2addr');
+_checkOperation('mul-int/2addr');
+_checkOperation('div-int/2addr');
+_checkOperation('rem-int/2addr');
+_checkOperation('and-int/2addr');
+_checkOperation('or-int/2addr');
+_checkOperation('xor-int/2addr');
+_checkOperation('shl-int/2addr');
+_checkOperation('shr-int/2addr');
+_checkOperation('ushr-int/2addr');
+// binary long/2addr operations
+_checkOperation('add-long/2addr');
+_checkOperation('sub-long/2addr');
+_checkOperation('mul-long/2addr');
+_checkOperation('div-long/2addr');
+_checkOperation('rem-long/2addr');
+_checkOperation('and-long/2addr');
+_checkOperation('or-long/2addr');
+_checkOperation('xor-long/2addr');
+_checkOperation('shl-long/2addr');
+_checkOperation('shr-long/2addr');
+_checkOperation('ushr-long/2addr');
+// binary float/2addr operations
+_checkOperation('add-float/2addr');
+_checkOperation('sub-float/2addr');
+_checkOperation('mul-float/2addr');
+_checkOperation('div-float/2addr');
+_checkOperation('rem-float/2addr');
+// binary double/2addr operations
+_checkOperation('add-double/2addr');
+_checkOperation('sub-double/2addr');
+_checkOperation('mul-double/2addr');
+_checkOperation('div-double/2addr');
+_checkOperation('rem-double/2addr');
+// binary int/lit16 operations
+_checkOperation('add-int/lit16');
+_checkOperation('rsub-int');
+_checkOperation('mul-int/lit16');
+_checkOperation('div-int/lit16');
+_checkOperation('rem-int/lit16');
+_checkOperation('and-int/lit16');
+_checkOperation('or-int/lit16');
+_checkOperation('xor-int/lit16');
+// binary int/lit8 operations
+_checkOperation('add-int/lit8');
+_checkOperation('rsub-int/lit8');
+_checkOperation('mul-int/lit8');
+_checkOperation('div-int/lit8');
+_checkOperation('rem-int/lit8');
+_checkOperation('and-int/lit8');
+_checkOperation('or-int/lit8');
+_checkOperation('xor-int/lit8');
+_checkOperation('shl-int/lit8');
+_checkOperation('shr-int/lit8');
+_checkOperation('ushr-int/lit8');
+// Verify the type check actually works - this should be a type error
+// @ts-expect-error
+_checkOperation('fake-operation');
+export {};

package/build/dalvikBytecodeUnparser/formatUnparsers.d.ts

@@ -1,4 +1,5 @@
 import { type Unparser } from '../unparser.js';
+import { type CodeUnit } from '../dalvikExecutableParser/typedNumbers.js';
 export declare const ubyteUnparser: Unparser<number, Uint8Array>;
 export declare const byteUnparser: Unparser<number, Uint8Array>;
 export declare const shortUnparser: Unparser<number, Uint8Array>;
@@ -9,7 +10,7 @@ export declare const longUnparser: Unparser<bigint, Uint8Array>;
 export declare const ulongUnparser: Unparser<bigint, Uint8Array>;
 export declare const nibblesUnparser: Unparser<[number, number], Uint8Array>;
 type DalvikBytecodeFormat10t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 };
 export declare const dalvikBytecodeFormat10tUnparser: Unparser<DalvikBytecodeFormat10t, Uint8Array>;
 type DalvikBytecodeFormat10x = void;
@@ -29,7 +30,7 @@ type DalvikBytecodeFormat12x = {
 export declare const dalvikBytecodeFormat12xUnparser: Unparser<DalvikBytecodeFormat12x, Uint8Array>;
 export declare const dalvikBytecodeFormat12xReversedUnparser: Unparser<DalvikBytecodeFormat12x, Uint8Array>;
 type DalvikBytecodeFormat20t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 };
 export declare const dalvikBytecodeFormat20tUnparser: Unparser<DalvikBytecodeFormat20t, Uint8Array>;
 type DalvikBytecodeFormat21c = {
@@ -43,7 +44,7 @@ type DalvikBytecodeFormat21h = {
 };
 export declare const dalvikBytecodeFormat21hUnparser: Unparser<DalvikBytecodeFormat21h, Uint8Array>;
 type DalvikBytecodeFormat21t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
     registers: number[];
 };
 export declare const dalvikBytecodeFormat21tUnparser: Unparser<DalvikBytecodeFormat21t, Uint8Array>;
@@ -68,7 +69,7 @@ type DalvikBytecodeFormat22s = {
 };
 export declare const dalvikBytecodeFormat22sUnparser: Unparser<DalvikBytecodeFormat22s, Uint8Array>;
 type DalvikBytecodeFormat22t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
     registers: number[];
 };
 export declare const dalvikBytecodeFormat22tUnparser: Unparser<DalvikBytecodeFormat22t, Uint8Array>;
@@ -82,7 +83,7 @@ type DalvikBytecodeFormat23x = {
 };
 export declare const dalvikBytecodeFormat23xUnparser: Unparser<DalvikBytecodeFormat23x, Uint8Array>;
 type DalvikBytecodeFormat30t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 };
 export declare const dalvikBytecodeFormat30tUnparser: Unparser<DalvikBytecodeFormat30t, Uint8Array>;
 type DalvikBytecodeFormat31i = {
@@ -96,7 +97,7 @@ type DalvikBytecodeFormat31c = {
 };
 export declare const dalvikBytecodeFormat31cUnparser: Unparser<DalvikBytecodeFormat31c, Uint8Array>;
 type DalvikBytecodeFormat31t = {
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
     registers: number[];
 };
 export declare const dalvikBytecodeFormat31tUnparser: Unparser<DalvikBytecodeFormat31t, Uint8Array>;
@@ -134,13 +135,13 @@ export declare const dalvikBytecodeFormat4rccUnparser: Unparser<DalvikBytecodeFo
 type DalvikBytecodeOperationPackedSwitchPayload = {
     operation: 'packed-switch-payload';
     value: number;
-    branchOffsets: number[];
+    branchOffsetsCodeUnit: CodeUnit[];
 };
 export declare const dalvikBytecodeOperationPackedSwitchPayloadUnparser: Unparser<DalvikBytecodeOperationPackedSwitchPayload, Uint8Array>;
 type DalvikBytecodeOperationSparseSwitchPayload = {
     operation: 'sparse-switch-payload';
     keys: number[];
-    branchOffsets: number[];
+    branchOffsetsCodeUnit: CodeUnit[];
 };
 export declare const dalvikBytecodeOperationSparseSwitchPayloadUnparser: Unparser<DalvikBytecodeOperationSparseSwitchPayload, Uint8Array>;
 type DalvikBytecodeOperationFillArrayDataPayload = {

package/build/dalvikBytecodeUnparser/formatUnparsers.js

@@ -1,3 +1,4 @@
+import { isoCodeUnit } from '../dalvikExecutableParser/typedNumbers.js';
 // Basic type unparsers
 export const ubyteUnparser = async function* (input) {
     const buffer = Buffer.alloc(1);
@@ -45,7 +46,7 @@ export const nibblesUnparser = async function* ([high, low], unparserContext) {
     yield* ubyteUnparser(byte, unparserContext);
 };
 export const dalvikBytecodeFormat10tUnparser = async function* (input, unparserContext) {
-    yield* byteUnparser(input.branchOffset, unparserContext);
+    yield* byteUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 export const dalvikBytecodeFormat10xUnparser = async function* (_input, unparserContext) {
     yield* ubyteUnparser(0, unparserContext); // Zero byte
@@ -65,7 +66,7 @@ export const dalvikBytecodeFormat12xReversedUnparser = async function* (input, u
 };
 export const dalvikBytecodeFormat20tUnparser = async function* (input, unparserContext) {
     yield* ubyteUnparser(0, unparserContext);
-    yield* shortUnparser(input.branchOffset, unparserContext);
+    yield* shortUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 export const dalvikBytecodeFormat21cUnparser = async function* (input, unparserContext) {
     yield* ubyteUnparser(input.registers[0], unparserContext);
@@ -77,7 +78,7 @@ export const dalvikBytecodeFormat21hUnparser = async function* (input, unparserC
 };
 export const dalvikBytecodeFormat21tUnparser = async function* (input, unparserContext) {
     yield* ubyteUnparser(input.registers[0], unparserContext);
-    yield* shortUnparser(input.branchOffset, unparserContext);
+    yield* shortUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 export const dalvikBytecodeFormat21sUnparser = async function* (input, unparserContext) {
     yield* ubyteUnparser(input.registers[0], unparserContext);
@@ -98,13 +99,13 @@ export const dalvikBytecodeFormat22sUnparser = async function* (input, unparserC
 };
 export const dalvikBytecodeFormat22tUnparser = async function* (input, unparserContext) {
     yield* nibblesUnparser([input.registers[1], input.registers[0]], unparserContext);
-    yield* shortUnparser(input.branchOffset, unparserContext);
+    yield* shortUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 // Format 22t for commutative operations (if-eq, if-ne): registers are already in sorted/canonical order
 // so we don't reverse them
 export const dalvikBytecodeFormat22tCommutativeUnparser = async function* (input, unparserContext) {
     yield* nibblesUnparser([input.registers[0], input.registers[1]], unparserContext);
-    yield* shortUnparser(input.branchOffset, unparserContext);
+    yield* shortUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 export const dalvikBytecodeFormat22xUnparser = async function* (input, unparserContext) {
     yield* ubyteUnparser(input.registers[0], unparserContext);
@@ -116,7 +117,7 @@ export const dalvikBytecodeFormat23xUnparser = async function* (input, unparserC
     yield* ubyteUnparser(input.registers[2], unparserContext);
 };
 export const dalvikBytecodeFormat30tUnparser = async function* (input, unparserContext) {
-    yield* intUnparser(input.branchOffset, unparserContext);
+    yield* intUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 export const dalvikBytecodeFormat31iUnparser = async function* (input, unparserContext) {
     yield* ubyteUnparser(input.registers[0], unparserContext);
@@ -128,7 +129,7 @@ export const dalvikBytecodeFormat31cUnparser = async function* (input, unparserC
 };
 export const dalvikBytecodeFormat31tUnparser = async function* (input, unparserContext) {
     yield* ubyteUnparser(input.registers[0], unparserContext);
-    yield* intUnparser(input.branchOffset, unparserContext);
+    yield* intUnparser(isoCodeUnit.unwrap(input.branchOffsetCodeUnit), unparserContext);
 };
 export const dalvikBytecodeFormat32xUnparser = async function* (input, unparserContext) {
     yield* ushortUnparser(input.registers[0], unparserContext);
@@ -182,12 +183,12 @@ export const dalvikBytecodeOperationPackedSwitchPayloadUnparser = async function
     // Ident (0x0100) - little-endian
     yield* ushortUnparser(0x01_00, unparserContext);
     // Size
-    yield* ushortUnparser(input.branchOffsets.length, unparserContext);
+    yield* ushortUnparser(input.branchOffsetsCodeUnit.length, unparserContext);
     // First key value
     yield* intUnparser(input.value, unparserContext);
     // Branch offsets
-    for (const offset of input.branchOffsets) {
-        yield* intUnparser(offset, unparserContext);
+    for (const offset of input.branchOffsetsCodeUnit) {
+        yield* intUnparser(isoCodeUnit.unwrap(offset), unparserContext);
     }
 };
 export const dalvikBytecodeOperationSparseSwitchPayloadUnparser = async function* (input, unparserContext) {
@@ -200,8 +201,8 @@ export const dalvikBytecodeOperationSparseSwitchPayloadUnparser = async function
         yield* intUnparser(key, unparserContext);
     }
     // Branch offsets
-    for (const offset of input.branchOffsets) {
-        yield* intUnparser(offset, unparserContext);
+    for (const offset of input.branchOffsetsCodeUnit) {
+        yield* intUnparser(isoCodeUnit.unwrap(offset), unparserContext);
     }
 };
 export const dalvikBytecodeOperationFillArrayDataPayloadUnparser = async function* (input, unparserContext) {

package/build/dalvikBytecodeUnparser.d.ts

@@ -1,3 +1,3 @@
 import { type Unparser } from './unparser.js';
-import { type DalvikBytecode } from './dalvikBytecodeParser.js';
-export declare const dalvikBytecodeUnparser: Unparser<DalvikBytecode, Uint8Array>;
+import { type RawDalvikBytecode } from './dalvikBytecodeParser.js';
+export declare const rawDalvikBytecodeUnparser: Unparser<RawDalvikBytecode, Uint8Array>;

package/build/dalvikBytecodeUnparser.js

@@ -245,9 +245,9 @@ const operationToOpcodeMap = new Map([
     // Note: Payload instructions don't have single-byte opcodes
     // They use multi-byte identifiers: 0x0100, 0x0200, 0x0300
 ]);
-export const dalvikBytecodeUnparser = async function* (input, unparserContext) {
+export const rawDalvikBytecodeUnparser = async function* (input, unparserContext) {
     for (const operation of input) {
-        yield* dalvikBytecodeOperationUnparser(operation, unparserContext);
+        yield* rawDalvikBytecodeOperationUnparser(operation, unparserContext);
     }
 };
 // Type guards for payload operations
@@ -260,7 +260,7 @@ function isSparseSwitchPayload(op) {
 function isFillArrayDataPayload(op) {
     return typeof op === 'object' && op !== null && 'operation' in op && op.operation === 'fill-array-data-payload';
 }
-const dalvikBytecodeOperationUnparser = async function* (operation, unparserContext) {
+const rawDalvikBytecodeOperationUnparser = async function* (operation, unparserContext) {
     if (!operation || typeof operation !== 'object' || !('operation' in operation)) {
         throw new Error('Invalid operation');
     }
@@ -300,8 +300,8 @@ function hasRegisters(op) {
 function hasValue(op) {
     return 'value' in op;
 }
-function hasBranchOffset(op) {
-    return 'branchOffset' in op;
+function hasBranchOffsetCodeUnit(op) {
+    return 'branchOffsetCodeUnit' in op;
 }
 async function* unparseOperationData(operation, unparserContext) {
     if (!('operation' in operation)) {
@@ -499,54 +499,54 @@ async function* unparseOperationData(operation, unparserContext) {
     }
     // Format 10t (goto)
     if (operationName === 'goto') {
-        if (!hasBranchOffset(operation)) {
-            throw new Error(`Operation ${operationName} missing branchOffset field`);
+        if (!hasBranchOffsetCodeUnit(operation)) {
+            throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit field`);
         }
-        yield* dalvikBytecodeFormat10tUnparser({ branchOffset: operation.branchOffset }, unparserContext);
+        yield* dalvikBytecodeFormat10tUnparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit }, unparserContext);
         return;
     }
     // Format 20t (goto/16)
     if (operationName === 'goto/16') {
-        if (!hasBranchOffset(operation)) {
-            throw new Error(`Operation ${operationName} missing branchOffset field`);
+        if (!hasBranchOffsetCodeUnit(operation)) {
+            throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit field`);
         }
-        yield* dalvikBytecodeFormat20tUnparser({ branchOffset: operation.branchOffset }, unparserContext);
+        yield* dalvikBytecodeFormat20tUnparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit }, unparserContext);
         return;
     }
     // Format 30t (goto/32)
     if (operationName === 'goto/32') {
-        if (!hasBranchOffset(operation)) {
-            throw new Error(`Operation ${operationName} missing branchOffset field`);
+        if (!hasBranchOffsetCodeUnit(operation)) {
+            throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit field`);
         }
-        yield* dalvikBytecodeFormat30tUnparser({ branchOffset: operation.branchOffset }, unparserContext);
+        yield* dalvikBytecodeFormat30tUnparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit }, unparserContext);
         return;
     }
     // Format 22t (if-* operations)
     if (operationName.startsWith('if-') && !operationName.endsWith('z')) {
-        if (!hasBranchOffset(operation) || !hasRegisters(operation)) {
-            throw new Error(`Operation ${operationName} missing branchOffset or registers field`);
+        if (!hasBranchOffsetCodeUnit(operation) || !hasRegisters(operation)) {
+            throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit or registers field`);
         }
         // Commutative operations (if-eq, if-ne) have sorted registers, so don't reverse
         const isCommutative = operationName === 'if-eq' || operationName === 'if-ne';
         const unparser = isCommutative ? dalvikBytecodeFormat22tCommutativeUnparser : dalvikBytecodeFormat22tUnparser;
-        yield* unparser({ branchOffset: operation.branchOffset, registers: operation.registers }, unparserContext);
+        yield* unparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit, registers: operation.registers }, unparserContext);
         return;
     }
     // Format 21t (if-*z operations)
     if (operationName.startsWith('if-') && operationName.endsWith('z')) {
-        if (!hasBranchOffset(operation) || !hasRegisters(operation)) {
-            throw new Error(`Operation ${operationName} missing branchOffset or registers field`);
+        if (!hasBranchOffsetCodeUnit(operation) || !hasRegisters(operation)) {
+            throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit or registers field`);
         }
-        yield* dalvikBytecodeFormat21tUnparser({ branchOffset: operation.branchOffset, registers: operation.registers }, unparserContext);
+        yield* dalvikBytecodeFormat21tUnparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit, registers: operation.registers }, unparserContext);
         return;
     }
     // Format 31t (packed-switch, sparse-switch, fill-array-data)
     if (operationName === 'packed-switch' || operationName === 'sparse-switch' ||
         operationName === 'fill-array-data') {
-        if (!hasBranchOffset(operation) || !hasRegisters(operation)) {
-            throw new Error(`Operation ${operationName} missing branchOffset or registers field`);
+        if (!hasBranchOffsetCodeUnit(operation) || !hasRegisters(operation)) {
+            throw new Error(`Operation ${operationName} missing branchOffsetCodeUnit or registers field`);
         }
-        yield* dalvikBytecodeFormat31tUnparser({ branchOffset: operation.branchOffset, registers: operation.registers }, unparserContext);
+        yield* dalvikBytecodeFormat31tUnparser({ branchOffsetCodeUnit: operation.branchOffsetCodeUnit, registers: operation.registers }, unparserContext);
         return;
     }
     // Format 22b (binary operations with literal8)

package/build/dalvikBytecodeUnparser.test.js

@@ -1,22 +1,22 @@
 import { testProp } from '@fast-check/ava';
 import { runUnparser } from './unparser.js';
-import { dalvikBytecodeUnparser } from './dalvikBytecodeUnparser.js';
+import { rawDalvikBytecodeUnparser } from './dalvikBytecodeUnparser.js';
 import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
 import { runParser } from './parser.js';
-import { createDalvikBytecodeParser } from './dalvikBytecodeParser.js';
+import { createRawDalvikBytecodeParser } from './dalvikBytecodeParser.js';
 import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
-import { arbitraryDalvikBytecode } from './arbitraryDalvikBytecode.js';
+import { arbitraryRawDalvikBytecode } from './arbitraryDalvikBytecode.js';
 import { uint8ArrayAsyncIterableToUint8Array } from './uint8Array.js';
 const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
-testProp('dalvik bytecode roundtrip', [arbitraryDalvikBytecode], async (t, bytecode) => {
+testProp('dalvik bytecode roundtrip', [arbitraryRawDalvikBytecode], async (t, bytecode) => {
     // Unparse the bytecode to bytes
-    const unparsedStreamIterable = runUnparser(dalvikBytecodeUnparser, bytecode, uint8ArrayUnparserOutputCompanion);
+    const unparsedStreamIterable = runUnparser(rawDalvikBytecodeUnparser, bytecode, uint8ArrayUnparserOutputCompanion);
     // Collect all chunks into a single Uint8Array
     const unparsedStream = await uint8ArrayAsyncIterableToUint8Array(unparsedStreamIterable);
     // Create parser with the correct size
-    const dalvikBytecodeParser = createDalvikBytecodeParser(unparsedStream.length);
+    const rawDalvikBytecodeParser = createRawDalvikBytecodeParser(unparsedStream.length);
     // Re-parse the unparsed bytes
-    const actual = await runParser(dalvikBytecodeParser, unparsedStream, uint8ArrayParserInputCompanion);
+    const actual = await runParser(rawDalvikBytecodeParser, unparsedStream, uint8ArrayParserInputCompanion);
     // Assert deep equality
     t.deepEqual(actual, bytecode);
 }, {

package/build/dalvikExecutable.d.ts

@@ -76,17 +76,17 @@ export type DalvikExecutableEncodedValue = {
     value: boolean;
 };
 type DalvikExecutableTry = {
-    startAddress: number;
+    startInstructionIndex: number;
     instructionCount: number;
     handler: DalvikExecutableEncodedCatchHandler;
 };
 type DalvikExecutableEncodedTypeAddressPair = {
     type: string;
-    address: number;
+    handlerInstructionIndex: number;
 };
 type DalvikExecutableEncodedCatchHandler = {
     handlers: DalvikExecutableEncodedTypeAddressPair[];
-    catchAllAddress: undefined | number;
+    catchAllInstructionIndex: undefined | number;
 };
 export type DalvikExecutableCode<Instructions> = {
     registersSize: number;

package/build/dalvikExecutable.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/build/dalvikExecutable.test-d.js

@@ -0,0 +1,59 @@
+import { expectType } from 'tsd';
+const classDef = dex.classDefinitions[0];
+const classData = classDef.classData;
+const method = classData.directMethods[0];
+const code = method.code;
+// Try block field types
+const tryBlock = code.tries[0];
+expectType(tryBlock.startInstructionIndex);
+expectType(tryBlock.instructionCount);
+// Handler field types
+const handler = tryBlock.handler;
+expectType(handler.catchAllInstructionIndex);
+// Type-address pair field types
+const typeAddressPair = handler.handlers[0];
+expectType(typeAddressPair.handlerInstructionIndex);
+expectType(gotoOp.targetInstructionIndex);
+expectType(goto16Op.targetInstructionIndex);
+expectType(goto32Op.targetInstructionIndex);
+expectType(packedSwitchOp.targetInstructionIndex);
+expectType(sparseSwitchOp.targetInstructionIndex);
+expectType(packedSwitchPayloadOp.targetInstructionIndices);
+expectType(sparseSwitchPayloadOp.targetInstructionIndices);
+expectType(fillArrayDataOp.targetInstructionIndex);
+expectType(ifEqOp.targetInstructionIndex);
+expectType(ifEqzOp.targetInstructionIndex);
+expectType(invokeVirtualOp.method);
+expectType(igetOp.field);
+expectType(checkCastOp.type);
+expectType(constStringOp.string);
+// Test that raw index fields do NOT exist on resolved types
+// @ts-expect-error - methodIndex should not exist, use method instead
+invokeVirtualOp.methodIndex;
+// @ts-expect-error - fieldIndex should not exist, use field instead
+igetOp.fieldIndex;
+// @ts-expect-error - typeIndex should not exist, use type instead
+checkCastOp.typeIndex;
+// @ts-expect-error - stringIndex should not exist, use string instead
+constStringOp.stringIndex;
+// Test that values can be constructed with resolved fields
+const _invokeVirtual = {
+    operation: 'invoke-virtual',
+    registers: [0],
+    method: { class: 'Lfoo/Bar;', prototype: { shorty: 'V', returnType: 'V', parameters: [] }, name: 'baz' },
+};
+const _iget = {
+    operation: 'iget',
+    registers: [0, 1],
+    field: { class: 'Lfoo/Bar;', type: 'I', name: 'x' },
+};
+const _checkCast = {
+    operation: 'check-cast',
+    registers: [0],
+    type: 'Lfoo/Bar;',
+};
+const _constString = {
+    operation: 'const-string',
+    registers: [0],
+    string: 'hello',
+};