@futpib/parser 1.0.2 → 1.0.4

package/build/arbitraryDalvikExecutable.js

@@ -0,0 +1,282 @@
+import * as fc from 'fast-check';
+// 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'));
+const arbitraryDalvikClassName = fc.tuple(fc.array(arbitraryJavaIdentifier, { minLength: 1, maxLength: 3 }), arbitraryJavaIdentifier).map(([packages, className]) => `L${packages.join('/')}/${className};`);
+const arbitraryDalvikTypeName = fc.oneof(arbitraryPrimitiveType, arbitraryDalvikClassName, arbitraryPrimitiveType.map(p => `[${p}`), // array of primitive
+arbitraryDalvikClassName.map(c => `[${c}`));
+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.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.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.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 = arbitraryDalvikExecutableAccessFlagsCommon;
+// Field generator
+const arbitraryDalvikExecutableField = fc.record({
+    class: arbitraryDalvikClassName,
+    type: arbitraryDalvikTypeName,
+    name: arbitraryDalvikFieldName,
+});
+const arbitraryDalvikExecutableFieldWithAccess = fc.record({
+    field: arbitraryDalvikExecutableField,
+    accessFlags: arbitraryDalvikExecutableFieldAccessFlags,
+});
+// Prototype generator
+const arbitraryShorty = fc.tuple(arbitraryPrimitiveType, // return type
+fc.array(fc.oneof(fc.constant('L'), arbitraryPrimitiveType), { maxLength: 5 })).map(([returnType, params]) => returnType + params.join(''));
+const arbitraryDalvikExecutablePrototype = 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.record({
+    class: arbitraryDalvikClassName,
+    prototype: arbitraryDalvikExecutablePrototype,
+    name: arbitraryDalvikMethodName,
+});
+// Encoded value generator (recursive)
+// DalvikExecutableEncodedValue is now a tagged union with type information
+const arbitraryDalvikExecutableEncodedValue = fc.letrec(tie => ({
+    value: fc.oneof(fc.record({ type: fc.constant('byte'), value: fc.integer({ min: -128, max: 127 }) }), fc.record({ type: fc.constant('short'), value: fc.integer({ min: -32768, max: 32767 }) }), fc.record({ type: fc.constant('char'), value: fc.integer({ min: 0, max: 65535 }) }), fc.record({ type: fc.constant('int'), value: fc.integer({ min: -2147483648, max: 2147483647 }) }), fc.record({ type: fc.constant('long'), value: fc.bigInt({ min: -9223372036854775808n, max: 9223372036854775807n }) }), fc.record({ type: fc.constant('float'), value: fc.float() }), fc.record({ type: fc.constant('double'), value: fc.double() }), fc.record({ type: fc.constant('methodType'), value: arbitraryDalvikExecutablePrototype }), fc.record({ type: fc.constant('methodHandle'), value: fc.nat(255) }), fc.record({ type: fc.constant('string'), value: fc.string() }), fc.record({ type: fc.constant('type'), value: arbitraryDalvikClassName }), fc.record({ type: fc.constant('field'), value: arbitraryDalvikExecutableField }), fc.record({ type: fc.constant('method'), value: arbitraryDalvikExecutableMethod }), fc.record({ type: fc.constant('enum'), value: arbitraryDalvikExecutableField }), fc.record({ type: fc.constant('array'), value: fc.array(tie('value'), { maxLength: 3 }) }), 
+    // Note: We skip 'annotation' type here to avoid deep recursion complexity
+    fc.record({ type: fc.constant('null'), value: fc.constant(null) }), fc.record({ type: fc.constant('boolean'), value: fc.boolean() })),
+})).value;
+// Annotation generators
+const arbitraryAnnotationVisibility = fc.oneof(fc.constant('build'), fc.constant('runtime'), fc.constant('system'));
+const arbitraryDalvikExecutableAnnotationElement = fc.record({
+    name: arbitraryJavaIdentifier,
+    value: arbitraryDalvikExecutableEncodedValue,
+});
+const arbitraryDalvikExecutableAnnotation = fc.record({
+    visibility: arbitraryAnnotationVisibility,
+    type: arbitraryDalvikClassName,
+    elements: fc.array(arbitraryDalvikExecutableAnnotationElement, { maxLength: 3 }),
+});
+// Debug info generators
+const arbitraryDalvikExecutableDebugByteCodeValue = fc.oneof(fc.record({
+    type: fc.constant('advancePc'),
+    addressDiff: fc.nat({ max: 255 }),
+}), fc.record({
+    type: fc.constant('advanceLine'),
+    lineDiff: fc.integer({ min: -128, max: 127 }),
+}), fc.record({
+    type: fc.constant('startLocal'),
+    registerNum: fc.nat({ max: 255 }),
+    name: fc.option(arbitraryJavaIdentifier, { nil: undefined }),
+    type_: fc.option(arbitraryDalvikTypeName, { nil: undefined }),
+}), fc.record({
+    type: fc.constant('startLocalExtended'),
+    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'),
+    registerNum: fc.nat({ max: 255 }),
+}), fc.record({
+    type: fc.constant('restartLocal'),
+    registerNum: fc.nat({ max: 255 }),
+}), fc.record({
+    type: fc.constant('setPrologueEnd'),
+}), fc.record({
+    type: fc.constant('setEpilogueBegin'),
+}), fc.record({
+    type: fc.constant('setFile'),
+    name: fc.option(fc.string(), { nil: undefined }),
+}), fc.record({
+    type: fc.constant('special'),
+    // Special opcodes must be >= 0x0A (values 0x00-0x09 are specific debug opcodes)
+    value: fc.integer({ min: 0x0A, max: 255 }),
+}));
+const arbitraryDalvikExecutableDebugInfo = fc.record({
+    lineStart: fc.nat({ max: 65535 }),
+    parameterNames: fc.array(fc.option(arbitraryJavaIdentifier, { nil: undefined }), { maxLength: 5 }),
+    bytecode: fc.array(arbitraryDalvikExecutableDebugByteCodeValue, { maxLength: 10 }),
+});
+const arbitraryDalvikExecutableEncodedTypeAddressPair = fc.record({
+    type: arbitraryDalvikClassName,
+    address: fc.nat({ max: 65535 }),
+});
+const arbitraryDalvikExecutableEncodedCatchHandler = 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.record({
+    startAddress: fc.nat({ max: 65535 }),
+    instructionCount: fc.nat({ max: 255 }),
+    handler: arbitraryDalvikExecutableEncodedCatchHandler,
+});
+// Generic factory function for DalvikExecutable
+export const createArbitraryDalvikExecutable = (arbitraryInstructions) => {
+    // Code generator using provided instructions arbitrary
+    const arbitraryDalvikExecutableCode = 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.record({
+        method: arbitraryDalvikExecutableMethod,
+        accessFlags: arbitraryDalvikExecutableMethodAccessFlags,
+        code: fc.option(arbitraryDalvikExecutableCode, { nil: undefined }),
+    });
+    // Annotation collections
+    const arbitraryDalvikExecutableClassFieldAnnotation = fc.record({
+        field: arbitraryDalvikExecutableField,
+        annotations: fc.option(fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }), { nil: undefined }),
+    });
+    const arbitraryDalvikExecutableClassMethodAnnotation = fc.record({
+        method: arbitraryDalvikExecutableMethod,
+        annotations: fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }),
+    });
+    const arbitraryDalvikExecutableClassParameterAnnotation = fc.record({
+        method: arbitraryDalvikExecutableMethod,
+        annotations: fc.array(fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }), { maxLength: 3 }),
+    });
+    const arbitraryDalvikExecutableClassAnnotations = 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.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.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/build/arbitraryDosDateTime.js

@@ -2,6 +2,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/build/arbitraryZipStream.js

@@ -4,7 +4,7 @@ function addZipEntryToZip(zip, 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,
     };
     if (zipEntry.type === 'file') {

package/build/arrayParser.js

@@ -1,5 +1,5 @@
 import { getParserName, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 export const createArrayParser = (elementParser) => {
     const arrayParser = async (parserContext) => {
         const elements = [];
@@ -15,7 +15,7 @@ export const createArrayParser = (elementParser) => {
                 elementParserContext.unlookahead();
             }
             catch (error) {
-                if (error instanceof ParserParsingFailedError) {
+                if (isParserParsingFailedError(error)) {
                     return elements;
                 }
                 throw error;

package/build/arrayUnparser.d.ts

@@ -1,2 +1,2 @@
-import { Unparser } from "./unparser.js";
+import { type Unparser } from './unparser.js';
 export declare const createArrayUnparser: <ElementInput, Sequence>(elementUnparser: Unparser<ElementInput, Sequence>) => Unparser<ElementInput[], Sequence>;

package/build/backsmali.d.ts

@@ -1 +1,3 @@
-export declare function baksmaliClass(dexStream: AsyncIterable<Uint8Array>, smaliFilePath: string): Promise<string>;
+export declare function baksmaliClass(dexStream: Uint8Array | AsyncIterable<Uint8Array>, smaliFilePath: string): Promise<string>;
+export declare function backsmaliSmaliIsolateClass(dexStream: Uint8Array | AsyncIterable<Uint8Array>, smaliFilePath: string): Promise<Uint8Array>;
+export declare function baksmaliListClasses(dexStream: Uint8Array | AsyncIterable<Uint8Array>): Promise<string[]>;

package/build/backsmali.js

@@ -1,15 +1,18 @@
 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, smaliFilePath) {
     const inputFilePath = temporaryFile();
     const outputDirectoryPath = temporaryDirectory();
     await fs.writeFile(inputFilePath, dexStream);
     await execa('baksmali', [
         'disassemble',
-        '--classes', 'L' + smaliFilePath + ';',
-        '--output', outputDirectoryPath,
+        '--classes',
+        'L' + smaliFilePath + ';',
+        '--output',
+        outputDirectoryPath,
         inputFilePath,
     ]);
     await fs.unlink(inputFilePath);
@@ -20,3 +23,28 @@ export async function baksmaliClass(dexStream, smaliFilePath) {
     });
     return smali;
 }
+export async function backsmaliSmaliIsolateClass(dexStream, smaliFilePath) {
+    const smali = await baksmaliClass(dexStream, smaliFilePath);
+    return smaliClass(smali);
+}
+export async function baksmaliListClasses(dexStream) {
+    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/build/bash.d.ts

@@ -0,0 +1,84 @@
+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;
+};
+export type BashRedirect = {
+    fd?: number;
+    operator: '>' | '>>' | '<' | '<<' | '<<<' | '>&' | '<&' | '>|';
+    target: BashWord | BashHereDoc;
+};
+export type BashHereDoc = {
+    type: 'hereDoc';
+    delimiter: string;
+    content: string;
+    quoted: boolean;
+};
+export type BashAssignment = {
+    name: string;
+    value?: BashWord;
+};
+export type BashSimpleCommand = {
+    type: 'simple';
+    name?: BashWord;
+    args: BashWord[];
+    redirects: BashRedirect[];
+    assignments: BashAssignment[];
+};
+export type BashSubshell = {
+    type: 'subshell';
+    body: BashCommand;
+};
+export type BashBraceGroup = {
+    type: 'braceGroup';
+    body: BashCommand;
+};
+export type BashCommandUnit = BashSimpleCommand | BashSubshell | BashBraceGroup;
+export type BashPipeline = {
+    type: 'pipeline';
+    negated: boolean;
+    commands: BashCommandUnit[];
+};
+export type BashCommandListSeparator = '&&' | '||' | ';' | '&' | '\n';
+export type BashCommandList = {
+    type: 'list';
+    entries: {
+        pipeline: BashPipeline;
+        separator?: BashCommandListSeparator;
+    }[];
+};
+export type BashCommand = BashCommandList;
+export type BashScript = BashCommand;

package/build/bash.js

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

package/build/bashParser.d.ts

@@ -0,0 +1,6 @@
+import { type Parser } from './parser.js';
+import { type BashWord, type BashSimpleCommand, type BashCommand } from './bash.js';
+export declare const bashWordParser: Parser<BashWord, string>;
+export declare const bashSimpleCommandParser: Parser<BashSimpleCommand, string>;
+export declare const bashCommandParser: Parser<BashCommand, string>;
+export declare const bashScriptParser: Parser<BashCommand, string>;