@futpib/parser 1.0.2 → 1.0.4

package/build/bashParser.js

@@ -0,0 +1,294 @@
+import { setParserName } from './parser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createArrayParser } from './arrayParser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { createOptionalParser } from './optionalParser.js';
+import { createRegExpParser } from './regexpParser.js';
+import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
+import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
+// Whitespace (spaces and tabs, not newlines - those are significant)
+const bashInlineWhitespaceParser = promiseCompose(createRegExpParser(/[ \t]+/), match => match[0]);
+const bashOptionalInlineWhitespaceParser = promiseCompose(createRegExpParser(/[ \t]*/), match => match[0]);
+// Newline
+const bashNewlineParser = promiseCompose(createRegExpParser(/\n/), match => match[0]);
+// Word characters (unquoted, no special chars)
+// Note: {} are excluded so brace groups are parsed correctly
+const bashUnquotedWordCharsParser = promiseCompose(createRegExpParser(/[^\s\n|&;<>(){}$`"'\\#]+/), match => match[0]);
+// Single quoted string: '...'
+const bashSingleQuotedParser = promiseCompose(createTupleParser([
+    createExactSequenceParser("'"),
+    promiseCompose(createRegExpParser(/[^']*/), match => match[0]),
+    createExactSequenceParser("'"),
+]), ([, value]) => ({
+    type: 'singleQuoted',
+    value,
+}));
+// Variable name
+const bashVariableNameParser = promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*|[0-9]+|[@*#?$!-]/), match => match[0]);
+// Simple variable: $var
+const bashSimpleVariableParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('$'),
+    bashVariableNameParser,
+]), ([, name]) => ({
+    type: 'variable',
+    name,
+}));
+// Command substitution: $(...)
+const bashCommandSubstitutionParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('$('),
+    bashOptionalInlineWhitespaceParser,
+    createParserAccessorParser(() => bashCommandParser),
+    bashOptionalInlineWhitespaceParser,
+    createExactSequenceParser(')'),
+]), ([, , command]) => ({
+    type: 'commandSubstitution',
+    command,
+}));
+// Backtick substitution: `...`
+const bashBacktickSubstitutionParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('`'),
+    createParserAccessorParser(() => bashCommandParser),
+    createExactSequenceParser('`'),
+]), ([, command]) => ({
+    type: 'backtickSubstitution',
+    command,
+}));
+// Double quoted string parts (inside "...")
+const bashDoubleQuotedPartParser = createDisjunctionParser([
+    bashSimpleVariableParser,
+    bashCommandSubstitutionParser,
+    bashBacktickSubstitutionParser,
+    // Escape sequences in double quotes
+    promiseCompose(createRegExpParser(/\\[\\$`"!\n]/), match => ({
+        type: 'literal',
+        value: match[0].slice(1),
+    })),
+    // Literal text (no special chars)
+    promiseCompose(createRegExpParser(/[^$`"\\]+/), match => ({
+        type: 'literal',
+        value: match[0],
+    })),
+]);
+// Double quoted string: "..."
+const bashDoubleQuotedParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('"'),
+    createArrayParser(bashDoubleQuotedPartParser),
+    createExactSequenceParser('"'),
+]), ([, parts]) => ({
+    type: 'doubleQuoted',
+    parts,
+}));
+// Literal word part (unquoted)
+const bashLiteralWordPartParser = promiseCompose(bashUnquotedWordCharsParser, value => ({
+    type: 'literal',
+    value,
+}));
+// Escape sequence outside quotes
+const bashEscapeParser = promiseCompose(createRegExpParser(/\\./), match => ({
+    type: 'literal',
+    value: match[0].slice(1),
+}));
+// Word part (any part of a word)
+const bashWordPartParser = createDisjunctionParser([
+    bashSingleQuotedParser,
+    bashDoubleQuotedParser,
+    bashCommandSubstitutionParser,
+    bashBacktickSubstitutionParser,
+    bashSimpleVariableParser,
+    bashEscapeParser,
+    bashLiteralWordPartParser,
+]);
+// Word (sequence of word parts)
+export const bashWordParser = promiseCompose(createNonEmptyArrayParser(bashWordPartParser), parts => ({ parts }));
+setParserName(bashWordParser, 'bashWordParser');
+// Assignment: NAME=value or NAME=
+const bashAssignmentParser = promiseCompose(createTupleParser([
+    promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*=/), match => match[0].slice(0, -1)),
+    createOptionalParser(bashWordParser),
+]), ([name, value]) => ({
+    name,
+    value: value ?? undefined,
+}));
+// Redirect operators
+const bashRedirectOperatorParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('>>'), () => '>>'),
+    promiseCompose(createExactSequenceParser('>&'), () => '>&'),
+    promiseCompose(createExactSequenceParser('>|'), () => '>|'),
+    promiseCompose(createExactSequenceParser('>'), () => '>'),
+    promiseCompose(createExactSequenceParser('<<<'), () => '<<<'),
+    promiseCompose(createExactSequenceParser('<<'), () => '<<'),
+    promiseCompose(createExactSequenceParser('<&'), () => '<&'),
+    promiseCompose(createExactSequenceParser('<'), () => '<'),
+]);
+// Redirect: [n]op word
+const bashRedirectParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createRegExpParser(/[0-9]+/), match => Number.parseInt(match[0], 10))),
+    bashRedirectOperatorParser,
+    bashOptionalInlineWhitespaceParser,
+    bashWordParser,
+]), ([fd, operator, , target]) => ({
+    fd: fd ?? undefined,
+    operator,
+    target,
+}));
+// Word with optional trailing whitespace - for use in arrays
+const bashWordWithWhitespaceParser = promiseCompose(createTupleParser([
+    bashWordParser,
+    bashOptionalInlineWhitespaceParser,
+]), ([word]) => word);
+// Redirect with optional trailing whitespace
+const bashRedirectWithWhitespaceParser = promiseCompose(createTupleParser([
+    bashRedirectParser,
+    bashOptionalInlineWhitespaceParser,
+]), ([redirect]) => redirect);
+// Word or redirect - for interleaved parsing in simple commands
+const bashWordOrRedirectParser = createDisjunctionParser([
+    promiseCompose(bashRedirectWithWhitespaceParser, redirect => ({ type: 'redirect', redirect })),
+    promiseCompose(bashWordWithWhitespaceParser, word => ({ type: 'word', word })),
+]);
+// Simple command: [assignments] [name] [args] [redirects]
+export const bashSimpleCommandParser = promiseCompose(createTupleParser([
+    // Assignments at the start
+    createArrayParser(promiseCompose(createTupleParser([
+        bashAssignmentParser,
+        bashOptionalInlineWhitespaceParser,
+    ]), ([assignment]) => assignment)),
+    // Command name, args, and redirects (interleaved)
+    createArrayParser(bashWordOrRedirectParser),
+]), ([assignments, items]) => {
+    const words = [];
+    const redirects = [];
+    for (const item of items) {
+        if (item.type === 'word') {
+            words.push(item.word);
+        }
+        else {
+            redirects.push(item.redirect);
+        }
+    }
+    const [name, ...args] = words;
+    return {
+        type: 'simple',
+        name,
+        args,
+        redirects,
+        assignments,
+    };
+});
+setParserName(bashSimpleCommandParser, 'bashSimpleCommandParser');
+// Subshell: ( command )
+const bashSubshellParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    bashOptionalInlineWhitespaceParser,
+    createParserAccessorParser(() => bashCommandParser),
+    bashOptionalInlineWhitespaceParser,
+    createExactSequenceParser(')'),
+]), ([, , body]) => ({
+    type: 'subshell',
+    body,
+}));
+setParserName(bashSubshellParser, 'bashSubshellParser');
+// Brace group: { command; }
+const bashBraceGroupParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('{'),
+    bashInlineWhitespaceParser,
+    createParserAccessorParser(() => bashCommandParser),
+    bashOptionalInlineWhitespaceParser,
+    createOptionalParser(createExactSequenceParser(';')),
+    bashOptionalInlineWhitespaceParser,
+    createExactSequenceParser('}'),
+]), ([, , body]) => ({
+    type: 'braceGroup',
+    body,
+}));
+setParserName(bashBraceGroupParser, 'bashBraceGroupParser');
+// Command unit: simple command, subshell, or brace group
+const bashCommandUnitParser = createDisjunctionParser([
+    bashSubshellParser,
+    bashBraceGroupParser,
+    bashSimpleCommandParser,
+]);
+setParserName(bashCommandUnitParser, 'bashCommandUnitParser');
+// Single pipe (not ||) - matches | only when not followed by another |
+const bashSinglePipeParser = promiseCompose(createRegExpParser(/\|(?!\|)/), match => match[0]);
+// Pipeline: [!] cmd [| cmd]...
+const bashPipelineParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('!'),
+        bashInlineWhitespaceParser,
+    ]), () => true)),
+    createSeparatedNonEmptyArrayParser(bashCommandUnitParser, createTupleParser([
+        bashOptionalInlineWhitespaceParser,
+        bashSinglePipeParser,
+        bashOptionalInlineWhitespaceParser,
+    ])),
+]), ([negated, commands]) => ({
+    type: 'pipeline',
+    negated: negated ?? false,
+    commands,
+}));
+setParserName(bashPipelineParser, 'bashPipelineParser');
+// Command list separator
+const bashListSeparatorParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('&&'), () => '&&'),
+    promiseCompose(createExactSequenceParser('||'), () => '||'),
+    promiseCompose(createExactSequenceParser(';'), () => ';'),
+    promiseCompose(createExactSequenceParser('&'), () => '&'),
+    promiseCompose(bashNewlineParser, () => '\n'),
+]);
+// Command list: pipeline [sep pipeline]...
+const bashCommandListParser = promiseCompose(createTupleParser([
+    bashPipelineParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        bashOptionalInlineWhitespaceParser,
+        bashListSeparatorParser,
+        bashOptionalInlineWhitespaceParser,
+        bashPipelineParser,
+    ]), ([, separator, , pipeline]) => ({ separator, pipeline }))),
+    createOptionalParser(promiseCompose(createTupleParser([
+        bashOptionalInlineWhitespaceParser,
+        bashListSeparatorParser,
+    ]), ([, separator]) => separator)),
+]), ([firstPipeline, rest, trailingSeparator]) => {
+    const entries = [];
+    if (rest.length === 0) {
+        entries.push({
+            pipeline: firstPipeline,
+            separator: trailingSeparator ?? undefined,
+        });
+    }
+    else {
+        entries.push({
+            pipeline: firstPipeline,
+            separator: rest[0].separator,
+        });
+        for (let i = 0; i < rest.length - 1; i++) {
+            entries.push({
+                pipeline: rest[i].pipeline,
+                separator: rest[i + 1].separator,
+            });
+        }
+        entries.push({
+            pipeline: rest[rest.length - 1].pipeline,
+            separator: trailingSeparator ?? undefined,
+        });
+    }
+    return {
+        type: 'list',
+        entries,
+    };
+});
+setParserName(bashCommandListParser, 'bashCommandListParser');
+// Top-level command parser
+export const bashCommandParser = bashCommandListParser;
+setParserName(bashCommandParser, 'bashCommandParser');
+// Script parser (handles leading/trailing whitespace)
+export const bashScriptParser = promiseCompose(createTupleParser([
+    bashOptionalInlineWhitespaceParser,
+    bashCommandParser,
+    bashOptionalInlineWhitespaceParser,
+]), ([, command]) => command);
+setParserName(bashScriptParser, 'bashScriptParser');

package/build/bashParser.test.d.ts

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

package/build/bashParser.test.js

@@ -0,0 +1,181 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { bashScriptParser, bashWordParser, bashSimpleCommandParser } from './bashParser.js';
+test('simple command parser - single word', async (t) => {
+    const result = await runParser(bashSimpleCommandParser, 'cmd', stringParserInputCompanion, { errorStack: true });
+    t.is(result.type, 'simple');
+    t.deepEqual(result.name, { parts: [{ type: 'literal', value: 'cmd' }] });
+});
+test('simple command parser - two words', async (t) => {
+    const result = await runParser(bashSimpleCommandParser, 'echo hello', stringParserInputCompanion);
+    t.is(result.type, 'simple');
+    t.deepEqual(result.name, { parts: [{ type: 'literal', value: 'echo' }] });
+    t.is(result.args.length, 1);
+});
+test('word parser - simple literal', async (t) => {
+    const result = await runParser(bashWordParser, 'hello', stringParserInputCompanion);
+    t.deepEqual(result, {
+        parts: [{ type: 'literal', value: 'hello' }],
+    });
+});
+test('word parser - variable', async (t) => {
+    const result = await runParser(bashWordParser, '$HOME', stringParserInputCompanion);
+    t.deepEqual(result, {
+        parts: [{ type: 'variable', name: 'HOME' }],
+    });
+});
+test('simple command', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'list',
+        entries: [{
+                pipeline: {
+                    type: 'pipeline',
+                    negated: false,
+                    commands: [{
+                            type: 'simple',
+                            name: { parts: [{ type: 'literal', value: 'echo' }] },
+                            args: [{ parts: [{ type: 'literal', value: 'hello' }] }],
+                            redirects: [],
+                            assignments: [],
+                        }],
+                },
+                separator: undefined,
+            }],
+    });
+});
+test('simple command with multiple args', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello world', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands[0].type, 'simple');
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 2);
+    }
+});
+test('pipeline', async (t) => {
+    const result = await runParser(bashScriptParser, 'cat file | grep pattern', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands.length, 2);
+});
+test('redirect output', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo > file', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.redirects.length, 1);
+        t.is(cmd.redirects[0].operator, '>');
+    }
+});
+test('redirect with fd', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd 2>&1', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.redirects.length, 1);
+        t.is(cmd.redirects[0].fd, 2);
+        t.is(cmd.redirects[0].operator, '>&');
+    }
+});
+test('single quoted string', async (t) => {
+    const result = await runParser(bashScriptParser, "echo 'hello world'", stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'singleQuoted', value: 'hello world' }],
+        });
+    }
+});
+test('double quoted string with variable', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "hello $name"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{
+                    type: 'doubleQuoted',
+                    parts: [
+                        { type: 'literal', value: 'hello ' },
+                        { type: 'variable', name: 'name' },
+                    ],
+                }],
+        });
+    }
+});
+test('simple variable', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $HOME', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'variable', name: 'HOME' }],
+        });
+    }
+});
+test('command substitution', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $(pwd)', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'commandSubstitution');
+    }
+});
+test('backtick substitution', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo `pwd`', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'backtickSubstitution');
+    }
+});
+test('subshell', async (t) => {
+    const result = await runParser(bashScriptParser, '(cd dir; pwd)', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands[0].type, 'subshell');
+});
+test('brace group', async (t) => {
+    const result = await runParser(bashScriptParser, '{ echo hello; }', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands[0].type, 'braceGroup');
+});
+test('command list with &&', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd1 && cmd2', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+    t.is(result.entries[0].separator, '&&');
+});
+test('command list with ||', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd1 || cmd2', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+    t.is(result.entries[0].separator, '||');
+});
+test('command list with ;', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd1; cmd2', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+    t.is(result.entries[0].separator, ';');
+});
+test('background command', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd &', stringParserInputCompanion);
+    t.is(result.entries[0].separator, '&');
+});
+test('assignment', async (t) => {
+    const result = await runParser(bashScriptParser, 'VAR=value cmd', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.assignments.length, 1);
+        t.is(cmd.assignments[0].name, 'VAR');
+    }
+});
+test('negated pipeline', async (t) => {
+    const result = await runParser(bashScriptParser, '! cmd', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.negated, true);
+});
+test('complex pipeline with redirects', async (t) => {
+    const result = await runParser(bashScriptParser, 'cat file 2>/dev/null | grep pattern | sort > output', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands.length, 3);
+});
+test('[[ treated as command name', async (t) => {
+    const result = await runParser(bashScriptParser, '[[ -f file ]]', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.name, { parts: [{ type: 'literal', value: '[[' }] });
+        t.is(cmd.args.length, 3); // -f, file, ]]
+    }
+});
+test('if treated as command name', async (t) => {
+    const result = await runParser(bashScriptParser, 'if true', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.name, { parts: [{ type: 'literal', value: 'if' }] });
+    }
+});

package/build/customInvariant.d.ts

@@ -1,4 +1,5 @@
 import { type Constructor } from 'type-fest';
+import { LazyMessage, LazyMessageError } from './lazyMessageError.js';
 export type Falsy = '' | 0 | false | undefined;
 export type ValueOrAccessor<T> = T | (() => T);
-export declare function customInvariant<T>(ErrorConstructor: Constructor<Error, [message: string]> | ((message: string) => Error), value: T, formatOrFormatLines: ValueOrAccessor<string | string[]>, ...formatArguments: (unknown | (() => unknown))[]): Exclude<T, Falsy>;
+export declare function customInvariant<T>(ErrorConstructor: Constructor<LazyMessageError, [LazyMessage]> | ((lazyMessage: LazyMessage) => LazyMessageError), value: T, formatOrFormatLines: ValueOrAccessor<string | string[]>, ...formatArguments: Array<unknown | (() => unknown)>): Exclude<T, Falsy>;

package/build/customInvariant.js

@@ -2,10 +2,8 @@ export function customInvariant(ErrorConstructor, value, formatOrFormatLines, ..
     if (value) {
         return value;
     }
-    let format = typeof formatOrFormatLines === 'function' ? formatOrFormatLines() : formatOrFormatLines;
-    format = Array.isArray(format) ? format.join('\n') : format;
-    throw new ErrorConstructor(format.replaceAll('%s', () => {
-        const argumentOrAccessor = formatArguments.shift();
-        return typeof argumentOrAccessor === 'function' ? argumentOrAccessor() : argumentOrAccessor;
-    }));
+    throw new ErrorConstructor([
+        formatOrFormatLines,
+        ...formatArguments,
+    ]);
 }

package/build/dalvikBytecodeParser/formatParsers.d.ts

@@ -1,5 +1,5 @@
-import { Iso } from "monocle-ts";
-import { Parser } from "../parser.js";
+import { type Iso } from 'monocle-ts';
+import { type Parser } from '../parser.js';
 export declare const nibblesParser: Parser<[number, number], Uint8Array>;
 type DalvikBytecodeFormat10t = {
     branchOffset: number;
@@ -11,6 +11,11 @@ type DalvikBytecodeFormat11x = {
     registers: number[];
 };
 export declare const dalvikBytecodeFormat11xParser: Parser<DalvikBytecodeFormat11x, Uint8Array>;
+type DalvikBytecodeFormat11n = {
+    value: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat11nParser: Parser<DalvikBytecodeFormat11n, Uint8Array>;
 type DalvikBytecodeFormat12x = {
     registers: number[];
 };
@@ -71,11 +76,27 @@ type DalvikBytecodeFormat23x = {
     registers: number[];
 };
 export declare const dalvikBytecodeFormat23xParser: Parser<DalvikBytecodeFormat23x, Uint8Array>;
+type DalvikBytecodeFormat30t = {
+    branchOffset: number;
+};
+export declare const dalvikBytecodeFormat30tParser: Parser<DalvikBytecodeFormat30t, Uint8Array>;
 type DalvikBytecodeFormat31i = {
     value: number;
     registers: number[];
 };
 export declare const dalvikBytecodeFormat31iParser: Parser<DalvikBytecodeFormat31i, Uint8Array>;
+type DalvikBytecodeFormat31c<Index> = {
+    index: Index;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat31cParser: <Index>({ isoIndex, }: {
+    isoIndex: Iso<Index, number>;
+}) => Parser<DalvikBytecodeFormat31c<Index>, Uint8Array>;
+type DalvikBytecodeFormat31t = {
+    branchOffset: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat31tParser: Parser<DalvikBytecodeFormat31t, Uint8Array>;
 type DalvikBytecodeFormat32x = {
     registers: number[];
 };
@@ -94,4 +115,57 @@ type DalvikBytecodeFormat3rc<Index> = {
 export declare const createDalvikBytecodeFormat3rcParser: <Index>({ isoIndex, }: {
     isoIndex: Iso<Index, number>;
 }) => Parser<DalvikBytecodeFormat3rc<Index>, Uint8Array>;
+type DalvikBytecodeFormat51l = {
+    value: bigint;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat51lParser: Parser<DalvikBytecodeFormat51l, Uint8Array>;
+type DalvikBytecodeFormat20bc = {
+    kind: number;
+    index: number;
+};
+export declare const dalvikBytecodeFormat20bcParser: Parser<DalvikBytecodeFormat20bc, Uint8Array>;
+type DalvikBytecodeFormat22cs = {
+    registers: number[];
+    fieldOffset: number;
+};
+export declare const dalvikBytecodeFormat22csParser: Parser<DalvikBytecodeFormat22cs, Uint8Array>;
+type DalvikBytecodeFormat35mi = {
+    inlineIndex: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat35miParser: Parser<DalvikBytecodeFormat35mi, Uint8Array>;
+type DalvikBytecodeFormat35ms = {
+    vtableOffset: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat35msParser: Parser<DalvikBytecodeFormat35ms, Uint8Array>;
+type DalvikBytecodeFormat3rmi = {
+    inlineIndex: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat3rmiParser: Parser<DalvikBytecodeFormat3rmi, Uint8Array>;
+type DalvikBytecodeFormat3rms = {
+    vtableOffset: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat3rmsParser: Parser<DalvikBytecodeFormat3rms, Uint8Array>;
+type DalvikBytecodeFormat45cc<MethodIndex, ProtoIndex> = {
+    methodIndex: MethodIndex;
+    protoIndex: ProtoIndex;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat45ccParser: <MethodIndex, ProtoIndex>({ isoMethodIndex, isoProtoIndex, }: {
+    isoMethodIndex: Iso<MethodIndex, number>;
+    isoProtoIndex: Iso<ProtoIndex, number>;
+}) => Parser<DalvikBytecodeFormat45cc<MethodIndex, ProtoIndex>, Uint8Array>;
+type DalvikBytecodeFormat4rcc<MethodIndex, ProtoIndex> = {
+    methodIndex: MethodIndex;
+    protoIndex: ProtoIndex;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat4rccParser: <MethodIndex, ProtoIndex>({ isoMethodIndex, isoProtoIndex, }: {
+    isoMethodIndex: Iso<MethodIndex, number>;
+    isoProtoIndex: Iso<ProtoIndex, number>;
+}) => Parser<DalvikBytecodeFormat4rcc<MethodIndex, ProtoIndex>, Uint8Array>;
 export {};