@futpib/parser 1.0.2 → 1.0.4

package/src/arbitraryDalvikExecutable.ts

@@ -0,0 +1,434 @@
+import * as fc from 'fast-check';
+import {
+	type DalvikExecutable,
+	type DalvikExecutableClassDefinition,
+	type DalvikExecutableAccessFlags,
+	type DalvikExecutableClassData,
+	type DalvikExecutableField,
+	type DalvikExecutableFieldWithAccess,
+	type DalvikExecutableMethod,
+	type DalvikExecutableMethodWithAccess,
+	type DalvikExecutablePrototype,
+	type DalvikExecutableCode,
+	type DalvikExecutableDebugInfo,
+	type DalvikExecutableAnnotation,
+	type DalvikExecutableClassAnnotations,
+	type DalvikExecutableClassFieldAnnotation,
+	type DalvikExecutableClassMethodAnnotation,
+	type DalvikExecutableClassParameterAnnotation,
+	type DalvikExecutableEncodedValue,
+} from './dalvikExecutable.js';
+
+// Local type definitions for non-exported types
+
+type DalvikExecutableAnnotationItemVisibility = 'build' | 'runtime' | 'system';
+
+type DalvikExecutableAnnotationElement = {
+	name: string;
+	value: DalvikExecutableEncodedValue;
+};
+
+type DalvikExecutableDebugByteCodeValue =
+	| { type: 'advancePc'; addressDiff: number }
+	| { type: 'advanceLine'; lineDiff: number }
+	| { type: 'startLocal'; registerNum: number; name: undefined | string; type_: undefined | string }
+	| { type: 'startLocalExtended'; registerNum: number; name: undefined | string; type_: undefined | string; signature: undefined | string }
+	| { type: 'endLocal'; registerNum: number }
+	| { type: 'restartLocal'; registerNum: number }
+	| { type: 'setPrologueEnd' }
+	| { type: 'setEpilogueBegin' }
+	| { type: 'setFile'; name: undefined | string }
+	| { type: 'special'; value: number };
+
+// String generators for valid Dalvik identifiers and type descriptors
+
+const arbitraryJavaIdentifier = fc.stringMatching(/^[a-zA-Z_][a-zA-Z0-9_]*$/);
+
+const arbitraryPrimitiveType = fc.oneof(
+	fc.constant('V'), // void
+	fc.constant('Z'), // boolean
+	fc.constant('B'), // byte
+	fc.constant('S'), // short
+	fc.constant('C'), // char
+	fc.constant('I'), // int
+	fc.constant('J'), // long
+	fc.constant('F'), // float
+	fc.constant('D'), // double
+);
+
+const arbitraryDalvikClassName: fc.Arbitrary<string> = fc.tuple(
+	fc.array(arbitraryJavaIdentifier, { minLength: 1, maxLength: 3 }),
+	arbitraryJavaIdentifier,
+).map(([packages, className]) => `L${packages.join('/')}/${className};`);
+
+const arbitraryDalvikTypeName: fc.Arbitrary<string> = fc.oneof(
+	arbitraryPrimitiveType,
+	arbitraryDalvikClassName,
+	arbitraryPrimitiveType.map(p => `[${p}`), // array of primitive
+	arbitraryDalvikClassName.map(c => `[${c}`), // array of object
+);
+
+const arbitraryDalvikMethodName = fc.oneof(
+	arbitraryJavaIdentifier,
+	fc.constant('<init>'),
+	fc.constant('<clinit>'),
+);
+
+const arbitraryDalvikFieldName = arbitraryJavaIdentifier;
+
+// Access flags generator - common flags for all contexts
+const arbitraryDalvikExecutableAccessFlagsCommon: fc.Arbitrary<DalvikExecutableAccessFlags> = fc.record({
+	public: fc.boolean(),
+	private: fc.boolean(),
+	protected: fc.boolean(),
+	static: fc.boolean(),
+	final: fc.boolean(),
+	synchronized: fc.boolean(),
+	volatile: fc.constant(false),
+	bridge: fc.constant(false),
+	transient: fc.constant(false),
+	varargs: fc.constant(false),
+	native: fc.boolean(),
+	interface: fc.boolean(),
+	abstract: fc.boolean(),
+	strict: fc.boolean(),
+	synthetic: fc.boolean(),
+	annotation: fc.boolean(),
+	enum: fc.boolean(),
+	constructor: fc.boolean(),
+	declaredSynchronized: fc.boolean(),
+});
+
+// Access flags for fields - volatile and transient are valid (0x40 and 0x80)
+const arbitraryDalvikExecutableFieldAccessFlags: fc.Arbitrary<DalvikExecutableAccessFlags> = fc.record({
+	public: fc.boolean(),
+	private: fc.boolean(),
+	protected: fc.boolean(),
+	static: fc.boolean(),
+	final: fc.boolean(),
+	synchronized: fc.boolean(),
+	volatile: fc.boolean(),
+	bridge: fc.constant(false),
+	transient: fc.boolean(),
+	varargs: fc.constant(false),
+	native: fc.boolean(),
+	interface: fc.boolean(),
+	abstract: fc.boolean(),
+	strict: fc.boolean(),
+	synthetic: fc.boolean(),
+	annotation: fc.boolean(),
+	enum: fc.boolean(),
+	constructor: fc.boolean(),
+	declaredSynchronized: fc.boolean(),
+});
+
+// Access flags for methods - bridge and varargs are valid (0x40 and 0x80)
+const arbitraryDalvikExecutableMethodAccessFlags: fc.Arbitrary<DalvikExecutableAccessFlags> = fc.record({
+	public: fc.boolean(),
+	private: fc.boolean(),
+	protected: fc.boolean(),
+	static: fc.boolean(),
+	final: fc.boolean(),
+	synchronized: fc.boolean(),
+	volatile: fc.constant(false),
+	bridge: fc.boolean(),
+	transient: fc.constant(false),
+	varargs: fc.boolean(),
+	native: fc.boolean(),
+	interface: fc.boolean(),
+	abstract: fc.boolean(),
+	strict: fc.boolean(),
+	synthetic: fc.boolean(),
+	annotation: fc.boolean(),
+	enum: fc.boolean(),
+	constructor: fc.boolean(),
+	declaredSynchronized: fc.boolean(),
+});
+
+// Generic access flags for class-level (uses common)
+const arbitraryDalvikExecutableAccessFlags: fc.Arbitrary<DalvikExecutableAccessFlags> = arbitraryDalvikExecutableAccessFlagsCommon;
+
+// Field generator
+const arbitraryDalvikExecutableField: fc.Arbitrary<DalvikExecutableField> = fc.record({
+	class: arbitraryDalvikClassName,
+	type: arbitraryDalvikTypeName,
+	name: arbitraryDalvikFieldName,
+});
+
+const arbitraryDalvikExecutableFieldWithAccess: fc.Arbitrary<DalvikExecutableFieldWithAccess> = fc.record({
+	field: arbitraryDalvikExecutableField,
+	accessFlags: arbitraryDalvikExecutableFieldAccessFlags,
+});
+
+// Prototype generator
+const arbitraryShorty: fc.Arbitrary<string> = fc.tuple(
+	arbitraryPrimitiveType, // return type
+	fc.array(fc.oneof(fc.constant('L'), arbitraryPrimitiveType), { maxLength: 5 }), // parameters
+).map(([returnType, params]) => returnType + params.join(''));
+
+const arbitraryDalvikExecutablePrototype: fc.Arbitrary<DalvikExecutablePrototype> = arbitraryShorty.chain(shorty => {
+	const returnTypeChar = shorty[0];
+	const paramChars = shorty.slice(1).split('');
+
+	const returnType = returnTypeChar === 'L' ? arbitraryDalvikClassName : fc.constant(returnTypeChar);
+	const parameters = fc.tuple(
+		...paramChars.map(char => char === 'L' ? arbitraryDalvikClassName : fc.constant(char))
+	);
+
+	return fc.record({
+		shorty: fc.constant(shorty),
+		returnType,
+		parameters,
+	});
+});
+
+// Method generator
+const arbitraryDalvikExecutableMethod: fc.Arbitrary<DalvikExecutableMethod> = fc.record({
+	class: arbitraryDalvikClassName,
+	prototype: arbitraryDalvikExecutablePrototype,
+	name: arbitraryDalvikMethodName,
+});
+
+// Encoded value generator (recursive)
+// DalvikExecutableEncodedValue is now a tagged union with type information
+const arbitraryDalvikExecutableEncodedValue: fc.Arbitrary<DalvikExecutableEncodedValue> = fc.letrec(tie => ({
+	value: fc.oneof(
+		fc.record({ type: fc.constant('byte' as const), value: fc.integer({ min: -128, max: 127 }) }),
+		fc.record({ type: fc.constant('short' as const), value: fc.integer({ min: -32768, max: 32767 }) }),
+		fc.record({ type: fc.constant('char' as const), value: fc.integer({ min: 0, max: 65535 }) }),
+		fc.record({ type: fc.constant('int' as const), value: fc.integer({ min: -2147483648, max: 2147483647 }) }),
+		fc.record({ type: fc.constant('long' as const), value: fc.bigInt({ min: -9223372036854775808n, max: 9223372036854775807n }) }),
+		fc.record({ type: fc.constant('float' as const), value: fc.float() }),
+		fc.record({ type: fc.constant('double' as const), value: fc.double() }),
+		fc.record({ type: fc.constant('methodType' as const), value: arbitraryDalvikExecutablePrototype }),
+		fc.record({ type: fc.constant('methodHandle' as const), value: fc.nat(255) }),
+		fc.record({ type: fc.constant('string' as const), value: fc.string() }),
+		fc.record({ type: fc.constant('type' as const), value: arbitraryDalvikClassName }),
+		fc.record({ type: fc.constant('field' as const), value: arbitraryDalvikExecutableField }),
+		fc.record({ type: fc.constant('method' as const), value: arbitraryDalvikExecutableMethod }),
+		fc.record({ type: fc.constant('enum' as const), value: arbitraryDalvikExecutableField }),
+		fc.record({ type: fc.constant('array' as const), value: fc.array(tie('value') as fc.Arbitrary<DalvikExecutableEncodedValue>, { maxLength: 3 }) }),
+		// Note: We skip 'annotation' type here to avoid deep recursion complexity
+		fc.record({ type: fc.constant('null' as const), value: fc.constant(null) }),
+		fc.record({ type: fc.constant('boolean' as const), value: fc.boolean() }),
+	),
+})).value;
+
+// Annotation generators
+const arbitraryAnnotationVisibility: fc.Arbitrary<DalvikExecutableAnnotationItemVisibility> = fc.oneof(
+	fc.constant('build' as const),
+	fc.constant('runtime' as const),
+	fc.constant('system' as const),
+);
+
+const arbitraryDalvikExecutableAnnotationElement: fc.Arbitrary<DalvikExecutableAnnotationElement> = fc.record({
+	name: arbitraryJavaIdentifier,
+	value: arbitraryDalvikExecutableEncodedValue,
+});
+
+const arbitraryDalvikExecutableAnnotation: fc.Arbitrary<DalvikExecutableAnnotation> = fc.record({
+	visibility: arbitraryAnnotationVisibility,
+	type: arbitraryDalvikClassName,
+	elements: fc.array(arbitraryDalvikExecutableAnnotationElement, { maxLength: 3 }),
+});
+
+// Debug info generators
+const arbitraryDalvikExecutableDebugByteCodeValue: fc.Arbitrary<DalvikExecutableDebugByteCodeValue> = fc.oneof(
+	fc.record({
+		type: fc.constant('advancePc' as const),
+		addressDiff: fc.nat({ max: 255 }),
+	}),
+	fc.record({
+		type: fc.constant('advanceLine' as const),
+		lineDiff: fc.integer({ min: -128, max: 127 }),
+	}),
+	fc.record({
+		type: fc.constant('startLocal' as const),
+		registerNum: fc.nat({ max: 255 }),
+		name: fc.option(arbitraryJavaIdentifier, { nil: undefined }),
+		type_: fc.option(arbitraryDalvikTypeName, { nil: undefined }),
+	}),
+	fc.record({
+		type: fc.constant('startLocalExtended' as const),
+		registerNum: fc.nat({ max: 255 }),
+		name: fc.option(arbitraryJavaIdentifier, { nil: undefined }),
+		type_: fc.option(arbitraryDalvikTypeName, { nil: undefined }),
+		signature: fc.option(fc.string(), { nil: undefined }),
+	}),
+	fc.record({
+		type: fc.constant('endLocal' as const),
+		registerNum: fc.nat({ max: 255 }),
+	}),
+	fc.record({
+		type: fc.constant('restartLocal' as const),
+		registerNum: fc.nat({ max: 255 }),
+	}),
+	fc.record({
+		type: fc.constant('setPrologueEnd' as const),
+	}),
+	fc.record({
+		type: fc.constant('setEpilogueBegin' as const),
+	}),
+	fc.record({
+		type: fc.constant('setFile' as const),
+		name: fc.option(fc.string(), { nil: undefined }),
+	}),
+	fc.record({
+		type: fc.constant('special' as const),
+		// Special opcodes must be >= 0x0A (values 0x00-0x09 are specific debug opcodes)
+		value: fc.integer({ min: 0x0A, max: 255 }),
+	}),
+);
+
+const arbitraryDalvikExecutableDebugInfo: fc.Arbitrary<DalvikExecutableDebugInfo> = fc.record({
+	lineStart: fc.nat({ max: 65535 }),
+	parameterNames: fc.array(fc.option(arbitraryJavaIdentifier, { nil: undefined }), { maxLength: 5 }),
+	bytecode: fc.array(arbitraryDalvikExecutableDebugByteCodeValue, { maxLength: 10 }),
+});
+
+// Try-catch handler generators
+interface DalvikExecutableTry {
+	startAddress: number;
+	instructionCount: number;
+	handler: DalvikExecutableEncodedCatchHandler;
+}
+
+interface DalvikExecutableEncodedCatchHandler {
+	handlers: DalvikExecutableEncodedTypeAddressPair[];
+	catchAllAddress: undefined | number;
+}
+
+interface DalvikExecutableEncodedTypeAddressPair {
+	type: string;
+	address: number;
+}
+
+const arbitraryDalvikExecutableEncodedTypeAddressPair: fc.Arbitrary<DalvikExecutableEncodedTypeAddressPair> = fc.record({
+	type: arbitraryDalvikClassName,
+	address: fc.nat({ max: 65535 }),
+});
+
+const arbitraryDalvikExecutableEncodedCatchHandler: fc.Arbitrary<DalvikExecutableEncodedCatchHandler> = fc.record({
+	handlers: fc.array(arbitraryDalvikExecutableEncodedTypeAddressPair, { maxLength: 3 }),
+	catchAllAddress: fc.option(fc.nat({ max: 65535 }), { nil: undefined }),
+}).filter(handler => {
+	// A handler must have at least one typed handler OR a catch-all address
+	return handler.handlers.length > 0 || handler.catchAllAddress !== undefined;
+});
+
+const arbitraryDalvikExecutableTry: fc.Arbitrary<DalvikExecutableTry> = fc.record({
+	startAddress: fc.nat({ max: 65535 }),
+	instructionCount: fc.nat({ max: 255 }),
+	handler: arbitraryDalvikExecutableEncodedCatchHandler,
+});
+
+// Generic factory function for DalvikExecutable
+export const createArbitraryDalvikExecutable = <Instructions>(
+	arbitraryInstructions: fc.Arbitrary<Instructions>,
+): fc.Arbitrary<DalvikExecutable<Instructions>> => {
+	// Code generator using provided instructions arbitrary
+	const arbitraryDalvikExecutableCode: fc.Arbitrary<DalvikExecutableCode<Instructions>> = fc.record({
+		registersSize: fc.nat({ max: 65535 }),
+		insSize: fc.nat({ max: 255 }),
+		outsSize: fc.nat({ max: 255 }),
+		debugInfo: fc.option(arbitraryDalvikExecutableDebugInfo, { nil: undefined }),
+		instructions: arbitraryInstructions,
+		tries: fc.array(arbitraryDalvikExecutableTry, { maxLength: 2 }),
+	});
+
+	// Method with access and code
+	const arbitraryDalvikExecutableMethodWithAccess: fc.Arbitrary<DalvikExecutableMethodWithAccess<Instructions>> = fc.record({
+		method: arbitraryDalvikExecutableMethod,
+		accessFlags: arbitraryDalvikExecutableMethodAccessFlags,
+		code: fc.option(arbitraryDalvikExecutableCode, { nil: undefined }),
+	});
+
+	// Annotation collections
+	const arbitraryDalvikExecutableClassFieldAnnotation: fc.Arbitrary<DalvikExecutableClassFieldAnnotation> = fc.record({
+		field: arbitraryDalvikExecutableField,
+		annotations: fc.option(fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }), { nil: undefined }),
+	});
+
+	const arbitraryDalvikExecutableClassMethodAnnotation: fc.Arbitrary<DalvikExecutableClassMethodAnnotation> = fc.record({
+		method: arbitraryDalvikExecutableMethod,
+		annotations: fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }),
+	});
+
+	const arbitraryDalvikExecutableClassParameterAnnotation: fc.Arbitrary<DalvikExecutableClassParameterAnnotation> = fc.record({
+		method: arbitraryDalvikExecutableMethod,
+		annotations: fc.array(
+			fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }),
+			{ maxLength: 3 }
+		),
+	});
+
+	const arbitraryDalvikExecutableClassAnnotations: fc.Arbitrary<DalvikExecutableClassAnnotations> = fc.record({
+		classAnnotations: fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }),
+		fieldAnnotations: fc.array(arbitraryDalvikExecutableClassFieldAnnotation, { maxLength: 2 }),
+		methodAnnotations: fc.array(arbitraryDalvikExecutableClassMethodAnnotation, { maxLength: 2 }),
+		parameterAnnotations: fc.array(arbitraryDalvikExecutableClassParameterAnnotation, { maxLength: 2 }),
+	}).map(annotations => ({
+		...annotations,
+		// Filter out field/method/parameter annotations with undefined or empty annotations array
+		// In DEX format, fields/methods/parameters with no annotations should not appear in the annotations directory at all
+		fieldAnnotations: annotations.fieldAnnotations.filter(fa => fa.annotations !== undefined && fa.annotations.length > 0),
+		methodAnnotations: annotations.methodAnnotations.filter(ma => ma.annotations.length > 0),
+		parameterAnnotations: annotations.parameterAnnotations.filter(pa => pa.annotations.length > 0 && pa.annotations.some(paramAnnots => paramAnnots.length > 0)),
+	}));
+
+	// Class data
+	const arbitraryDalvikExecutableClassData: fc.Arbitrary<DalvikExecutableClassData<Instructions>> = fc.record({
+		staticFields: fc.array(arbitraryDalvikExecutableFieldWithAccess, { maxLength: 3 }),
+		instanceFields: fc.array(arbitraryDalvikExecutableFieldWithAccess, { maxLength: 3 }),
+		directMethods: fc.array(arbitraryDalvikExecutableMethodWithAccess, { maxLength: 3 }),
+		virtualMethods: fc.array(arbitraryDalvikExecutableMethodWithAccess, { maxLength: 3 }),
+	}).filter(classData => 
+		// Filter out empty classData (all arrays empty) as it's semantically equivalent to undefined
+		classData.staticFields.length > 0 ||
+		classData.instanceFields.length > 0 ||
+		classData.directMethods.length > 0 ||
+		classData.virtualMethods.length > 0
+	);
+
+	// Class definition
+	const arbitraryDalvikExecutableClassDefinition: fc.Arbitrary<DalvikExecutableClassDefinition<Instructions>> = fc.record({
+		class: arbitraryDalvikClassName,
+		accessFlags: arbitraryDalvikExecutableAccessFlags,
+		superclass: arbitraryDalvikClassName,
+		interfaces: fc.array(arbitraryDalvikClassName, { maxLength: 3 }),
+		sourceFile: fc.option(fc.stringMatching(/^[a-zA-Z0-9_]+\.java$/), { nil: undefined }),
+		annotations: fc.option(arbitraryDalvikExecutableClassAnnotations, { nil: undefined }),
+		staticValues: fc.array(arbitraryDalvikExecutableEncodedValue, { maxLength: 3 }),
+		classData: fc.option(arbitraryDalvikExecutableClassData, { nil: undefined }),
+	}).map(classDef => {
+		// Match parser logic: if all members are synthetic, set class synthetic to true
+		const allMembers = [
+			...classDef.classData?.staticFields ?? [],
+			...classDef.classData?.instanceFields ?? [],
+			...classDef.classData?.directMethods ?? [],
+			// Note: virtualMethods are not included to match parser behavior
+		];
+		const allMembersAreSynthetic = (
+			allMembers.every(member => member.accessFlags.synthetic)
+			&& allMembers.length > 0
+		);
+
+		if (allMembersAreSynthetic) {
+			return {
+				...classDef,
+				accessFlags: {
+					...classDef.accessFlags,
+					synthetic: true,
+				},
+			};
+		}
+
+		return classDef;
+	});
+
+	// Root DalvikExecutable
+	return fc.record({
+		classDefinitions: fc.array(arbitraryDalvikExecutableClassDefinition, { minLength: 1, maxLength: 3 }),
+		link: fc.option(fc.uint8Array({ minLength: 1, maxLength: 10 }), { nil: undefined }),
+	});
+};

package/src/arbitraryDosDateTime.ts

@@ -3,6 +3,7 @@ import * as fc from 'fast-check';
 export const arbitraryDosDateTime = fc.date({
 	min: new Date(Date.UTC(1980, 0, 1)),
 	max: new Date(Date.UTC(2099, 11, 31)),
+	noInvalidDate: true,
 }).map(date => {
 	date.setSeconds(0);
 	date.setMilliseconds(0);

package/src/arbitraryZipStream.ts

@@ -6,7 +6,7 @@ function addZipEntryToZip(zip: JSZip, zipEntry: ZipEntry) {
 	const options = {
 		comment: zipEntry.comment,
 		date: zipEntry.date,
-		// unixPermissions: zipEntry.permissions.type === 'unix' ? zipEntry.permissions.unixPermissions : undefined,
+		// UnixPermissions: zipEntry.permissions.type === 'unix' ? zipEntry.permissions.unixPermissions : undefined,
 		// dosPermissions: zipEntry.permissions.type === 'dos' ? zipEntry.permissions.dosPermissions : undefined,
 	};
 

package/src/arrayParser.ts

@@ -1,5 +1,5 @@
 import { getParserName, type Parser, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 
 export const createArrayParser = <ElementOutput, Sequence>(
 	elementParser: Parser<ElementOutput, Sequence>,
@@ -19,7 +19,7 @@ export const createArrayParser = <ElementOutput, Sequence>(
 				elements.push(element);
 				elementParserContext.unlookahead();
 			} catch (error) {
-				if (error instanceof ParserParsingFailedError) {
+				if (isParserParsingFailedError(error)) {
 					return elements;
 				}
 

package/src/arrayUnparser.ts

@@ -1,4 +1,4 @@
-import { Unparser } from "./unparser.js";
+import { type Unparser } from './unparser.js';
 
 export const createArrayUnparser = <ElementInput, Sequence>(
 	elementUnparser: Unparser<ElementInput, Sequence>,
@@ -10,4 +10,4 @@ export const createArrayUnparser = <ElementInput, Sequence>(
 	};
 
 	return arrayUnparser;
-}
+};

package/src/backsmali.ts

@@ -1,9 +1,13 @@
 import fs from 'node:fs/promises';
+import path from 'node:path';
 import { execa } from 'execa';
 import { temporaryDirectory, temporaryFile } from 'tempy';
-import path from 'node:path';
+import { smaliClass } from './smali.js';
 
-export async function baksmaliClass(dexStream: AsyncIterable<Uint8Array>, smaliFilePath: string) {
+export async function baksmaliClass(
+	dexStream: Uint8Array | AsyncIterable<Uint8Array>,
+	smaliFilePath: string,
+): Promise<string> {
 	const inputFilePath = temporaryFile();
 	const outputDirectoryPath = temporaryDirectory();
 
@@ -11,8 +15,10 @@ export async function baksmaliClass(dexStream: AsyncIterable<Uint8Array>, smaliF
 
 	await execa('baksmali', [
 		'disassemble',
-		'--classes', 'L' + smaliFilePath + ';',
-		'--output', outputDirectoryPath,
+		'--classes',
+		'L' + smaliFilePath + ';',
+		'--output',
+		outputDirectoryPath,
 		inputFilePath,
 	]);
 
@@ -28,3 +34,41 @@ export async function baksmaliClass(dexStream: AsyncIterable<Uint8Array>, smaliF
 
 	return smali;
 }
+
+export async function backsmaliSmaliIsolateClass(
+	dexStream: Uint8Array | AsyncIterable<Uint8Array>,
+	smaliFilePath: string,
+): Promise<Uint8Array> {
+	const smali = await baksmaliClass(dexStream, smaliFilePath);
+	return smaliClass(smali);
+}
+
+export async function baksmaliListClasses(dexStream: Uint8Array | AsyncIterable<Uint8Array>): Promise<string[]> {
+	const inputFilePath = temporaryFile();
+
+	await fs.writeFile(inputFilePath, dexStream);
+
+	const result = await execa('baksmali', [
+		'list',
+		'classes',
+		inputFilePath,
+	]);
+
+	await fs.unlink(inputFilePath);
+
+	if (result.stderr) {
+		throw new Error(`baksmali error: ${result.stderr}`);
+	}
+
+	const classes = result.stdout
+		.split('\n')
+		.filter(line => line.trim())
+		.map(line => line.trim())
+		.map(class_ => (
+			class_
+				.replace(/^L/, '')
+				.replace(/;$/, '')
+		));
+
+	return classes;
+}

package/src/bash.ts

@@ -0,0 +1,120 @@
+// Word: a single argument/token (may contain expansions)
+export type BashWord = {
+	parts: BashWordPart[];
+};
+
+export type BashWordPart =
+	| BashWordPartLiteral
+	| BashWordPartSingleQuoted
+	| BashWordPartDoubleQuoted
+	| BashWordPartVariable
+	| BashWordPartVariableBraced
+	| BashWordPartCommandSubstitution
+	| BashWordPartBacktickSubstitution
+	| BashWordPartArithmeticExpansion;
+
+export type BashWordPartLiteral = {
+	type: 'literal';
+	value: string;
+};
+
+export type BashWordPartSingleQuoted = {
+	type: 'singleQuoted';
+	value: string;
+};
+
+export type BashWordPartDoubleQuoted = {
+	type: 'doubleQuoted';
+	parts: BashWordPart[];
+};
+
+export type BashWordPartVariable = {
+	type: 'variable';
+	name: string;
+};
+
+export type BashWordPartVariableBraced = {
+	type: 'variableBraced';
+	name: string;
+	operator?: string;
+	operand?: BashWord;
+};
+
+export type BashWordPartCommandSubstitution = {
+	type: 'commandSubstitution';
+	command: BashCommand;
+};
+
+export type BashWordPartBacktickSubstitution = {
+	type: 'backtickSubstitution';
+	command: BashCommand;
+};
+
+export type BashWordPartArithmeticExpansion = {
+	type: 'arithmeticExpansion';
+	expression: string;
+};
+
+// Redirect: file descriptor operations
+export type BashRedirect = {
+	fd?: number;
+	operator: '>' | '>>' | '<' | '<<' | '<<<' | '>&' | '<&' | '>|';
+	target: BashWord | BashHereDoc;
+};
+
+export type BashHereDoc = {
+	type: 'hereDoc';
+	delimiter: string;
+	content: string;
+	quoted: boolean;
+};
+
+// Assignment
+export type BashAssignment = {
+	name: string;
+	value?: BashWord;
+};
+
+// Simple command: name + args + redirects
+export type BashSimpleCommand = {
+	type: 'simple';
+	name?: BashWord;
+	args: BashWord[];
+	redirects: BashRedirect[];
+	assignments: BashAssignment[];
+};
+
+// Compound commands (structural syntax only)
+export type BashSubshell = {
+	type: 'subshell';
+	body: BashCommand;
+};
+
+export type BashBraceGroup = {
+	type: 'braceGroup';
+	body: BashCommand;
+};
+
+export type BashCommandUnit = BashSimpleCommand | BashSubshell | BashBraceGroup;
+
+// Pipeline: cmd1 | cmd2 | cmd3
+export type BashPipeline = {
+	type: 'pipeline';
+	negated: boolean;
+	commands: BashCommandUnit[];
+};
+
+export type BashCommandListSeparator = '&&' | '||' | ';' | '&' | '\n';
+
+// Command list: pipelines connected by && || ; &
+export type BashCommandList = {
+	type: 'list';
+	entries: {
+		pipeline: BashPipeline;
+		separator?: BashCommandListSeparator;
+	}[];
+};
+
+// Top-level
+export type BashCommand = BashCommandList;
+export type BashScript = BashCommand;