@futpib/parser 1.0.2 → 1.0.4

package/src/dalvikExecutable.ts

@@ -1,27 +1,70 @@
 
 export type DalvikExecutableAccessFlags = {
-	public: boolean,
-	private: boolean,
-	protected: boolean,
-	static: boolean,
-	final: boolean,
-	synchronized: boolean,
-	volatile: boolean,
-	bridge: boolean,
-	transient: boolean,
-	varargs: boolean,
-	native: boolean,
-	interface: boolean,
-	abstract: boolean,
-	strict: boolean,
-	synthetic: boolean,
-	annotation: boolean,
-	enum: boolean,
-	constructor: boolean,
-	declaredSynchronized: boolean,
-};
-
-export type DalvikExecutableEncodedValue = number | DalvikExecutableEncodedValue[] | undefined;
+	public: boolean;
+	private: boolean;
+	protected: boolean;
+	static: boolean;
+	final: boolean;
+	synchronized: boolean;
+	volatile: boolean;
+	bridge: boolean;
+	transient: boolean;
+	varargs: boolean;
+	native: boolean;
+	interface: boolean;
+	abstract: boolean;
+	strict: boolean;
+	synthetic: boolean;
+	annotation: boolean;
+	enum: boolean;
+	constructor: boolean;
+	declaredSynchronized: boolean;
+};
+
+export function dalvikExecutableAccessFlagsDefault(): DalvikExecutableAccessFlags {
+	return {
+		public: false,
+		private: false,
+		protected: false,
+		static: false,
+		final: false,
+		synchronized: false,
+		volatile: false,
+		bridge: false,
+		transient: false,
+		varargs: false,
+		native: false,
+		interface: false,
+		abstract: false,
+		strict: false,
+		synthetic: false,
+		annotation: false,
+		enum: false,
+		constructor: false,
+		declaredSynchronized: false,
+	};
+}
+
+export type DalvikExecutableEncodedValue =
+	| { type: 'byte'; value: number }
+	| { type: 'short'; value: number }
+	| { type: 'char'; value: number }
+	| { type: 'int'; value: number }
+	| { type: 'long'; value: bigint }
+	| { type: 'float'; value: number }
+	| { type: 'double'; value: number }
+	| { type: 'methodType'; value: DalvikExecutablePrototype }
+	| { type: 'methodHandle'; value: number }
+	| { type: 'string'; value: string }
+	| { type: 'type'; value: string }
+	| { type: 'field'; value: DalvikExecutableField }
+	| { type: 'method'; value: DalvikExecutableMethod }
+	| { type: 'enum'; value: DalvikExecutableField }
+	| { type: 'array'; value: DalvikExecutableEncodedValue[] }
+	| { type: 'annotation'; value: DalvikExecutableAnnotation }
+	// eslint-disable-next-line @typescript-eslint/no-restricted-types
+	| { type: 'null'; value: null }
+	| { type: 'boolean'; value: boolean };
 
 type DalvikExecutableTry = {
 	startAddress: number;
@@ -35,8 +78,8 @@ type DalvikExecutableEncodedTypeAddressPair = {
 };
 
 type DalvikExecutableEncodedCatchHandler = {
-	handlers: DalvikExecutableEncodedTypeAddressPair[],
-	catchAllAddress: undefined | number,
+	handlers: DalvikExecutableEncodedTypeAddressPair[];
+	catchAllAddress: undefined | number;
 };
 
 export type DalvikExecutableCode<Instructions> = {
@@ -98,7 +141,7 @@ type DalvikExecutableDebugByteCode = DalvikExecutableDebugByteCodeValue[];
 
 export type DalvikExecutableDebugInfo = {
 	lineStart: number;
-	parameterNames: (undefined | string)[];
+	parameterNames: Array<undefined | string>;
 	bytecode: DalvikExecutableDebugByteCode;
 };
 
@@ -117,7 +160,7 @@ export type DalvikExecutableAnnotation = {
 	visibility: DalvikExecutableAnnotationItemVisibility;
 	type: string;
 	elements: DalvikExecutableAnnotationElement[];
-}
+};
 
 export type DalvikExecutablePrototype = {
 	shorty: string;
@@ -134,13 +177,21 @@ export type DalvikExecutableField = {
 export function isDalvikExecutableField(x: unknown): x is DalvikExecutableField {
 	return (
 		x !== null
-			&& typeof x === 'object'
-			&& 'class' in x
-			&& 'type' in x
-			&& 'name' in x
-			&& typeof (x as DalvikExecutableField).class === 'string'
-			&& typeof (x as DalvikExecutableField).type === 'string'
-			&& typeof (x as DalvikExecutableField).name === 'string'
+		&& typeof x === 'object'
+		&& 'class' in x
+		&& 'type' in x
+		&& 'name' in x
+		&& typeof (x as DalvikExecutableField).class === 'string'
+		&& typeof (x as DalvikExecutableField).type === 'string'
+		&& typeof (x as DalvikExecutableField).name === 'string'
+	);
+}
+
+export function dalvikExecutableFieldEquals(a: DalvikExecutableField, b: DalvikExecutableField): boolean {
+	return (
+		a.class === b.class
+		&& a.type === b.type
+		&& a.name === b.name
 	);
 }
 
@@ -158,13 +209,24 @@ export type DalvikExecutableMethod = {
 export function isDalvikExecutableMethod(x: unknown): x is DalvikExecutableMethod {
 	return (
 		x !== null
-			&& typeof x === 'object'
-			&& 'class' in x
-			&& 'prototype' in x
-			&& 'name' in x
-			&& typeof (x as DalvikExecutableMethod).class === 'string'
-			&& typeof (x as DalvikExecutableMethod).prototype === 'object'
-			&& typeof (x as DalvikExecutableMethod).name === 'string'
+		&& typeof x === 'object'
+		&& 'class' in x
+		&& 'prototype' in x
+		&& 'name' in x
+		&& typeof (x as DalvikExecutableMethod).class === 'string'
+		&& typeof (x as DalvikExecutableMethod).prototype === 'object'
+		&& typeof (x as DalvikExecutableMethod).name === 'string'
+	);
+}
+
+export function dalvikExecutableMethodEquals(a: DalvikExecutableMethod, b: DalvikExecutableMethod): boolean {
+	return (
+		a.class === b.class
+		&& a.name === b.name
+		&& a.prototype.shorty === b.prototype.shorty
+		&& a.prototype.returnType === b.prototype.returnType
+		&& a.prototype.parameters.length === b.prototype.parameters.length
+		&& a.prototype.parameters.every((v, i) => v === b.prototype.parameters[i])
 	);
 }
 
@@ -181,16 +243,16 @@ export type DalvikExecutableClassFieldAnnotation = {
 
 export type DalvikExecutableClassMethodAnnotation = {
 	method: DalvikExecutableMethod;
-	annotations: undefined | DalvikExecutableAnnotation[];
+	annotations: DalvikExecutableAnnotation[];
 };
 
 export type DalvikExecutableClassParameterAnnotation = {
 	method: DalvikExecutableMethod;
-	annotations: undefined | (undefined | DalvikExecutableAnnotation[])[];
+	annotations: DalvikExecutableAnnotation[][];
 };
 
 export type DalvikExecutableClassAnnotations = {
-	classAnnotations: undefined | DalvikExecutableAnnotation[];
+	classAnnotations: DalvikExecutableAnnotation[];
 	fieldAnnotations: DalvikExecutableClassFieldAnnotation[];
 	methodAnnotations: DalvikExecutableClassMethodAnnotation[];
 	parameterAnnotations: DalvikExecutableClassParameterAnnotation[];
@@ -199,13 +261,13 @@ export type DalvikExecutableClassAnnotations = {
 export type DalvikExecutableClassData<Instructions> = {
 	staticFields: DalvikExecutableFieldWithAccess[];
 	instanceFields: DalvikExecutableFieldWithAccess[];
-	directMethods: DalvikExecutableMethodWithAccess<Instructions>[];
-	virtualMethods: DalvikExecutableMethodWithAccess<Instructions>[];
+	directMethods: Array<DalvikExecutableMethodWithAccess<Instructions>>;
+	virtualMethods: Array<DalvikExecutableMethodWithAccess<Instructions>>;
 };
 
 export type DalvikExecutableClassDefinition<Instructions> = {
 	class: string;
-	accessFlags: DalvikExecutableAccessFlags,
+	accessFlags: DalvikExecutableAccessFlags;
 	superclass: string;
 	interfaces: string[];
 	sourceFile: undefined | string;
@@ -215,6 +277,6 @@ export type DalvikExecutableClassDefinition<Instructions> = {
 };
 
 export type DalvikExecutable<Instructions> = {
-	classDefinitions: DalvikExecutableClassDefinition<Instructions>[];
-	link: undefined | Uint8Array,
+	classDefinitions: Array<DalvikExecutableClassDefinition<Instructions>>;
+	link: undefined | Uint8Array;
 };

package/src/dalvikExecutableParser/stringSyntaxParser.ts

@@ -1,12 +1,12 @@
-import invariant from "invariant";
-import { Parser, setParserName } from "../parser.js";
-import { ParserContext } from "../parserContext.js";
-import { promiseCompose } from "../promiseCompose.js";
-import { createSeparatedArrayParser } from "../separatedArrayParser.js";
-import { createExactSequenceParser } from "../exactSequenceParser.js";
-import { createUnionParser } from "../unionParser.js";
-import { createTupleParser } from "../tupleParser.js";
-import { createArrayParser } from "../arrayParser.js";
+import invariant from 'invariant';
+import { type Parser, setParserName } from '../parser.js';
+import { type ParserContext } from '../parserContext.js';
+import { promiseCompose } from '../promiseCompose.js';
+import { createSeparatedArrayParser } from '../separatedArrayParser.js';
+import { createExactSequenceParser } from '../exactSequenceParser.js';
+import { createUnionParser } from '../unionParser.js';
+import { createTupleParser } from '../tupleParser.js';
+import { createArrayParser } from '../arrayParser.js';
 
 export const smaliSimpleNameParser: Parser<string, string> = async (parserContext: ParserContext<string, string>) => {
 	const characters: string[] = [];
@@ -22,47 +22,47 @@ export const smaliSimpleNameParser: Parser<string, string> = async (parserContex
 			(
 				character >= 'a' && character <= 'z'
 			)
-				|| (
-					character >= 'A' && character <= 'Z'
-				)
-				|| (
-					character >= '0' && character <= '9'
-				)
-				|| (
-					character === ' '
-				)
-				|| (
-					character === '$'
-				)
-				|| (
-					character === '-'
-				)
+			|| (
+				character >= 'A' && character <= 'Z'
+			)
+			|| (
+				character >= '0' && character <= '9'
+			)
+			|| (
+				character === ' '
+			)
+			|| (
+				character === '$'
+			)
+			|| (
+				character === '-'
+			)
 				|| (
 					character === '_'
 				)
 				|| (
-					character === '\u00a0'
+					character === '\u00A0'
 				)
 				|| (
-					character >= '\u00a1' && character <= '\u1fff'
+					character >= '\u00A1' && character <= '\u1FFF'
 				)
 				|| (
-					character >= '\u2000' && character <= '\u200a'
+					character >= '\u2000' && character <= '\u200A'
 				)
 				|| (
 					character >= '\u2010' && character <= '\u2027'
 				)
 				|| (
-					character === '\u202f'
+					character === '\u202F'
 				)
 				|| (
-					character >= '\u2030' && character <= '\ud7ff'
+					character >= '\u2030' && character <= '\uD7FF'
 				)
 				|| (
-					character >= '\ue000' && character <= '\uffef'
+					character >= '\uE000' && character <= '\uFFEF'
 				)
 				|| (
-					character >= '\ud800' && character <= '\udbff'
+					character >= '\uD800' && character <= '\uDBFF'
 				)
 		) {
 			parserContext.skip(1);
@@ -90,7 +90,7 @@ export const smaliMemberNameParser: Parser<string, string> = createUnionParser([
 			smaliSimpleNameParser,
 			createExactSequenceParser('>'),
 		]),
-		(strings) => strings.join(''),
+		strings => strings.join(''),
 	),
 ]);
 
@@ -101,7 +101,7 @@ const smaliFullClassNameParser: Parser<string, string> = promiseCompose(
 		smaliMemberNameParser,
 		createExactSequenceParser('/'),
 	),
-	(pathSegments) => pathSegments.join('/'),
+	pathSegments => pathSegments.join('/'),
 );
 
 setParserName(smaliFullClassNameParser, 'smaliFullClassNameParser');

package/src/dalvikExecutableParser/typeParsers.ts

@@ -1,24 +1,25 @@
-import { createElementParser } from "../elementParser.js";
-import { createFixedLengthSequenceParser } from "../fixedLengthSequenceParser.js";
-import { uleb128NumberParser } from "../leb128Parser.js";
-import { Parser } from "../parser.js";
-import { promiseCompose } from "../promiseCompose.js";
+import { createElementParser } from '../elementParser.js';
+import { createFixedLengthSequenceParser } from '../fixedLengthSequenceParser.js';
+import { uleb128NumberParser } from '../leb128Parser.js';
+import { type Parser } from '../parser.js';
+import { parserCreatorCompose } from '../parserCreatorCompose.js';
+import { promiseCompose } from '../promiseCompose.js';
 
-export const uleb128p1NumberParser: Parser<number, Uint8Array> = async (parserContext) => {
+export const uleb128p1NumberParser: Parser<number, Uint8Array> = async parserContext => {
 	const value = await uleb128NumberParser(parserContext);
 	return value - 1;
-}
+};
 
 export const ubyteParser: Parser<number, Uint8Array> = createElementParser();
 
 export const byteParser: Parser<number, Uint8Array> = promiseCompose(
 	ubyteParser,
-	(ubyte) => ubyte > 127 ? ubyte - 256 : ubyte,
+	ubyte => ubyte > 127 ? ubyte - 256 : ubyte,
 );
 
 export const shortParser: Parser<number, Uint8Array> = promiseCompose(
 	createFixedLengthSequenceParser<Uint8Array>(2),
-	(uint8Array) => {
+	uint8Array => {
 		const buffer = Buffer.from(uint8Array);
 		return buffer.readInt16LE(0);
 	},
@@ -26,15 +27,23 @@ export const shortParser: Parser<number, Uint8Array> = promiseCompose(
 
 export const ushortParser: Parser<number, Uint8Array> = promiseCompose(
 	createFixedLengthSequenceParser<Uint8Array>(2),
-	(uint8Array) => {
+	uint8Array => {
 		const buffer = Buffer.from(uint8Array);
 		return buffer.readUInt16LE(0);
 	},
 );
 
+export const createExactUshortParser = (expectedValue: number): Parser<number, Uint8Array> => parserCreatorCompose(
+	() => ushortParser,
+	ushortValue => async parserContext => {
+		parserContext.invariant(ushortValue === expectedValue, `Expected ushort value ${expectedValue}, got ${ushortValue}`);
+		return ushortValue;
+	},
+)();
+
 export const intParser: Parser<number, Uint8Array> = promiseCompose(
 	createFixedLengthSequenceParser<Uint8Array>(4),
-	(uint8Array) => {
+	uint8Array => {
 		const buffer = Buffer.from(uint8Array);
 		return buffer.readInt32LE(0);
 	},
@@ -42,7 +51,7 @@ export const intParser: Parser<number, Uint8Array> = promiseCompose(
 
 export const uintParser: Parser<number, Uint8Array> = promiseCompose(
 	createFixedLengthSequenceParser<Uint8Array>(4),
-	(uint8Array) => {
+	uint8Array => {
 		const buffer = Buffer.from(uint8Array);
 		return buffer.readUInt32LE(0);
 	},
@@ -50,7 +59,7 @@ export const uintParser: Parser<number, Uint8Array> = promiseCompose(
 
 export const longParser: Parser<bigint, Uint8Array> = promiseCompose(
 	createFixedLengthSequenceParser<Uint8Array>(8),
-	(uint8Array) => {
+	uint8Array => {
 		const buffer = Buffer.from(uint8Array);
 		return buffer.readBigInt64LE(0);
 	},
@@ -58,7 +67,7 @@ export const longParser: Parser<bigint, Uint8Array> = promiseCompose(
 
 export const ulongParser: Parser<bigint, Uint8Array> = promiseCompose(
 	createFixedLengthSequenceParser<Uint8Array>(8),
-	(uint8Array) => {
+	uint8Array => {
 		const buffer = Buffer.from(uint8Array);
 		return buffer.readBigUInt64LE(0);
 	},

package/src/dalvikExecutableParser/typedNumbers.ts

@@ -1,57 +1,57 @@
-import { Newtype, iso } from 'newtype-ts';
+import { type Newtype, iso } from 'newtype-ts';
 
-export interface IndexIntoStringIds extends Newtype<{ readonly IndexIntoStringIds: unique symbol }, number> {}
+export type IndexIntoStringIds = {} & Newtype<{ readonly IndexIntoStringIds: unique symbol }, number>;
 export const isoIndexIntoStringIds = iso<IndexIntoStringIds>();
 
-export interface IndexIntoTypeIds extends Newtype<{ readonly IndexIntoTypeIds: unique symbol }, number> {}
+export type IndexIntoTypeIds = {} & Newtype<{ readonly IndexIntoTypeIds: unique symbol }, number>;
 export const isoIndexIntoTypeIds = iso<IndexIntoTypeIds>();
 
-export interface IndexIntoPrototypeIds extends Newtype<{ readonly IndexIntoPrototypeIds: unique symbol }, number> {}
+export type IndexIntoPrototypeIds = {} & Newtype<{ readonly IndexIntoPrototypeIds: unique symbol }, number>;
 export const isoIndexIntoPrototypeIds = iso<IndexIntoPrototypeIds>();
 
-export interface IndexIntoFieldIds extends Newtype<{ readonly IndexIntoFieldIds: unique symbol }, number> {}
+export type IndexIntoFieldIds = {} & Newtype<{ readonly IndexIntoFieldIds: unique symbol }, number>;
 export const isoIndexIntoFieldIds = iso<IndexIntoFieldIds>();
 
-export interface IndexIntoMethodIds extends Newtype<{ readonly IndexIntoMethodIds: unique symbol }, number> {}
+export type IndexIntoMethodIds = {} & Newtype<{ readonly IndexIntoMethodIds: unique symbol }, number>;
 export const isoIndexIntoMethodIds = iso<IndexIntoMethodIds>();
 
-export interface OffsetToStringDataItem extends Newtype<{ readonly OffsetToStringDataItem: unique symbol }, number> {}
+export type OffsetToStringDataItem = {} & Newtype<{ readonly OffsetToStringDataItem: unique symbol }, number>;
 export const isoOffsetToStringDataItem = iso<OffsetToStringDataItem>();
 
-export interface OffsetToTypeList extends Newtype<{ readonly OffsetToTypeList: unique symbol }, number> {}
+export type OffsetToTypeList = {} & Newtype<{ readonly OffsetToTypeList: unique symbol }, number>;
 export const isoOffsetToTypeList = iso<OffsetToTypeList>();
 
-export interface OffsetToAnnotationsDirectoryItem extends Newtype<{ readonly OffsetToAnnotationsDirectoryItem: unique symbol }, number> {}
+export type OffsetToAnnotationsDirectoryItem = {} & Newtype<{ readonly OffsetToAnnotationsDirectoryItem: unique symbol }, number>;
 export const isoOffsetToAnnotationsDirectoryItem = iso<OffsetToAnnotationsDirectoryItem>();
 
-export interface OffsetToAnnotationSetItem extends Newtype<{ readonly OffsetToAnnotationSetItem: unique symbol }, number> {}
+export type OffsetToAnnotationSetItem = {} & Newtype<{ readonly OffsetToAnnotationSetItem: unique symbol }, number>;
 export const isoOffsetToAnnotationSetItem = iso<OffsetToAnnotationSetItem>();
 
-export interface OffsetToAnnotationSetRefListItem extends Newtype<{ readonly OffsetToAnnotationSetRefListItem: unique symbol }, number> {}
+export type OffsetToAnnotationSetRefListItem = {} & Newtype<{ readonly OffsetToAnnotationSetRefListItem: unique symbol }, number>;
 export const isoOffsetToAnnotationSetRefListItem = iso<OffsetToAnnotationSetRefListItem>();
 
-export interface OffsetToClassDataItem extends Newtype<{ readonly OffsetToClassDataItem: unique symbol }, number> {}
+export type OffsetToClassDataItem = {} & Newtype<{ readonly OffsetToClassDataItem: unique symbol }, number>;
 export const isoOffsetToClassDataItem = iso<OffsetToClassDataItem>();
 
-export interface OffsetToEncodedArrayItem extends Newtype<{ readonly OffsetToEncodedArrayItem: unique symbol }, number> {}
+export type OffsetToEncodedArrayItem = {} & Newtype<{ readonly OffsetToEncodedArrayItem: unique symbol }, number>;
 export const isoOffsetToEncodedArrayItem = iso<OffsetToEncodedArrayItem>();
 
-export interface OffsetToCodeItem extends Newtype<{ readonly OffsetToCodeItem: unique symbol }, number> {}
+export type OffsetToCodeItem = {} & Newtype<{ readonly OffsetToCodeItem: unique symbol }, number>;
 export const isoOffsetToCodeItem = iso<OffsetToCodeItem>();
 
-export interface OffsetToDebugInfoItem extends Newtype<{ readonly OffsetToDebugInfoItem: unique symbol }, number> {}
+export type OffsetToDebugInfoItem = {} & Newtype<{ readonly OffsetToDebugInfoItem: unique symbol }, number>;
 export const isoOffsetToDebugInfoItem = iso<OffsetToDebugInfoItem>();
 
-export interface OffsetToAnnotationItem extends Newtype<{ readonly OffsetToAnnotationItem: unique symbol }, number> {}
+export type OffsetToAnnotationItem = {} & Newtype<{ readonly OffsetToAnnotationItem: unique symbol }, number>;
 export const isoOffsetToAnnotationItem = iso<OffsetToAnnotationItem>();
 
-export interface OffsetFromEncodedCatchHandlerListToEncodedCatchHandler extends Newtype<{ readonly OffsetFromEncodedCatchHandlerListToEncodedCatchHandler: unique symbol }, number> {}
+export type OffsetFromEncodedCatchHandlerListToEncodedCatchHandler = {} & Newtype<{ readonly OffsetFromEncodedCatchHandlerListToEncodedCatchHandler: unique symbol }, number>;
 export const isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler = iso<OffsetFromEncodedCatchHandlerListToEncodedCatchHandler>();
 
-export interface TypedNumberArray<IndexType, ValueType> extends Newtype<{ readonly TypedNumberArray: unique symbol }, Array<ValueType>> {
+export type TypedNumberArray<IndexType, ValueType> = {
 	get length(): number;
 	at(index: IndexType): undefined | ValueType;
 	map<NewValueType>(fn: (value: ValueType, index: IndexType) => NewValueType): TypedNumberArray<IndexType, NewValueType>;
 	[Symbol.iterator](): IterableIterator<ValueType>;
-};
+} & Newtype<{ readonly TypedNumberArray: unique symbol }, ValueType[]>;
 export const getIsoTypedNumberArray = <IndexType, ValueType>() => iso<TypedNumberArray<IndexType, ValueType>>();

package/src/dalvikExecutableParser.test.ts

@@ -4,39 +4,37 @@ import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { dalvikExecutableParser, dalvikExecutableWithRawInstructionsParser } from './dalvikExecutableParser.js';
 import { fetchCid } from './fetchCid.js';
 
-for (const [ dexCid, shouldSnapshot ] of [
-	[ 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true ],
-	[ 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false ],
-	[ 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false ],
-	[ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false ],
-] as const) {
-	test.serial(
-		'dex (with instructions as bytes) ' + dexCid,
-		async t => {
-			const dexStream = await fetchCid(dexCid);
-
-			const actual = await runParser(dalvikExecutableWithRawInstructionsParser, dexStream, uint8ArrayParserInputCompanion, {
-				errorJoinMode: 'all',
-			});
-
-			if (shouldSnapshot) {
-				t.snapshot(actual);
-			} else {
-				//console.dir(actual, { depth: null });
-				t.pass();
-			}
-		},
-	);
-}
+const dexWithRawInstructionsMacro = test.macro({
+	title: (providedTitle, dexCid: string) => providedTitle ?? `dex (with instructions as bytes) ${dexCid}`,
+	async exec(t, dexCid: string, shouldSnapshot: boolean) {
+		const dexStream = await fetchCid(dexCid);
+
+		const actual = await runParser(dalvikExecutableWithRawInstructionsParser, dexStream, uint8ArrayParserInputCompanion, {
+			errorJoinMode: 'all',
+		});
+
+		if (shouldSnapshot) {
+			t.snapshot(actual);
+		} else {
+			// Console.dir(actual, { depth: null });
+			t.pass();
+		}
+	},
+});
+
+test.serial(dexWithRawInstructionsMacro, 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true);
+test.serial(dexWithRawInstructionsMacro, 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false);
+test.serial(dexWithRawInstructionsMacro, 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false);
+test.serial(dexWithRawInstructionsMacro, 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false);
 
-type ObjectPath = (string | symbol | number)[];
+type ObjectPath = Array<string | symbol | number>;
 
 function objectWalk(object: unknown, f: (path: ObjectPath, value: unknown) => void, initialPath: ObjectPath = []) {
 	f(initialPath, object);
 
 	if (
 		!object
-			|| typeof object !== 'object'
+		|| typeof object !== 'object'
 	) {
 		return;
 	}
@@ -52,38 +50,40 @@ function objectWalk(object: unknown, f: (path: ObjectPath, value: unknown) => vo
 	}
 }
 
-for (const [ dexCid, shouldSnapshot ] of [
-	[ 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true ],
-	// [ 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false ],
-	// [ 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false ],
-	// [ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false ],
-] as const) {
-	test.serial(
-		'dex (with parsed instructions) ' + dexCid,
-		async t => {
-			const dexStream = await fetchCid(dexCid);
-
-			const actual = await runParser(dalvikExecutableParser, dexStream, uint8ArrayParserInputCompanion, {
-				errorJoinMode: 'all',
-			});
-
-			objectWalk(actual, (path) => {
-				const key = path.at(-1);
-
-				if (typeof key !== 'string') {
-					return;
-				}
-
-				t.false(key.endsWith('Offset'), 'All offsets should be resolved: ' + path.join('.'));
-				t.false(key.endsWith('Index'), 'All indexes should be resolved: ' + path.join('.'));
-			});
-
-			if (shouldSnapshot) {
-				t.snapshot(actual);
-			} else {
-				//console.dir(actual, { depth: null });
-				t.pass();
+const dexWithParsedInstructionsMacro = test.macro({
+	title: (providedTitle, dexCid: string) => providedTitle ?? `dex (with parsed instructions) ${dexCid}`,
+	async exec(t, dexCid: string, shouldSnapshot: boolean) {
+		const dexStream = await fetchCid(dexCid);
+
+		debugger;
+
+		const actual = await runParser(dalvikExecutableParser, dexStream, uint8ArrayParserInputCompanion, {
+			errorJoinMode: 'all',
+		});
+
+		debugger;
+
+		objectWalk(actual, path => {
+			const key = path.at(-1);
+
+			if (typeof key !== 'string') {
+				return;
 			}
-		},
-	);
-}
+
+			t.false(key.endsWith('Offset') && key !== 'branchOffset', 'All offsets should be resolved: ' + path.join('.'));
+			t.false(key.endsWith('Index'), 'All indexes should be resolved: ' + path.join('.'));
+		});
+
+		if (shouldSnapshot) {
+			t.snapshot(actual);
+		} else {
+			// Console.dir(actual, { depth: null });
+			t.pass();
+		}
+	},
+});
+
+test.serial.only(dexWithParsedInstructionsMacro, 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true);
+test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false);
+test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false);
+test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false);