@futpib/parser 1.0.3 → 1.0.6

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,

package/build/dalvikBytecodeParser.d.ts

@@ -1,5 +1,5 @@
 import { type DalvikExecutableField, type DalvikExecutableMethod } from './dalvikExecutable.js';
-import { type IndexIntoFieldIds, type IndexIntoMethodIds, type IndexIntoPrototypeIds, type IndexIntoStringIds, type IndexIntoTypeIds } from './dalvikExecutableParser/typedNumbers.js';
+import { type CodeUnit, type IndexIntoCallSiteIds, type IndexIntoFieldIds, type IndexIntoMethodIds, type IndexIntoPrototypeIds, type IndexIntoStringIds, type IndexIntoTypeIds } from './dalvikExecutableParser/typedNumbers.js';
 import { type Parser } from './parser.js';
 type DalvikBytecodeOperationNoOperation = {
     operation: 'nop';
@@ -78,37 +78,47 @@ type DalvikBytecodeOperationInvokePolymorphicRange = {
     protoIndex: IndexIntoPrototypeIds;
     registers: number[];
 };
+type DalvikBytecodeOperationInvokeCustom = {
+    operation: 'invoke-custom';
+    callSiteIndex: IndexIntoCallSiteIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationInvokeCustomRange = {
+    operation: 'invoke-custom/range';
+    callSiteIndex: IndexIntoCallSiteIds;
+    registers: number[];
+};
 type DalvikBytecodeOperationGoto = {
     operation: 'goto';
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 };
 type DalvikBytecodeOperationGoto16 = {
     operation: 'goto/16';
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 };
 type DalvikBytecodeOperationGoto32 = {
     operation: 'goto/32';
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 };
 type DalvikBytecodeOperationPackedSwitch = {
     operation: 'packed-switch';
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
     registers: number[];
 };
 type DalvikBytecodeOperationPackedSwitchPayload = {
     operation: 'packed-switch-payload';
     value: number;
-    branchOffsets: number[];
+    branchOffsetsCodeUnit: CodeUnit[];
 };
 type DalvikBytecodeOperationSparseSwitch = {
     operation: 'sparse-switch';
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
     registers: number[];
 };
 type DalvikBytecodeOperationSparseSwitchPayload = {
     operation: 'sparse-switch-payload';
     keys: number[];
-    branchOffsets: number[];
+    branchOffsetsCodeUnit: CodeUnit[];
 };
 type DalvikBytecodeOperationFillArrayDataPayload = {
     operation: 'fill-array-data-payload';
@@ -768,6 +778,11 @@ declare const dalvikBytecodeOperationDivideFloatParser: Parser<{
     registers: number[];
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationDivideFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideFloatParser>>;
+declare const dalvikBytecodeOperationRemainderFloatParser: Parser<{
+    operation: "rem-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationRemainderFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderFloatParser>>;
 declare const dalvikBytecodeOperationAddDoubleParser: Parser<{
     operation: "add-double";
     registers: number[];
@@ -793,7 +808,7 @@ declare const dalvikBytecodeOperationRemainderDoubleParser: Parser<{
     registers: number[];
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationRemainderDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderDoubleParser>>;
-type DalvikBytecodeOperationBinaryOperation = DalvikBytecodeOperationAddInt | DalvikBytecodeOperationSubtractInt | DalvikBytecodeOperationMultiplyInt | DalvikBytecodeOperationDivideInt | DalvikBytecodeOperationRemainderInt | DalvikBytecodeOperationAndInt | DalvikBytecodeOperationOrInt | DalvikBytecodeOperationXorInt | DalvikBytecodeOperationShiftLeftInt | DalvikBytecodeOperationShiftRightInt | DalvikBytecodeOperationUnsignedShiftRightInt | DalvikBytecodeOperationAddLong | DalvikBytecodeOperationSubtractLong | DalvikBytecodeOperationMultiplyLong | DalvikBytecodeOperationDivideLong | DalvikBytecodeOperationRemainderLong | DalvikBytecodeOperationAndLong | DalvikBytecodeOperationOrLong | DalvikBytecodeOperationXorLong | DalvikBytecodeOperationShiftLeftLong | DalvikBytecodeOperationShiftRightLong | DalvikBytecodeOperationUnsignedShiftRightLong | DalvikBytecodeOperationAddFloat | DalvikBytecodeOperationSubtractFloat | DalvikBytecodeOperationMultiplyFloat | DalvikBytecodeOperationDivideFloat | DalvikBytecodeOperationAddDouble | DalvikBytecodeOperationSubtractDouble | DalvikBytecodeOperationMultiplyDouble | DalvikBytecodeOperationDivideDouble | DalvikBytecodeOperationRemainderDouble;
+type DalvikBytecodeOperationBinaryOperation = DalvikBytecodeOperationAddInt | DalvikBytecodeOperationSubtractInt | DalvikBytecodeOperationMultiplyInt | DalvikBytecodeOperationDivideInt | DalvikBytecodeOperationRemainderInt | DalvikBytecodeOperationAndInt | DalvikBytecodeOperationOrInt | DalvikBytecodeOperationXorInt | DalvikBytecodeOperationShiftLeftInt | DalvikBytecodeOperationShiftRightInt | DalvikBytecodeOperationUnsignedShiftRightInt | DalvikBytecodeOperationAddLong | DalvikBytecodeOperationSubtractLong | DalvikBytecodeOperationMultiplyLong | DalvikBytecodeOperationDivideLong | DalvikBytecodeOperationRemainderLong | DalvikBytecodeOperationAndLong | DalvikBytecodeOperationOrLong | DalvikBytecodeOperationXorLong | DalvikBytecodeOperationShiftLeftLong | DalvikBytecodeOperationShiftRightLong | DalvikBytecodeOperationUnsignedShiftRightLong | DalvikBytecodeOperationAddFloat | DalvikBytecodeOperationSubtractFloat | DalvikBytecodeOperationMultiplyFloat | DalvikBytecodeOperationDivideFloat | DalvikBytecodeOperationRemainderFloat | DalvikBytecodeOperationAddDouble | DalvikBytecodeOperationSubtractDouble | DalvikBytecodeOperationMultiplyDouble | DalvikBytecodeOperationDivideDouble | DalvikBytecodeOperationRemainderDouble;
 declare const dalvikBytecodeOperationNegateIntParser: Parser<{
     operation: "neg-int";
     registers: number[];
@@ -903,74 +918,74 @@ type DalvikBytecodeOperationUnaryOperation = DalvikBytecodeOperationNegateInt |
 declare const dalvikBytecodeIfEqualParser: Parser<{
     operation: "if-eq";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfEqual = Awaited<ReturnType<typeof dalvikBytecodeIfEqualParser>>;
 declare const dalvikBytecodeIfNotEqualParser: Parser<{
     operation: "if-ne";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfNotEqual = Awaited<ReturnType<typeof dalvikBytecodeIfNotEqualParser>>;
 declare const dalvikBytecodeIfLessThanParser: Parser<{
     operation: "if-lt";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfLessThan = Awaited<ReturnType<typeof dalvikBytecodeIfLessThanParser>>;
 declare const dalvikBytecodeIfGreaterThanOrEqualToParser: Parser<{
     operation: "if-ge";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfGreaterThanOrEqualTo = Awaited<ReturnType<typeof dalvikBytecodeIfGreaterThanOrEqualToParser>>;
 declare const dalvikBytecodeIfGreaterThanParser: Parser<{
     operation: "if-gt";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfGreaterThan = Awaited<ReturnType<typeof dalvikBytecodeIfGreaterThanParser>>;
 declare const dalvikBytecodeIfLessThanOrEqualToParser: Parser<{
     operation: "if-le";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfLessThanOrEqualTo = Awaited<ReturnType<typeof dalvikBytecodeIfLessThanOrEqualToParser>>;
 type DalvikBytecodeOperationIfTest = DalvikBytecodeOperationIfEqual | DalvikBytecodeOperationIfNotEqual | DalvikBytecodeOperationIfLessThan | DalvikBytecodeOperationIfGreaterThanOrEqualTo | DalvikBytecodeOperationIfGreaterThan | DalvikBytecodeOperationIfLessThanOrEqualTo;
 declare const dalvikBytecodeIfEqualZeroParser: Parser<{
     operation: "if-eqz";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfEqualZero = Awaited<ReturnType<typeof dalvikBytecodeIfEqualZeroParser>>;
 declare const dalvikBytecodeIfNotEqualZeroParser: Parser<{
     operation: "if-nez";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfNotEqualZero = Awaited<ReturnType<typeof dalvikBytecodeIfNotEqualZeroParser>>;
 declare const dalvikBytecodeIfLessThanZeroParser: Parser<{
     operation: "if-ltz";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfLessThanZero = Awaited<ReturnType<typeof dalvikBytecodeIfLessThanZeroParser>>;
 declare const dalvikBytecodeIfGreaterThanOrEqualToZeroParser: Parser<{
     operation: "if-gez";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfGreaterThanOrEqualToZero = Awaited<ReturnType<typeof dalvikBytecodeIfGreaterThanOrEqualToZeroParser>>;
 declare const dalvikBytecodeIfGreaterThanZeroParser: Parser<{
     operation: "if-gtz";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfGreaterThanZero = Awaited<ReturnType<typeof dalvikBytecodeIfGreaterThanZeroParser>>;
 declare const dalvikBytecodeIfLessThanOrEqualToZeroParser: Parser<{
     operation: "if-lez";
     registers: number[];
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationIfLessThanOrEqualToZero = Awaited<ReturnType<typeof dalvikBytecodeIfLessThanOrEqualToZeroParser>>;
 type DalvikBytecodeOperationIfTestZero = DalvikBytecodeOperationIfEqualZero | DalvikBytecodeOperationIfNotEqualZero | DalvikBytecodeOperationIfLessThanZero | DalvikBytecodeOperationIfGreaterThanOrEqualToZero | DalvikBytecodeOperationIfGreaterThanZero | DalvikBytecodeOperationIfLessThanOrEqualToZero;
@@ -989,6 +1004,11 @@ type DalvikBytecodeOperationConstMethodHandle = {
     methodIndex: IndexIntoMethodIds;
     registers: number[];
 };
+type DalvikBytecodeOperationConstMethodType = {
+    operation: 'const-method-type';
+    protoIndex: IndexIntoPrototypeIds;
+    registers: number[];
+};
 type DalvikBytecodeOperationNewInstance = {
     operation: 'new-instance';
     typeIndex: IndexIntoTypeIds;
@@ -1011,7 +1031,7 @@ type DalvikBytecodeOperationFilledNewArrayRange = {
 };
 type DalvikBytecodeOperationFillArrayData = {
     operation: 'fill-array-data';
-    branchOffset: number;
+    branchOffsetCodeUnit: CodeUnit;
     registers: number[];
 };
 type DalvikBytecodeOperationCheckCast = {
@@ -1088,6 +1108,14 @@ type DalvikBytecodeOperationMoveWide16 = {
     operation: 'move-wide/16';
     registers: number[];
 };
+type DalvikBytecodeOperationMove16 = {
+    operation: 'move/16';
+    registers: number[];
+};
+type DalvikBytecodeOperationMoveObject16 = {
+    operation: 'move-object/16';
+    registers: number[];
+};
 declare const dalvikBytecodeOperationReturnParser: Parser<{
     operation: "return";
     registers: number[];
@@ -1174,14 +1202,14 @@ declare const dalvikBytecodeOperationCompareLongParser: Parser<{
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationCompareLong = Awaited<ReturnType<typeof dalvikBytecodeOperationCompareLongParser>>;
 type DalvikBytecodeOperationCompare = DalvikBytecodeOperationCompareFloatWithLessThanBias | DalvikBytecodeOperationCompareFloatWithGreaterThanBias | DalvikBytecodeOperationCompareDoubleWithLessThanBias | DalvikBytecodeOperationCompareDoubleWithGreaterThanBias | DalvikBytecodeOperationCompareLong;
-export type DalvikBytecodeOperation = DalvikBytecodeOperationNoOperation | DalvikBytecodeOperationIfTest | DalvikBytecodeOperationIfTestZero | DalvikBytecodeOperationBinaryOperation | DalvikBytecodeOperationBinaryOperationLiteral8 | DalvikBytecodeOperationBinaryOperationLiteral16 | DalvikBytecodeOperationBinaryOperationInPlace | DalvikBytecodeOperationUnaryOperation | DalvikBytecodeOperationGoto | DalvikBytecodeOperationGoto16 | DalvikBytecodeOperationGoto32 | DalvikBytecodeOperationPackedSwitch | DalvikBytecodeOperationPackedSwitchPayload | DalvikBytecodeOperationSparseSwitch | DalvikBytecodeOperationSparseSwitchPayload | DalvikBytecodeOperationNewArray | DalvikBytecodeOperationFilledNewArray | DalvikBytecodeOperationFilledNewArrayRange | DalvikBytecodeOperationFillArrayDataPayload | DalvikBytecodeOperationMoveResult1 | DalvikBytecodeOperationMove | DalvikBytecodeOperationMoveWide | DalvikBytecodeOperationMoveObject | DalvikBytecodeOperationMoveFrom16 | DalvikBytecodeOperationMoveWideFrom16 | DalvikBytecodeOperationMoveObjectFrom16 | DalvikBytecodeOperationMoveWide16 | DalvikBytecodeOperationInvoke | DalvikBytecodeOperationInvokeRange | DalvikBytecodeOperationInvokePolymorphic | DalvikBytecodeOperationInvokePolymorphicRange | DalvikBytecodeOperationNewInstance | DalvikBytecodeOperationFillArrayData | DalvikBytecodeOperationCheckCast | DalvikBytecodeOperationInstanceOf | DalvikBytecodeOperationArrayLength | DalvikBytecodeOperationArrayElement | DalvikBytecodeOperationInstanceField | DalvikBytecodeOperationStaticField | DalvikBytecodeOperationConst4 | DalvikBytecodeOperationConst16 | DalvikBytecodeOperationConstHigh16 | DalvikBytecodeOperationConstWide16 | DalvikBytecodeOperationConstWide32 | DalvikBytecodeOperationConstWide | DalvikBytecodeOperationConstWideHigh16 | DalvikBytecodeOperationConst | DalvikBytecodeOperationConstString | DalvikBytecodeOperationConstStringJumbo | DalvikBytecodeOperationConstMethodHandle | DalvikBytecodeOperationConstClass | DalvikBytecodeOperationMonitorEnter | DalvikBytecodeOperationMonitorExit | DalvikBytecodeOperationThrow | DalvikBytecodeOperationCompare | DalvikBytecodeOperationReturnVoid | DalvikBytecodeOperationReturn1;
-export declare const dalvikBytecodeOperationCompanion: {
-    getRegisters(operation: DalvikBytecodeOperation): number[];
+export type RawDalvikBytecodeOperation = DalvikBytecodeOperationNoOperation | DalvikBytecodeOperationIfTest | DalvikBytecodeOperationIfTestZero | DalvikBytecodeOperationBinaryOperation | DalvikBytecodeOperationBinaryOperationLiteral8 | DalvikBytecodeOperationBinaryOperationLiteral16 | DalvikBytecodeOperationBinaryOperationInPlace | DalvikBytecodeOperationUnaryOperation | DalvikBytecodeOperationGoto | DalvikBytecodeOperationGoto16 | DalvikBytecodeOperationGoto32 | DalvikBytecodeOperationPackedSwitch | DalvikBytecodeOperationPackedSwitchPayload | DalvikBytecodeOperationSparseSwitch | DalvikBytecodeOperationSparseSwitchPayload | DalvikBytecodeOperationNewArray | DalvikBytecodeOperationFilledNewArray | DalvikBytecodeOperationFilledNewArrayRange | DalvikBytecodeOperationFillArrayDataPayload | DalvikBytecodeOperationMoveResult1 | DalvikBytecodeOperationMove | DalvikBytecodeOperationMoveWide | DalvikBytecodeOperationMoveObject | DalvikBytecodeOperationMoveFrom16 | DalvikBytecodeOperationMove16 | DalvikBytecodeOperationMoveWideFrom16 | DalvikBytecodeOperationMoveObjectFrom16 | DalvikBytecodeOperationMoveWide16 | DalvikBytecodeOperationMoveObject16 | DalvikBytecodeOperationInvoke | DalvikBytecodeOperationInvokeRange | DalvikBytecodeOperationInvokePolymorphic | DalvikBytecodeOperationInvokePolymorphicRange | DalvikBytecodeOperationInvokeCustom | DalvikBytecodeOperationInvokeCustomRange | DalvikBytecodeOperationNewInstance | DalvikBytecodeOperationFillArrayData | DalvikBytecodeOperationCheckCast | DalvikBytecodeOperationInstanceOf | DalvikBytecodeOperationArrayLength | DalvikBytecodeOperationArrayElement | DalvikBytecodeOperationInstanceField | DalvikBytecodeOperationStaticField | DalvikBytecodeOperationConst4 | DalvikBytecodeOperationConst16 | DalvikBytecodeOperationConstHigh16 | DalvikBytecodeOperationConstWide16 | DalvikBytecodeOperationConstWide32 | DalvikBytecodeOperationConstWide | DalvikBytecodeOperationConstWideHigh16 | DalvikBytecodeOperationConst | DalvikBytecodeOperationConstString | DalvikBytecodeOperationConstStringJumbo | DalvikBytecodeOperationConstMethodHandle | DalvikBytecodeOperationConstMethodType | DalvikBytecodeOperationConstClass | DalvikBytecodeOperationMonitorEnter | DalvikBytecodeOperationMonitorExit | DalvikBytecodeOperationThrow | DalvikBytecodeOperationCompare | DalvikBytecodeOperationReturnVoid | DalvikBytecodeOperationReturn1;
+export declare const rawDalvikBytecodeOperationCompanion: {
+    getRegisters(operation: RawDalvikBytecodeOperation): number[];
 };
-export type DalvikBytecode = DalvikBytecodeOperation[];
-export declare const createDalvikBytecodeParser: (size: number) => Parser<DalvikBytecode, Uint8Array>;
-type ResolvedDalvikBytecodeOperation<T extends DalvikBytecodeOperation> = T extends {
-    stringIndex: IndexIntoFieldIds;
+export type RawDalvikBytecode = RawDalvikBytecodeOperation[];
+export declare const createRawDalvikBytecodeParser: (size: number) => Parser<RawDalvikBytecode, Uint8Array>;
+export type IndexResolvedOperation<T> = T extends {
+    stringIndex: IndexIntoStringIds;
 } ? Omit<T, 'stringIndex'> & {
     string: string;
 } : T extends {
@@ -1197,11 +1225,12 @@ type ResolvedDalvikBytecodeOperation<T extends DalvikBytecodeOperation> = T exte
 } ? Omit<T, 'fieldIndex'> & {
     field: DalvikExecutableField;
 } : T;
-export type DalvikBytecodeOperationResolvers = {
+type IndexResolvedRawDalvikBytecodeOperation<T extends RawDalvikBytecodeOperation> = IndexResolvedOperation<T>;
+export type RawDalvikBytecodeOperationResolvers = {
     resolveIndexIntoStringIds: (index: IndexIntoStringIds) => string;
     resolveIndexIntoTypeIds: (index: IndexIntoTypeIds) => string;
     resolveIndexIntoMethodIds: (index: IndexIntoMethodIds) => DalvikExecutableMethod;
     resolveIndexIntoFieldIds: (index: IndexIntoFieldIds) => DalvikExecutableField;
 };
-export declare function resolveDalvikBytecodeOperation<T extends DalvikBytecodeOperation>(operation: T, { resolveIndexIntoStringIds, resolveIndexIntoTypeIds, resolveIndexIntoMethodIds, resolveIndexIntoFieldIds, }: DalvikBytecodeOperationResolvers): ResolvedDalvikBytecodeOperation<T>;
+export declare function resolveRawDalvikBytecodeOperationIndices<T extends RawDalvikBytecodeOperation>(operation: T, { resolveIndexIntoStringIds, resolveIndexIntoTypeIds, resolveIndexIntoMethodIds, resolveIndexIntoFieldIds, }: RawDalvikBytecodeOperationResolvers): IndexResolvedRawDalvikBytecodeOperation<T>;
 export {};

package/build/dalvikBytecodeParser.js

@@ -1,15 +1,16 @@
 import { createArrayParser } from './arrayParser.js';
 import { createDalvikBytecodeFormat21cParser, createDalvikBytecodeFormat21sParser, createDalvikBytecodeFormat21tParser, createDalvikBytecodeFormat22bParser, createDalvikBytecodeFormat22cParser, createDalvikBytecodeFormat22sParser, createDalvikBytecodeFormat22tParser, dalvikBytecodeFormat23xParser, createDalvikBytecodeFormat31cParser, dalvikBytecodeFormat31iParser, dalvikBytecodeFormat31tParser, createDalvikBytecodeFormat35cParser, createDalvikBytecodeFormat3rcParser, dalvikBytecodeFormat10tParser, dalvikBytecodeFormat10xParser, dalvikBytecodeFormat11xParser, dalvikBytecodeFormat11nParser, dalvikBytecodeFormat12xParser, dalvikBytecodeFormat20tParser, dalvikBytecodeFormat22xParser, dalvikBytecodeFormat32xParser, dalvikBytecodeFormat30tParser, dalvikBytecodeFormat51lParser, createDalvikBytecodeFormat45ccParser, createDalvikBytecodeFormat4rccParser, } from './dalvikBytecodeParser/formatParsers.js';
 import { ubyteParser, ushortParser, intParser, uintParser, createExactUshortParser, } from './dalvikExecutableParser/typeParsers.js';
-import { isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoPrototypeIds, isoIndexIntoStringIds, isoIndexIntoTypeIds, } from './dalvikExecutableParser/typedNumbers.js';
+import { isoCodeUnit, isoIndexIntoCallSiteIds, isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoPrototypeIds, isoIndexIntoStringIds, isoIndexIntoTypeIds, } from './dalvikExecutableParser/typedNumbers.js';
 import { createExactElementParser } from './exactElementParser.js';
-import { createElementSwitchParser } from './exactElementSwitchParser.js';
+import { createElementSwitchParser } from './elementSwitchParser.js';
 import { setParserName } from './parser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createSliceBoundedParser } from './sliceBoundedParser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
 import { parserCreatorCompose } from './parserCreatorCompose.js';
 import { createQuantifierParser } from './quantifierParser.js';
+import { createObjectParser } from './objectParser.js';
 import { createTupleParser } from './tupleParser.js';
 // https://source.android.com/docs/core/runtime/dalvik-bytecode
 const dalvikBytecodeOperationUnusedParser = async (parserContext) => {
@@ -21,10 +22,10 @@ const dalvikBytecodeOperationUnusedParser = async (parserContext) => {
     parserContext.skip(1);
 };
 setParserName(dalvikBytecodeOperationUnusedParser, 'dalvikBytecodeOperationUnusedParser');
-const dalvikBytecodeOperationNoOperationParser = promiseCompose(createExactUshortParser(0x00_00), // nop is 2 bytes: 0x00 0x00
-() => ({
+const dalvikBytecodeOperationNoOperationParser = createObjectParser({
+    _opcode: createExactUshortParser(0x00_00), // nop is 2 bytes: 0x00 0x00
     operation: 'nop',
-}));
+});
 setParserName(dalvikBytecodeOperationNoOperationParser, 'dalvikBytecodeOperationNoOperationParser');
 const createDalvikBytecodeOperationInvoke = (operation, opcode) => promiseCompose(createTupleParser([
     createExactElementParser(opcode),
@@ -98,33 +99,55 @@ const dalvikBytecodeOperationInvokePolymorphicRangeParser = promiseCompose(creat
     registers,
 }));
 setParserName(dalvikBytecodeOperationInvokePolymorphicRangeParser, 'dalvikBytecodeOperationInvokePolymorphicRangeParser');
+const dalvikBytecodeOperationInvokeCustomParser = promiseCompose(createTupleParser([
+    createExactElementParser(0xFC),
+    createDalvikBytecodeFormat35cParser({
+        isoIndex: isoIndexIntoCallSiteIds,
+    }),
+]), ([_opcode, { index, registers },]) => ({
+    operation: 'invoke-custom',
+    callSiteIndex: index,
+    registers,
+}));
+setParserName(dalvikBytecodeOperationInvokeCustomParser, 'dalvikBytecodeOperationInvokeCustomParser');
+const dalvikBytecodeOperationInvokeCustomRangeParser = promiseCompose(createTupleParser([
+    createExactElementParser(0xFD),
+    createDalvikBytecodeFormat3rcParser({
+        isoIndex: isoIndexIntoCallSiteIds,
+    }),
+]), ([_opcode, { index, registers },]) => ({
+    operation: 'invoke-custom/range',
+    callSiteIndex: index,
+    registers,
+}));
+setParserName(dalvikBytecodeOperationInvokeCustomRangeParser, 'dalvikBytecodeOperationInvokeCustomRangeParser');
 const dalvikBytecodeOperationGotoParser = promiseCompose(createTupleParser([
     createExactElementParser(0x28),
     dalvikBytecodeFormat10tParser,
-]), ([_opcode, { branchOffset }]) => ({
+]), ([_opcode, { branchOffsetCodeUnit }]) => ({
     operation: 'goto',
-    branchOffset,
+    branchOffsetCodeUnit,
 }));
 const dalvikBytecodeOperationGoto16Parser = promiseCompose(createTupleParser([
     createExactElementParser(0x29),
     dalvikBytecodeFormat20tParser,
-]), ([_opcode, { branchOffset }]) => ({
+]), ([_opcode, { branchOffsetCodeUnit }]) => ({
     operation: 'goto/16',
-    branchOffset,
+    branchOffsetCodeUnit,
 }));
 const dalvikBytecodeOperationGoto32Parser = promiseCompose(createTupleParser([
     createExactElementParser(0x2A),
     dalvikBytecodeFormat30tParser,
-]), ([_opcode, { branchOffset }]) => ({
+]), ([_opcode, { branchOffsetCodeUnit }]) => ({
     operation: 'goto/32',
-    branchOffset,
+    branchOffsetCodeUnit,
 }));
 const dalvikBytecodeOperationPackedSwitchParser = promiseCompose(createTupleParser([
     createExactElementParser(0x2B),
     dalvikBytecodeFormat31tParser,
-]), ([_opcode, { branchOffset, registers }]) => ({
+]), ([_opcode, { branchOffsetCodeUnit, registers }]) => ({
     operation: 'packed-switch',
-    branchOffset,
+    branchOffsetCodeUnit,
     registers,
 }));
 setParserName(dalvikBytecodeOperationPackedSwitchParser, 'dalvikBytecodeOperationPackedSwitchParser');
@@ -138,15 +161,15 @@ const dalvikBytecodeOperationPackedSwitchPayloadParser = parserCreatorCompose(()
 })), ({ size, value }) => promiseCompose(createQuantifierParser(intParser, size), branchOffsets => ({
     operation: 'packed-switch-payload',
     value,
-    branchOffsets,
+    branchOffsetsCodeUnit: branchOffsets.map(isoCodeUnit.wrap),
 })))();
 setParserName(dalvikBytecodeOperationPackedSwitchPayloadParser, 'dalvikBytecodeOperationPackedSwitchPayloadParser');
 const dalvikBytecodeOperationSparseSwitchParser = promiseCompose(createTupleParser([
     createExactElementParser(0x2C),
     dalvikBytecodeFormat31tParser,
-]), ([_opcode, { branchOffset, registers }]) => ({
+]), ([_opcode, { branchOffsetCodeUnit, registers }]) => ({
     operation: 'sparse-switch',
-    branchOffset,
+    branchOffsetCodeUnit,
     registers,
 }));
 setParserName(dalvikBytecodeOperationSparseSwitchParser, 'dalvikBytecodeOperationSparseSwitchParser');
@@ -161,7 +184,7 @@ const dalvikBytecodeOperationSparseSwitchPayloadParser = parserCreatorCompose(()
 ]), ([keys, branchOffsets]) => ({
     operation: 'sparse-switch-payload',
     keys,
-    branchOffsets,
+    branchOffsetsCodeUnit: branchOffsets.map(isoCodeUnit.wrap),
 })))();
 setParserName(dalvikBytecodeOperationSparseSwitchPayloadParser, 'dalvikBytecodeOperationSparseSwitchPayloadParser');
 const dalvikBytecodeOperationFillArrayDataPayloadParser = parserCreatorCompose(() => promiseCompose(createTupleParser([
@@ -482,6 +505,7 @@ const dalvikBytecodeOperationAddFloatParser = createDalvikBytecodeOperationBinar
 const dalvikBytecodeOperationSubtractFloatParser = createDalvikBytecodeOperationBinaryOperation('sub-float', 0xA7);
 const dalvikBytecodeOperationMultiplyFloatParser = createDalvikBytecodeOperationBinaryOperation('mul-float', 0xA8);
 const dalvikBytecodeOperationDivideFloatParser = createDalvikBytecodeOperationBinaryOperation('div-float', 0xA9);
+const dalvikBytecodeOperationRemainderFloatParser = createDalvikBytecodeOperationBinaryOperation('rem-float', 0xAA);
 const dalvikBytecodeOperationAddDoubleParser = createDalvikBytecodeOperationBinaryOperation('add-double', 0xAB);
 const dalvikBytecodeOperationSubtractDoubleParser = createDalvikBytecodeOperationBinaryOperation('sub-double', 0xAC);
 const dalvikBytecodeOperationMultiplyDoubleParser = createDalvikBytecodeOperationBinaryOperation('mul-double', 0xAD);
@@ -514,6 +538,7 @@ const dalvikBytecodeOperationBinaryOperationParser = createDisjunctionParser([
     dalvikBytecodeOperationSubtractFloatParser,
     dalvikBytecodeOperationMultiplyFloatParser,
     dalvikBytecodeOperationDivideFloatParser,
+    dalvikBytecodeOperationRemainderFloatParser,
     dalvikBytecodeOperationAddDoubleParser,
     dalvikBytecodeOperationSubtractDoubleParser,
     dalvikBytecodeOperationMultiplyDoubleParser,
@@ -577,19 +602,19 @@ setParserName(dalvikBytecodeOperationUnaryOperationParser, 'dalvikBytecodeOperat
 const createDalvikBytecodeOperationIfTestCommutative = (operation, opcode) => promiseCompose(createTupleParser([
     createExactElementParser(opcode),
     createDalvikBytecodeFormat22tParser(),
-]), ([_opcode, { registers, branchOffset }]) => ({
+]), ([_opcode, { registers, branchOffsetCodeUnit }]) => ({
     operation,
     registers: registers.sort((a, b) => a - b),
-    branchOffset,
+    branchOffsetCodeUnit,
 }));
 // For non-commutative comparison operations (if-lt, if-ge, if-gt, if-le), reverse to get correct semantic order
 const createDalvikBytecodeOperationIfTest = (operation, opcode) => promiseCompose(createTupleParser([
     createExactElementParser(opcode),
     createDalvikBytecodeFormat22tParser(),
-]), ([_opcode, { registers, branchOffset }]) => ({
+]), ([_opcode, { registers, branchOffsetCodeUnit }]) => ({
     operation,
     registers: registers.reverse(),
-    branchOffset,
+    branchOffsetCodeUnit,
 }));
 const dalvikBytecodeIfEqualParser = createDalvikBytecodeOperationIfTestCommutative('if-eq', 0x32);
 const dalvikBytecodeIfNotEqualParser = createDalvikBytecodeOperationIfTestCommutative('if-ne', 0x33);
@@ -609,10 +634,10 @@ setParserName(dalvikBytecodeOperationIfTestParser, 'dalvikBytecodeOperationIfTes
 const createDalvikBytecodeOperationIfTestZero = (operation, opcode) => promiseCompose(createTupleParser([
     createExactElementParser(opcode),
     createDalvikBytecodeFormat21tParser(),
-]), ([_opcode, { registers, branchOffset }]) => ({
+]), ([_opcode, { registers, branchOffsetCodeUnit }]) => ({
     operation,
     registers,
-    branchOffset,
+    branchOffsetCodeUnit,
 }));
 const dalvikBytecodeIfEqualZeroParser = createDalvikBytecodeOperationIfTestZero('if-eqz', 0x38);
 const dalvikBytecodeIfNotEqualZeroParser = createDalvikBytecodeOperationIfTestZero('if-nez', 0x39);
@@ -662,6 +687,17 @@ const dalvikBytecodeOperationConstMethodHandleParser = promiseCompose(createTupl
     registers,
 }));
 setParserName(dalvikBytecodeOperationConstMethodHandleParser, 'dalvikBytecodeOperationConstMethodHandleParser');
+const dalvikBytecodeOperationConstMethodTypeParser = promiseCompose(createTupleParser([
+    createExactElementParser(0xFF),
+    createDalvikBytecodeFormat21cParser({
+        isoIndex: isoIndexIntoPrototypeIds,
+    }),
+]), ([_opcode, { index, registers }]) => ({
+    operation: 'const-method-type',
+    protoIndex: index,
+    registers,
+}));
+setParserName(dalvikBytecodeOperationConstMethodTypeParser, 'dalvikBytecodeOperationConstMethodTypeParser');
 const dalvikBytecodeOperationNewInstanceParser = promiseCompose(createTupleParser([
     createExactElementParser(0x22),
     createDalvikBytecodeFormat21cParser({
@@ -709,9 +745,9 @@ setParserName(dalvikBytecodeOperationFilledNewArrayRangeParser, 'dalvikBytecodeO
 const dalvikBytecodeOperationFillArrayDataParser = promiseCompose(createTupleParser([
     createExactElementParser(0x26),
     dalvikBytecodeFormat31tParser,
-]), ([_opcode, { branchOffset, registers }]) => ({
+]), ([_opcode, { branchOffsetCodeUnit, registers }]) => ({
     operation: 'fill-array-data',
-    branchOffset,
+    branchOffsetCodeUnit,
     registers,
 }));
 setParserName(dalvikBytecodeOperationFillArrayDataParser, 'dalvikBytecodeOperationFillArrayDataParser');
@@ -761,12 +797,11 @@ const dalvikBytecodeOperationMonitorExitParser = promiseCompose(createTupleParse
     registers,
 }));
 setParserName(dalvikBytecodeOperationMonitorExitParser, 'dalvikBytecodeOperationMonitorExitParser');
-const dalvikBytecodeOperationReturnVoidParser = promiseCompose(createTupleParser([
-    createExactElementParser(0x0E),
-    dalvikBytecodeFormat10xParser,
-]), () => ({
+const dalvikBytecodeOperationReturnVoidParser = createObjectParser({
+    _opcode: createExactElementParser(0x0E),
+    _format: dalvikBytecodeFormat10xParser,
     operation: 'return-void',
-}));
+});
 setParserName(dalvikBytecodeOperationReturnVoidParser, 'dalvikBytecodeOperationReturnVoidParser');
 const createDalvikBytecodeMoveResult1Parser = (operation, opcode) => promiseCompose(createTupleParser([
     createExactElementParser(opcode),
@@ -839,6 +874,22 @@ const dalvikBytecodeOperationMoveWide16Parser = promiseCompose(createTupleParser
     registers,
 }));
 setParserName(dalvikBytecodeOperationMoveWide16Parser, 'dalvikBytecodeOperationMoveWide16Parser');
+const dalvikBytecodeOperationMove16Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x03),
+    dalvikBytecodeFormat32xParser,
+]), ([_opcode, { registers }]) => ({
+    operation: 'move/16',
+    registers,
+}));
+setParserName(dalvikBytecodeOperationMove16Parser, 'dalvikBytecodeOperationMove16Parser');
+const dalvikBytecodeOperationMoveObject16Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x09),
+    dalvikBytecodeFormat32xParser,
+]), ([_opcode, { registers }]) => ({
+    operation: 'move-object/16',
+    registers,
+}));
+setParserName(dalvikBytecodeOperationMoveObject16Parser, 'dalvikBytecodeOperationMoveObject16Parser');
 const createDalvikBytecodeOperationReturn1Parser = createDalvikBytecodeMoveResult1Parser;
 const dalvikBytecodeOperationReturnParser = createDalvikBytecodeOperationReturn1Parser('return', 0x0F);
 const dalvikBytecodeOperationReturnWideParser = createDalvikBytecodeOperationReturn1Parser('return-wide', 0x10);
@@ -949,7 +1000,7 @@ const dalvikBytecodeOperationCompareParser = createDisjunctionParser([
     dalvikBytecodeOperationCompareLongParser,
 ]);
 setParserName(dalvikBytecodeOperationCompareParser, 'dalvikBytecodeOperationCompareParser');
-export const dalvikBytecodeOperationCompanion = {
+export const rawDalvikBytecodeOperationCompanion = {
     getRegisters(operation) {
         if (operation && typeof operation === 'object' && 'registers' in operation) {
             return operation.registers;
@@ -974,6 +1025,9 @@ const dalvikBytecodeOperationOpcodeMap = new Map([
     // Invoke polymorphic operations
     [0xFA, dalvikBytecodeOperationInvokePolymorphicParser],
     [0xFB, dalvikBytecodeOperationInvokePolymorphicRangeParser],
+    // Invoke custom operations
+    [0xFC, dalvikBytecodeOperationInvokeCustomParser],
+    [0xFD, dalvikBytecodeOperationInvokeCustomRangeParser],
     // New instance/array operations
     [0x22, dalvikBytecodeOperationNewInstanceParser],
     [0x23, dalvikBytecodeOperationNewArrayParser],
@@ -1032,6 +1086,7 @@ const dalvikBytecodeOperationOpcodeMap = new Map([
     [0x1A, dalvikBytecodeOperationConstStringParser],
     [0x1B, dalvikBytecodeOperationConstStringJumboParser],
     [0xFE, dalvikBytecodeOperationConstMethodHandleParser],
+    [0xFF, dalvikBytecodeOperationConstMethodTypeParser],
     [0x1C, dalvikBytecodeOperationConstClassParser],
     // Monitor operations
     [0x1D, dalvikBytecodeOperationMonitorEnterParser],
@@ -1062,6 +1117,8 @@ const dalvikBytecodeOperationOpcodeMap = new Map([
     [0x05, dalvikBytecodeOperationMoveWideFrom16Parser],
     [0x08, dalvikBytecodeOperationMoveObjectFrom16Parser],
     [0x06, dalvikBytecodeOperationMoveWide16Parser],
+    [0x03, dalvikBytecodeOperationMove16Parser],
+    [0x09, dalvikBytecodeOperationMoveObject16Parser],
     // Const value operations
     [0x12, dalvikBytecodeOperationConst4Parser],
     [0x13, dalvikBytecodeOperationConst16Parser],
@@ -1118,7 +1175,7 @@ const dalvikBytecodeOperationOpcodeMap = new Map([
     [0xA7, dalvikBytecodeOperationSubtractFloatParser],
     [0xA8, dalvikBytecodeOperationMultiplyFloatParser],
     [0xA9, dalvikBytecodeOperationDivideFloatParser],
-    // Note: 0xAA (rem-float) parser is missing in codebase
+    [0xAA, dalvikBytecodeOperationRemainderFloatParser],
     [0xAB, dalvikBytecodeOperationAddDoubleParser],
     [0xAC, dalvikBytecodeOperationSubtractDoubleParser],
     [0xAD, dalvikBytecodeOperationMultiplyDoubleParser],
@@ -1254,9 +1311,9 @@ const dalvikBytecodeOperationParser = promiseCompose(createTupleParser([
 // Console.log(operation);
 operation);
 setParserName(dalvikBytecodeOperationParser, 'dalvikBytecodeOperationParser');
-const dalvikBytecodeParser = promiseCompose(createArrayParser(dalvikBytecodeOperationParser), operations => operations.filter((operation) => operation !== undefined));
-export const createDalvikBytecodeParser = (size) => createSliceBoundedParser(dalvikBytecodeParser, size, true);
-export function resolveDalvikBytecodeOperation(operation, { resolveIndexIntoStringIds, resolveIndexIntoTypeIds, resolveIndexIntoMethodIds, resolveIndexIntoFieldIds, }) {
+const rawDalvikBytecodeParser = promiseCompose(createArrayParser(dalvikBytecodeOperationParser), operations => operations.filter((operation) => operation !== undefined));
+export const createRawDalvikBytecodeParser = (size) => createSliceBoundedParser(rawDalvikBytecodeParser, size, true);
+export function resolveRawDalvikBytecodeOperationIndices(operation, { resolveIndexIntoStringIds, resolveIndexIntoTypeIds, resolveIndexIntoMethodIds, resolveIndexIntoFieldIds, }) {
     if (operation && typeof operation === 'object' && 'stringIndex' in operation) {
         const { stringIndex, ...rest } = operation;
         return {

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

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