@futpib/parser 1.0.1 → 1.0.2

package/build/smaliParser.js

@@ -0,0 +1,656 @@
+import invariant from "invariant";
+import { dalvikBytecodeOperationCompanion } from "./dalvikBytecodeParser.js";
+import { isDalvikExecutableField, isDalvikExecutableMethod } from "./dalvikExecutable.js";
+import { createExactSequenceParser } from "./exactSequenceParser.js";
+import { cloneParser, setParserName } from "./parser.js";
+import { promiseCompose } from "./promiseCompose.js";
+import { createTupleParser } from "./tupleParser.js";
+import { createUnionParser } from "./unionParser.js";
+import { createArrayParser } from "./arrayParser.js";
+import { jsonNumberParser, jsonStringParser } from "./jsonParser.js";
+import { createNonEmptyArrayParser } from "./nonEmptyArrayParser.js";
+import { createOptionalParser } from "./optionalParser.js";
+import { createNegativeLookaheadParser } from "./negativeLookaheadParser.js";
+import { createSeparatedArrayParser } from "./separatedArrayParser.js";
+import { smaliMemberNameParser, smaliTypeDescriptorParser } from "./dalvikExecutableParser/stringSyntaxParser.js";
+import { createDisjunctionParser } from "./disjunctionParser.js";
+const smaliNewlinesParser = promiseCompose(createNonEmptyArrayParser(createExactSequenceParser('\n')), (_newlines) => undefined);
+const smaliOptionalIndentationParser = promiseCompose(createArrayParser(createExactSequenceParser('    ')), (_indentation) => undefined);
+const smaliCommentParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('#'),
+    (async (parserContext) => {
+        const characters = [];
+        while (true) {
+            const character = await parserContext.peek(0);
+            parserContext.invariant(character !== undefined, 'Unexpected end of input');
+            invariant(character !== undefined, 'Unexpected end of input');
+            if (character !== '\n') {
+                characters.push(character);
+                parserContext.skip(1);
+                continue;
+            }
+            break;
+        }
+        return characters.join('');
+    }),
+]), ([_hash, comment,]) => comment);
+const smaliCommentsOrNewlinesParser = promiseCompose(createArrayParser(createUnionParser([
+    smaliNewlinesParser,
+    smaliCommentParser,
+])), (newlinesOrComments) => newlinesOrComments.filter((newlineOrComment) => typeof newlineOrComment === 'string'));
+const smaliIdentifierParser = async (parserContext) => {
+    const characters = [];
+    while (true) {
+        const character = await parserContext.peek(0);
+        parserContext.invariant(character !== undefined, 'Unexpected end of input');
+        invariant(character !== undefined, 'Unexpected end of input');
+        if (character === '_'
+            || (character >= 'a' && character <= 'z')
+            || (character >= 'A' && character <= 'Z')
+            || (character >= '0' && character <= '9')) {
+            parserContext.skip(1);
+            characters.push(character);
+            continue;
+        }
+        parserContext.invariant(characters.length > 0, 'Expected at least one character');
+        break;
+    }
+    return characters.join('');
+};
+setParserName(smaliIdentifierParser, 'smaliIdentifierParser');
+const smaliQuotedStringParser = jsonStringParser;
+const smaliAccessFlagsParser = promiseCompose(createSeparatedArrayParser(createUnionParser([
+    createExactSequenceParser('public'),
+    createExactSequenceParser('protected'),
+    createExactSequenceParser('private'),
+    createExactSequenceParser('final'),
+    createExactSequenceParser('brigde'),
+    createExactSequenceParser('synthetic'),
+    createExactSequenceParser('varargs'),
+    createExactSequenceParser('static'),
+    createExactSequenceParser('constructor'),
+    createExactSequenceParser('abstract'),
+    // ... TODO
+]), createExactSequenceParser(' ')), (accessFlagNames) => {
+    const accessFlags = {
+        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,
+    };
+    for (const accessFlagName of accessFlagNames) {
+        accessFlags[accessFlagName] = true;
+    }
+    return accessFlags;
+});
+const smaliClassDeclarationParser = promiseCompose(createTupleParser([
+    smaliCommentsOrNewlinesParser,
+    createExactSequenceParser('.class '),
+    smaliAccessFlagsParser,
+    createExactSequenceParser(' '),
+    smaliTypeDescriptorParser,
+    createExactSequenceParser('\n'),
+]), ([_commentsOrNewlines, _dotClass, accessFlags, _space, classPath, _newline,]) => ({
+    accessFlags,
+    class: classPath,
+}));
+setParserName(smaliClassDeclarationParser, 'smaliClassDeclarationParser');
+const smaliSuperDeclarationParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.super '),
+    smaliTypeDescriptorParser,
+    createExactSequenceParser('\n'),
+]), ([_super, superclass, _newline,]) => ({
+    superclass,
+}));
+setParserName(smaliSuperDeclarationParser, 'smaliSuperDeclarationParser');
+const smaliInterfaceDeclarationParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.implements '),
+    smaliTypeDescriptorParser,
+    createExactSequenceParser('\n'),
+]), ([_interface, interface_, _newline,]) => interface_);
+setParserName(smaliInterfaceDeclarationParser, 'smaliInterfaceDeclarationParser');
+const smaliSourceDeclarationParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.source '),
+    smaliQuotedStringParser,
+    createExactSequenceParser('\n'),
+]), ([_source, sourceFile, _newline,]) => ({
+    sourceFile,
+}));
+export const smaliFieldParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.field '),
+    smaliAccessFlagsParser,
+    createExactSequenceParser(' '),
+    smaliMemberNameParser,
+    createExactSequenceParser(':'),
+    smaliTypeDescriptorParser,
+    createExactSequenceParser('\n'),
+]), ([_field, accessFlags, _space, name, _colon, type,]) => {
+    return {
+        accessFlags,
+        field: {
+            class: 'FILLED_LATER',
+            type,
+            name,
+        },
+    };
+});
+setParserName(smaliFieldParser, 'smaliFieldParser');
+const smaliFieldsParser = promiseCompose(createArrayParser(createDisjunctionParser([
+    smaliFieldParser,
+    smaliCommentsOrNewlinesParser,
+])), (fieldsAndComments) => {
+    let type = 'instanceField';
+    const staticFields = [];
+    const instanceFields = [];
+    for (const fieldOrComment of fieldsAndComments) {
+        if (Array.isArray(fieldOrComment)) {
+            for (const comment of fieldOrComment) {
+                if (comment === ' static fields') {
+                    type = 'staticField';
+                }
+                if (comment === ' instance fields') {
+                    type = 'instanceField';
+                }
+            }
+            continue;
+        }
+        invariant(typeof fieldOrComment === 'object', 'Expected field or comment');
+        const field = fieldOrComment;
+        if (type === 'staticField') {
+            staticFields.push(field);
+            continue;
+        }
+        if (type === 'instanceField') {
+            instanceFields.push(field);
+            continue;
+        }
+        invariant(false, 'Expected field type');
+    }
+    return {
+        staticFields,
+        instanceFields,
+    };
+});
+setParserName(smaliFieldsParser, 'smaliFieldsParser');
+const smaliShortyFieldTypeParser = createUnionParser([
+    createExactSequenceParser('Z'),
+    createExactSequenceParser('B'),
+    createExactSequenceParser('S'),
+    createExactSequenceParser('C'),
+    createExactSequenceParser('I'),
+    createExactSequenceParser('J'),
+    createExactSequenceParser('F'),
+    createExactSequenceParser('D'),
+]);
+setParserName(smaliShortyFieldTypeParser, 'smaliShortyFieldTypeParser');
+const smaliShortyReturnTypeParser = createUnionParser([
+    createExactSequenceParser('V'),
+    smaliShortyFieldTypeParser,
+]);
+setParserName(smaliShortyReturnTypeParser, 'smaliShortyReturnTypeParser');
+function shortyFromLongy(longy) {
+    if (longy.startsWith('[')) {
+        return 'L';
+    }
+    return longy.slice(0, 1);
+}
+const smaliMethodPrototypeParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    createArrayParser(smaliTypeDescriptorParser),
+    createExactSequenceParser(')'),
+    smaliTypeDescriptorParser,
+]), ([_openParenthesis, parameters, _closeParenthesis, returnType,]) => ({
+    parameters,
+    returnType,
+    shorty: shortyFromLongy(returnType) + parameters.map((parameter) => {
+        if (parameter === 'V') {
+            return '';
+        }
+        return shortyFromLongy(parameter);
+    }).join(''),
+}));
+setParserName(smaliMethodPrototypeParser, 'smaliMethodPrototypeParser');
+const smaliCodeRegistersParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .registers '),
+    jsonNumberParser,
+    createExactSequenceParser('\n'),
+]), ([_registers, registers, _newline,]) => registers);
+setParserName(smaliCodeRegistersParser, 'smaliCodeRegistersParser');
+export const smaliAnnotationParser = promiseCompose(createTupleParser([
+    smaliOptionalIndentationParser,
+    createExactSequenceParser('.annotation '),
+    createUnionParser([
+        createExactSequenceParser('build'),
+        createExactSequenceParser('runtime'),
+        createExactSequenceParser('system'),
+    ]),
+    createExactSequenceParser(' '),
+    smaliTypeDescriptorParser,
+    createExactSequenceParser('\n'),
+    smaliOptionalIndentationParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('value = '),
+        createUnionParser([
+            smaliTypeDescriptorParser,
+            promiseCompose(createTupleParser([
+                createExactSequenceParser('{\n'),
+                createSeparatedArrayParser(promiseCompose(createTupleParser([
+                    smaliOptionalIndentationParser,
+                    smaliTypeDescriptorParser,
+                ]), ([_indentation, value,]) => value), createExactSequenceParser(',\n')),
+                createExactSequenceParser('\n'),
+                smaliOptionalIndentationParser,
+                createExactSequenceParser('}'),
+            ]), ([_openBrace, value, _closeBrace,]) => value),
+            promiseCompose(createTupleParser([
+                createExactSequenceParser('{\n'),
+                createSeparatedArrayParser(promiseCompose(createTupleParser([
+                    smaliOptionalIndentationParser,
+                    smaliQuotedStringParser,
+                ]), ([_indentation, value,]) => value), createExactSequenceParser(',\n')),
+                createExactSequenceParser('\n'),
+                smaliOptionalIndentationParser,
+                createExactSequenceParser('}'),
+            ]), ([_openBrace, value, _closeBrace,]) => value),
+        ]),
+        createExactSequenceParser('\n'),
+    ]), ([_indentation, value, _newline,]) => value)),
+    smaliOptionalIndentationParser,
+    createExactSequenceParser('.end annotation\n'),
+]), ([_indentation0, _annotation, _accessFlags, _space, type, _newline, _indentation1, value, _endAnnotation,]) => ({
+    type,
+    value,
+    // accessFlags,
+}));
+setParserName(smaliAnnotationParser, 'smaliAnnotationParser');
+const smaliCodeLineParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .line '),
+    jsonNumberParser,
+    createExactSequenceParser('\n'),
+]), ([_line, line, _newline,]) => line);
+setParserName(smaliCodeLineParser, 'smaliCodeLineParser');
+function isSmaliRegister(value) {
+    return (value !== null
+        && typeof value === 'object'
+        && 'prefix' in value
+        && 'index' in value
+        && typeof value.prefix === 'string'
+        && typeof value.index === 'number');
+}
+const smaliParametersRegisterParser = promiseCompose(createUnionParser([
+    createTupleParser([
+        createExactSequenceParser('v'),
+        jsonNumberParser,
+    ]),
+    createTupleParser([
+        createExactSequenceParser('p'),
+        jsonNumberParser,
+    ]),
+]), ([prefix, index,]) => ({
+    prefix,
+    index,
+}));
+setParserName(smaliParametersRegisterParser, 'smaliParametersRegisterParser');
+const smaliCodeLocalParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .local '),
+    smaliParametersRegisterParser,
+    createOptionalParser(createTupleParser([
+        createExactSequenceParser(','),
+        createArrayParser(createExactSequenceParser(' ')),
+        jsonStringParser,
+        createExactSequenceParser(':'),
+        smaliTypeDescriptorParser,
+    ])),
+    createExactSequenceParser('\n'),
+]), ([_local, local, _newlocal,]) => local);
+setParserName(smaliCodeLocalParser, 'smaliCodeLocalParser');
+export const smaliCodeParameterParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    .param '),
+    smaliParametersRegisterParser,
+    createOptionalParser(createTupleParser([
+        createExactSequenceParser(','),
+        createArrayParser(createExactSequenceParser(' ')),
+        jsonStringParser,
+        createArrayParser(createExactSequenceParser(' ')),
+    ])),
+    createOptionalParser(smaliCommentParser),
+    createExactSequenceParser('\n'),
+]), ([_param, parameter, _newparam, _commentOrNewline,]) => parameter);
+setParserName(smaliCodeParameterParser, 'smaliCodeParameterParser');
+const smaliCodeLabelParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    :'),
+    smaliIdentifierParser,
+    createExactSequenceParser('\n'),
+]), ([_label, label, _newlabel,]) => label);
+setParserName(smaliCodeLabelParser, 'smaliCodeLabelParser');
+const smaliParametersRegistersParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('{'),
+    createArrayParser(promiseCompose(createTupleParser([
+        smaliParametersRegisterParser,
+        createOptionalParser(createExactSequenceParser(', ')),
+    ]), ([parameter, _comma,]) => parameter)),
+    createExactSequenceParser('}'),
+]), ([_openBrace, parameters, _closeBrace,]) => parameters);
+setParserName(smaliParametersRegistersParser, 'smaliParametersRegistersParser');
+const smaliParametersStringParser = cloneParser(smaliQuotedStringParser);
+setParserName(smaliParametersStringParser, 'smaliParametersStringParser');
+const smaliParametersIntegerParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('0x'),
+    async (parserContext) => {
+        const characters = [];
+        while (true) {
+            const character = await parserContext.peek(0);
+            parserContext.invariant(character !== undefined, 'Unexpected end of input');
+            invariant(character !== undefined, 'Unexpected end of input');
+            if ((character >= '0' && character <= '9')
+                || (character >= 'a' && character <= 'f')
+                || (character >= 'A' && character <= 'F')) {
+                characters.push(character);
+                parserContext.skip(1);
+                continue;
+            }
+            break;
+        }
+        return characters.join('');
+    },
+    createOptionalParser(createExactSequenceParser('L')),
+]), ([_0x, value, optionalL,]) => {
+    if (optionalL) {
+        return BigInt('0x' + value);
+    }
+    return parseInt(value, 16);
+});
+setParserName(smaliParametersIntegerParser, 'smaliParametersIntegerParser');
+const smaliParametersLabelParser = promiseCompose(createTupleParser([
+    createExactSequenceParser(':'),
+    smaliIdentifierParser,
+]), ([_label, label,]) => label);
+setParserName(smaliParametersLabelParser, 'smaliParametersLabelParser');
+const smaliParametersTypeParser = cloneParser(smaliTypeDescriptorParser);
+setParserName(smaliParametersTypeParser, 'smaliParametersTypeParser');
+const smaliParametersMethodParser = promiseCompose(createTupleParser([
+    smaliTypeDescriptorParser,
+    createExactSequenceParser('->'),
+    smaliMemberNameParser,
+    smaliMethodPrototypeParser,
+]), ([classPath, _separator, methodName, prototype,]) => ({
+    class: classPath,
+    prototype,
+    name: methodName,
+}));
+setParserName(smaliParametersMethodParser, 'smaliParametersMethodParser');
+const smaliParametersFieldParser = promiseCompose(createTupleParser([
+    smaliTypeDescriptorParser,
+    createExactSequenceParser('->'),
+    smaliMemberNameParser,
+    createExactSequenceParser(':'),
+    smaliTypeDescriptorParser,
+]), ([classPath, _separator, fieldName, _colon, type,]) => ({
+    class: classPath,
+    name: fieldName,
+    type,
+}));
+setParserName(smaliParametersFieldParser, 'smaliParametersFieldParser');
+const smaliCodeOperationParametersParser = createArrayParser(promiseCompose(createTupleParser([
+    createUnionParser([
+        smaliParametersRegisterParser,
+        smaliParametersRegistersParser,
+        smaliParametersStringParser,
+        smaliParametersIntegerParser,
+        smaliParametersLabelParser,
+        promiseCompose(createTupleParser([
+            createNegativeLookaheadParser(smaliParametersMethodParser),
+            createNegativeLookaheadParser(smaliParametersFieldParser),
+            smaliParametersTypeParser,
+        ]), ([_notMethod, _notField, type,]) => type),
+        smaliParametersMethodParser,
+        smaliParametersFieldParser,
+    ]),
+    createOptionalParser(createExactSequenceParser(', ')),
+]), ([parameter, _comma,]) => parameter));
+setParserName(smaliCodeOperationParametersParser, 'smaliCodeOperationParametersParser');
+const smaliCodeOperationNameParser = promiseCompose(createTupleParser([
+    promiseCompose(createSeparatedArrayParser(smaliIdentifierParser, createExactSequenceParser('-')), (parts) => parts.join('-')),
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('/'),
+        smaliIdentifierParser,
+    ]), ([slash, name]) => slash + name)),
+]), ([name, optionalSlashName,]) => name + (optionalSlashName || ''));
+setParserName(smaliCodeOperationNameParser, 'smaliCodeOperationNameParser');
+const smaliCodeOperationParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('    '),
+    smaliCodeOperationNameParser,
+    promiseCompose(createOptionalParser(createTupleParser([
+        createExactSequenceParser(' '),
+        smaliCodeOperationParametersParser,
+    ])), (undefinedOrParameters) => undefinedOrParameters === undefined ? [] : undefinedOrParameters[1]),
+    createExactSequenceParser('\n'),
+]), ([_indent, operation, parameters, _newline,]) => ({
+    operation,
+    parameters,
+}));
+setParserName(smaliCodeOperationParser, 'smaliCodeOperationParser');
+const operationsWithTypeArgument = new Set([
+    'new-instance',
+    'check-cast',
+    'instance-of',
+]);
+const smaliAnnotatedCodeOperationParser = promiseCompose(createTupleParser([
+    createArrayParser(smaliCodeLineParser),
+    createOptionalParser(smaliCodeLocalParser),
+    createArrayParser(smaliCodeLabelParser),
+    smaliCodeOperationParser,
+]), ([_lines, _local, _labels, operation,]) => {
+    const operation_ = {
+        operation: operation.operation,
+        // line,
+        // local,
+        // label,
+        // parameters: (operation as any).parameters,
+    }; // TODO
+    for (const parameter of operation.parameters.flat() ?? []) {
+        if (isDalvikExecutableMethod(parameter)) {
+            operation_.method = parameter;
+            continue;
+        }
+        if (isDalvikExecutableField(parameter)) {
+            operation_.field = parameter;
+            continue;
+        }
+        if (isSmaliRegister(parameter)) {
+            if (!operation_.registers) {
+                operation_.registers = [];
+            }
+            operation_.registers.push(parameter);
+            continue;
+        }
+        if (typeof parameter === 'string') {
+            if (operationsWithTypeArgument.has(operation_.operation)) {
+                operation_.type = parameter;
+                continue;
+            }
+            operation_.string = parameter;
+            continue;
+        }
+        if (typeof parameter === 'number' || typeof parameter === 'bigint') {
+            operation_.value = parameter;
+            continue;
+        }
+        invariant(false, 'TODO: parameter: %s, operation: %s', JSON.stringify(parameter), JSON.stringify(operation));
+    }
+    if (operation_.registers) {
+        operation_.registers = operation_.registers.reverse();
+    }
+    return operation_;
+});
+setParserName(smaliCodeOperationParser, 'smaliCodeOperationParser');
+const smaliExecutableCodeParser = promiseCompose(createTupleParser([
+    smaliCodeRegistersParser,
+    createArrayParser(smaliAnnotationParser),
+    createOptionalParser(smaliCodeParameterParser),
+    createArrayParser(promiseCompose(createTupleParser([
+        createOptionalParser(smaliCommentsOrNewlinesParser),
+        smaliAnnotatedCodeOperationParser,
+    ]), ([_commentsOrNewlines, operation,]) => operation)),
+]), ([registersSize, _annotations, _parameters, instructions,]) => {
+    return {
+        registersSize,
+        insSize: -1, // TODO
+        outsSize: -1, // TODO
+        debugInfo: undefined, // TODO
+        instructions,
+        tries: [], // TODO
+        // _annotations,
+    };
+});
+setParserName(smaliExecutableCodeParser, 'smaliExecutableCodeParser');
+const smaliMethodParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.method '),
+    smaliAccessFlagsParser,
+    createExactSequenceParser(' '),
+    smaliMemberNameParser,
+    smaliMethodPrototypeParser,
+    createExactSequenceParser('\n'),
+    smaliExecutableCodeParser,
+    createArrayParser(smaliCodeLineParser),
+    createExactSequenceParser('.end method\n'),
+]), ([_method, accessFlags, _space, name, prototype, _newline, code, _lines, _endMethod,]) => {
+    let insSize = 1;
+    for (const _parameter of prototype.parameters) {
+        insSize += 1; // TODO: two words for wide types
+    }
+    code.insSize = insSize;
+    for (const operation of code.instructions) {
+        const smaliRegisters = dalvikBytecodeOperationCompanion.getRegisters(operation); // TODO
+        if (!smaliRegisters.length) {
+            continue;
+        }
+        const registers = smaliRegisters.map(({ prefix, index }) => {
+            if (prefix === 'v') {
+                return index;
+            }
+            if (prefix === 'p') {
+                return code.registersSize - insSize + index;
+            }
+            invariant(false, 'Expected prefix to be v or p');
+        });
+        operation.registers = registers; // TODO
+    }
+    let outsSize = 0;
+    for (const operation of code.instructions) {
+        const registers = dalvikBytecodeOperationCompanion.getRegisters(operation);
+        outsSize = Math.max(outsSize, registers.length); // TODO: two words for wide types
+    }
+    code.outsSize = outsSize;
+    return {
+        accessFlags,
+        method: {
+            class: 'FILLED_LATER',
+            prototype,
+            name,
+        },
+        code,
+    };
+});
+setParserName(smaliMethodParser, 'smaliMethodParser');
+const smaliMethodsParser = promiseCompose(createArrayParser(createDisjunctionParser([
+    smaliMethodParser,
+    smaliCommentsOrNewlinesParser,
+])), (methodsAndComments) => {
+    let type = 'directMethod';
+    const directMethods = [];
+    const virtualMethods = [];
+    for (const methodOrComment of methodsAndComments) {
+        if (Array.isArray(methodOrComment)) {
+            for (const comment of methodOrComment) {
+                if (comment === ' direct methods') {
+                    type = 'directMethod';
+                }
+                if (comment === ' virtual methods') {
+                    type = 'virtualMethod';
+                }
+            }
+            continue;
+        }
+        invariant(typeof methodOrComment === 'object', 'Expected method or comment');
+        const method = methodOrComment;
+        if (type === 'directMethod') {
+            directMethods.push(method);
+            continue;
+        }
+        if (type === 'virtualMethod') {
+            virtualMethods.push(method);
+            continue;
+        }
+        invariant(false, 'Expected method type');
+    }
+    return {
+        directMethods,
+        virtualMethods,
+    };
+});
+setParserName(smaliMethodsParser, 'smaliMethodsParser');
+export const smaliParser = promiseCompose(createTupleParser([
+    smaliClassDeclarationParser,
+    smaliSuperDeclarationParser,
+    smaliSourceDeclarationParser,
+    smaliCommentsOrNewlinesParser,
+    createArrayParser(smaliInterfaceDeclarationParser),
+    smaliCommentsOrNewlinesParser,
+    createOptionalParser(smaliFieldsParser),
+    smaliMethodsParser,
+]), ([{ accessFlags, class: class_, }, { superclass, }, { sourceFile, }, _commentsOrNewlines0, interfaces, _commentsOrNewlines1, fields, methods,]) => ({
+    accessFlags,
+    class: class_,
+    superclass,
+    sourceFile,
+    annotations: undefined, // TODO
+    classData: {
+        directMethods: methods.directMethods.map((method) => ({
+            ...method,
+            method: {
+                ...method.method,
+                class: class_,
+            },
+        })),
+        virtualMethods: methods.virtualMethods.map((method) => ({
+            ...method,
+            method: {
+                ...method.method,
+                class: class_,
+            },
+        })),
+        staticFields: (fields?.staticFields ?? []).map((field) => ({
+            ...field,
+            field: {
+                ...field.field,
+                class: class_,
+            },
+        })),
+        instanceFields: (fields?.instanceFields ?? []).map((field) => ({
+            ...field,
+            field: {
+                ...field.field,
+                class: class_,
+            },
+        })),
+    },
+    interfaces,
+    staticValues: [], // TODO
+}));
+setParserName(smaliParser, 'smaliParser');

package/build/smaliParser.test.d.ts

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