@futpib/parser 1.0.7 → 1.0.8

package/src/arbitraryBash.ts

@@ -0,0 +1,237 @@
+import * as fc from 'fast-check';
+import {
+	type BashWord,
+	type BashWordPart,
+	type BashWordPartLiteral,
+	type BashWordPartSingleQuoted,
+	type BashWordPartDoubleQuoted,
+	type BashWordPartVariable,
+	type BashWordPartVariableBraced,
+	type BashWordPartArithmeticExpansion,
+	type BashSimpleCommand,
+	type BashSubshell,
+	type BashBraceGroup,
+	type BashCommandUnit,
+	type BashPipeline,
+	type BashCommandList,
+	type BashRedirect,
+	type BashAssignment,
+} from './bash.js';
+
+const arbitraryBashIdentifier: fc.Arbitrary<string> = fc.stringMatching(/^[a-zA-Z_][a-zA-Z0-9_]*$/);
+
+// Safe unquoted literal: no shell special chars, no leading {/} or #, no = (would be parsed as assignment)
+const arbitraryBashWordPartLiteral: fc.Arbitrary<BashWordPartLiteral> = fc.record({
+	type: fc.constant('literal' as const),
+	value: fc.stringMatching(/^[a-zA-Z0-9][a-zA-Z0-9._@%,:^~-]*$/),
+});
+
+// Single-quoted: no single quotes, no newlines inside (keep simple)
+const arbitraryBashWordPartSingleQuoted: fc.Arbitrary<BashWordPartSingleQuoted> = fc.record({
+	type: fc.constant('singleQuoted' as const),
+	value: fc.stringMatching(/^[^'\n]*$/),
+});
+
+const arbitraryBashWordPartVariable: fc.Arbitrary<BashWordPartVariable> = fc.record({
+	type: fc.constant('variable' as const),
+	name: arbitraryBashIdentifier,
+});
+
+// variableBraced without operator/operand (always include the optional keys so deepEqual matches parser output)
+const arbitraryBashWordPartVariableBraced: fc.Arbitrary<BashWordPartVariableBraced> = fc.record({
+	type: fc.constant('variableBraced' as const),
+	name: arbitraryBashIdentifier,
+	operator: fc.constant(undefined),
+	operand: fc.constant(undefined),
+});
+
+const arbitraryBashWordPartArithmeticExpansion: fc.Arbitrary<BashWordPartArithmeticExpansion> = fc.record({
+	type: fc.constant('arithmeticExpansion' as const),
+	expression: fc.stringMatching(/^[0-9+\- ]*$/),
+});
+
+type RecursiveArbitraries = {
+	commandList: BashCommandList;
+};
+
+const recursiveArbitraries = fc.letrec<RecursiveArbitraries>(tie => {
+	const arbitraryCommandList = tie('commandList') as fc.Arbitrary<BashCommandList>;
+
+	// Double-quoted literal: no shell-special chars inside double quotes
+	const arbitraryDoubleQuotedLiteral: fc.Arbitrary<BashWordPartLiteral> = fc.record({
+		type: fc.constant('literal' as const),
+		value: fc.stringMatching(/^[^"\\$`\n]+$/),
+	});
+
+	const arbitraryBashWordPartDoubleQuoted: fc.Arbitrary<BashWordPartDoubleQuoted> = fc.record({
+		type: fc.constant('doubleQuoted' as const),
+		parts: fc.array(
+			fc.oneof(
+				{ weight: 3, arbitrary: arbitraryDoubleQuotedLiteral as fc.Arbitrary<BashWordPart> },
+				{ weight: 1, arbitrary: arbitraryBashWordPartVariable as fc.Arbitrary<BashWordPart> },
+				{ weight: 1, arbitrary: arbitraryBashWordPartVariableBraced as fc.Arbitrary<BashWordPart> },
+			),
+			{ minLength: 1, maxLength: 3 },
+		),
+	}).filter(dq =>
+		dq.parts.every((part, i) => {
+			const next = dq.parts[i + 1];
+			// Prevent adjacent literal parts (they merge when re-parsed)
+			if (part.type === 'literal' && next !== undefined && next.type === 'literal') {
+				return false;
+			}
+
+			// Prevent $var followed by literal starting with ident char (would be mis-parsed as one variable)
+			if (part.type === 'variable' && next !== undefined && next.type === 'literal') {
+				return next.value.length === 0 || !isIdentChar(next.value[0]!);
+			}
+
+			return true;
+		}),
+	);
+
+	const arbitraryBashWordPartCommandSubstitution = fc.record({
+		type: fc.constant('commandSubstitution' as const),
+		command: arbitraryCommandList,
+	});
+
+	const arbitraryBashWordPart: fc.Arbitrary<BashWordPart> = fc.oneof(
+		{ weight: 4, arbitrary: arbitraryBashWordPartLiteral as fc.Arbitrary<BashWordPart> },
+		{ weight: 2, arbitrary: arbitraryBashWordPartSingleQuoted as fc.Arbitrary<BashWordPart> },
+		{ weight: 2, arbitrary: arbitraryBashWordPartDoubleQuoted as fc.Arbitrary<BashWordPart> },
+		{ weight: 2, arbitrary: arbitraryBashWordPartVariable as fc.Arbitrary<BashWordPart> },
+		{ weight: 1, arbitrary: arbitraryBashWordPartVariableBraced as fc.Arbitrary<BashWordPart> },
+		{ weight: 1, arbitrary: arbitraryBashWordPartArithmeticExpansion as fc.Arbitrary<BashWordPart> },
+		{ weight: 1, arbitrary: arbitraryBashWordPartCommandSubstitution as fc.Arbitrary<BashWordPart> },
+	);
+
+	function isIdentChar(ch: string): boolean {
+		return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch === '_';
+	}
+
+	const arbitraryWord: fc.Arbitrary<BashWord> = fc.record({
+		parts: fc.array(arbitraryBashWordPart, { minLength: 1, maxLength: 2 }),
+	}).filter(word =>
+		word.parts.every((part, i) => {
+			const next = word.parts[i + 1];
+			// Prevent adjacent literal parts (they merge when re-parsed)
+			if (part.type === 'literal' && next !== undefined && next.type === 'literal') {
+				return false;
+			}
+
+			// Prevent $var followed by literal starting with ident char (would be mis-parsed as one variable)
+			if (part.type === 'variable' && next !== undefined && next.type === 'literal') {
+				return next.value.length === 0 || !isIdentChar(next.value[0]!);
+			}
+
+			return true;
+		}),
+	);
+
+	// Always include value key (even if undefined) to match createObjectParser behavior
+	const arbitraryBashAssignment: fc.Arbitrary<BashAssignment> = fc.record({
+		name: arbitraryBashIdentifier,
+		value: fc.option(arbitraryWord, { nil: undefined }),
+	});
+
+	// Always include fd key (even if undefined) to match createObjectParser behavior
+	const arbitraryBashRedirect: fc.Arbitrary<BashRedirect> = fc.record({
+		fd: fc.constant(undefined),
+		operator: fc.oneof(
+			fc.constant('>' as const),
+			fc.constant('>>' as const),
+			fc.constant('<' as const),
+		),
+		target: arbitraryWord,
+	});
+
+	const arbitraryBashSimpleCommandWithName: fc.Arbitrary<BashSimpleCommand> = fc.record({
+		type: fc.constant('simple' as const),
+		name: arbitraryWord,
+		args: fc.array(arbitraryWord, { maxLength: 2 }),
+		redirects: fc.array(arbitraryBashRedirect, { maxLength: 1 }),
+		assignments: fc.array(arbitraryBashAssignment, { maxLength: 1 }),
+	});
+
+	// Commands with no name: only assignments and/or redirects (no args)
+	const arbitraryBashSimpleCommandNoName: fc.Arbitrary<BashSimpleCommand> = fc.record({
+		type: fc.constant('simple' as const),
+		name: fc.constant(undefined),
+		args: fc.constant([]),
+		redirects: fc.array(arbitraryBashRedirect, { maxLength: 1 }),
+		assignments: fc.array(arbitraryBashAssignment, { minLength: 1, maxLength: 2 }),
+	});
+
+	const arbitraryBashSimpleCommand: fc.Arbitrary<BashSimpleCommand> = fc.oneof(
+		{ weight: 4, arbitrary: arbitraryBashSimpleCommandWithName },
+		{ weight: 1, arbitrary: arbitraryBashSimpleCommandNoName },
+	);
+
+	const arbitraryBashSubshell: fc.Arbitrary<BashSubshell> = fc.record({
+		type: fc.constant('subshell' as const),
+		body: arbitraryCommandList,
+	});
+
+	// Brace group bodies need trailing ';' on last entry (required by "{ cmd; }" syntax)
+	const arbitraryBraceGroupBody: fc.Arbitrary<BashCommandList> = arbitraryCommandList.map(list => {
+		const entries = list.entries.map((entry, i) => {
+			if (i === list.entries.length - 1 && entry.separator === undefined) {
+				return { pipeline: entry.pipeline, separator: ';' as const };
+			}
+
+			return entry;
+		});
+		return { ...list, entries };
+	});
+
+	const arbitraryBashBraceGroup: fc.Arbitrary<BashBraceGroup> = fc.record({
+		type: fc.constant('braceGroup' as const),
+		body: arbitraryBraceGroupBody,
+	});
+
+	const arbitraryBashCommandUnit: fc.Arbitrary<BashCommandUnit> = fc.oneof(
+		{ weight: 5, arbitrary: arbitraryBashSimpleCommand as fc.Arbitrary<BashCommandUnit> },
+		{ weight: 1, arbitrary: arbitraryBashSubshell as fc.Arbitrary<BashCommandUnit> },
+		{ weight: 1, arbitrary: arbitraryBashBraceGroup as fc.Arbitrary<BashCommandUnit> },
+	);
+
+	const arbitraryBashPipeline: fc.Arbitrary<BashPipeline> = fc.record({
+		type: fc.constant('pipeline' as const),
+		negated: fc.boolean(),
+		commands: fc.array(arbitraryBashCommandUnit, { minLength: 1, maxLength: 2 }),
+	});
+
+	const commandListArbitrary: fc.Arbitrary<BashCommandList> = fc.record({
+		type: fc.constant('list' as const),
+		entries: fc.array(
+			fc.record({
+				pipeline: arbitraryBashPipeline,
+				separator: fc.option(
+					fc.oneof(
+						fc.constant('&&' as const),
+						fc.constant('||' as const),
+						fc.constant(';' as const),
+					),
+					{ nil: undefined },
+				),
+			}),
+			{ minLength: 1, maxLength: 2 },
+		),
+	}).map(list => {
+		const entries = list.entries.map((entry, i) => {
+			if (i < list.entries.length - 1 && entry.separator === undefined) {
+				return { pipeline: entry.pipeline, separator: ';' as const };
+			}
+
+			return entry;
+		});
+		return { ...list, entries };
+	});
+
+	return {
+		commandList: commandListArbitrary,
+	};
+});
+
+export const arbitraryBashCommandList: fc.Arbitrary<BashCommandList> =
+	recursiveArbitraries.commandList as fc.Arbitrary<BashCommandList>;

package/src/arbitraryJavaScript.ts

@@ -256,7 +256,7 @@ const arbitraryArrowFunctionExpression = fc.oneof(
 	fc.record({
 		type: fc.constant('ArrowFunctionExpression' as const),
 		id: fc.constant(null),
-		params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+		params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id: Identifier) => id.name }),
 		body: arbitraryFunctionBodyBlockStatement,
 		expression: fc.constant(false),
 		generator: fc.constant(false),
@@ -265,7 +265,7 @@ const arbitraryArrowFunctionExpression = fc.oneof(
 	fc.record({
 		type: fc.constant('ArrowFunctionExpression' as const),
 		id: fc.constant(null),
-		params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+		params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id: Identifier) => id.name }),
 		body: arbitraryLeafExpression,
 		expression: fc.constant(true),
 		generator: fc.constant(false),
@@ -276,7 +276,7 @@ const arbitraryArrowFunctionExpression = fc.oneof(
 const arbitraryFunctionExpression = fc.record({
 	type: fc.constant('FunctionExpression' as const),
 	id: fc.constant(null),
-	params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+	params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id: Identifier) => id.name }),
 	body: arbitraryFunctionBodyBlockStatement,
 	expression: fc.constant(false),
 	generator: fc.constant(false),
@@ -359,7 +359,7 @@ const arbitraryTryStatement: fc.Arbitrary<Statement> = fc.oneof(
 const arbitraryFunctionDeclaration: fc.Arbitrary<Statement> = fc.record({
 	type: fc.constant('FunctionDeclaration' as const),
 	id: arbitraryIdentifier,
-	params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+	params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id: Identifier) => id.name }),
 	body: arbitraryFunctionBodyBlockStatement,
 	expression: fc.constant(false),
 	generator: fc.constant(false),

package/src/bashUnparser.test.ts

@@ -0,0 +1,37 @@
+import { testProp } from '@fast-check/ava';
+import { arbitraryBashCommandList } from './arbitraryBash.js';
+import { bashScriptUnparser } from './bashUnparser.js';
+import { bashScriptParser } from './bashParser.js';
+import { runParser } from './parser.js';
+import { runUnparser } from './unparser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
+
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+
+async function collectString(asyncIterable: AsyncIterable<string>): Promise<string> {
+	let result = '';
+	for await (const chunk of asyncIterable) {
+		result += chunk;
+	}
+
+	return result;
+}
+
+testProp(
+	'bash roundtrip',
+	[arbitraryBashCommandList],
+	async (t, command) => {
+		const source = await collectString(runUnparser(
+			bashScriptUnparser, command, stringUnparserOutputCompanion));
+
+		const reparsed = await runParser(
+			bashScriptParser, source, stringParserInputCompanion);
+
+		t.deepEqual(reparsed, command);
+	},
+	{
+		verbose: true,
+		seed,
+	},
+);

package/src/bashUnparser.ts

@@ -0,0 +1,211 @@
+import { type Unparser } from './unparser.js';
+import {
+	type BashWord,
+	type BashWordPart,
+	type BashSimpleCommand,
+	type BashSubshell,
+	type BashBraceGroup,
+	type BashCommandUnit,
+	type BashPipeline,
+	type BashCommandList,
+	type BashRedirect,
+	type BashAssignment,
+	type BashCommand,
+} from './bash.js';
+
+function isIdentChar(ch: string): boolean {
+	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch === '_';
+}
+
+function nextPartStartsWithIdentChar(parts: BashWordPart[], index: number): boolean {
+	const next = parts[index + 1];
+	if (next === undefined) {
+		return false;
+	}
+
+	if (next.type === 'literal') {
+		return next.value.length > 0 && isIdentChar(next.value[0]!);
+	}
+
+	return false;
+}
+
+function unparseWord(word: BashWord): string {
+	return word.parts.map((part, i) => unparseWordPartInContext(part, word.parts, i)).join('');
+}
+
+function unparseWordPartInContext(part: BashWordPart, parts: BashWordPart[], index: number): string {
+	return unparseWordPart(part);
+}
+
+function unparseWordPart(part: BashWordPart): string {
+	switch (part.type) {
+		case 'literal':
+			return escapeLiteral(part.value);
+
+		case 'singleQuoted':
+			return "'" + part.value + "'";
+
+		case 'doubleQuoted':
+			return '"' + part.parts.map(p => unparseDoubleQuotedPart(p)).join('') + '"';
+
+		case 'variable':
+			return '$' + part.name;
+
+		case 'variableBraced': {
+			let result = '${' + part.name;
+			if (part.operator !== undefined) {
+				result += part.operator;
+				if (part.operand !== undefined) {
+					result += unparseWord(part.operand);
+				}
+			}
+
+			result += '}';
+			return result;
+		}
+
+		case 'commandSubstitution':
+			return '$( ' + unparseCommand(part.command) + ' )';
+
+		case 'backtickSubstitution':
+			return '`' + unparseCommand(part.command) + '`';
+
+		case 'arithmeticExpansion':
+			return '$((' + part.expression + '))';
+
+		case 'processSubstitution':
+			return part.direction + '(' + unparseCommand(part.command) + ')';
+	}
+}
+
+function unparseDoubleQuotedPart(part: BashWordPart): string {
+	switch (part.type) {
+		case 'literal': {
+			let result = '';
+			for (const ch of part.value) {
+				if (ch === '\\' || ch === '$' || ch === '`' || ch === '"') {
+					result += '\\' + ch;
+				} else {
+					result += ch;
+				}
+			}
+
+			return result;
+		}
+
+		default:
+			return unparseWordPart(part);
+	}
+}
+
+function escapeLiteral(value: string): string {
+	let result = '';
+	for (const ch of value) {
+		if (' \t\n|&;<>()$`"\' \\'.includes(ch) || ch === '{' || ch === '}' || ch === '#') {
+			result += '\\' + ch;
+		} else {
+			result += ch;
+		}
+	}
+
+	return result;
+}
+
+function unparseRedirect(redirect: BashRedirect): string {
+	let result = '';
+	if (redirect.fd !== undefined) {
+		result += String(redirect.fd);
+	}
+
+	result += redirect.operator;
+	if ('type' in redirect.target && redirect.target.type === 'hereDoc') {
+		result += redirect.target.delimiter;
+	} else {
+		result += unparseWord(redirect.target as BashWord);
+	}
+
+	return result;
+}
+
+function unparseAssignment(assignment: BashAssignment): string {
+	let result = assignment.name + '=';
+	if (assignment.value !== undefined) {
+		result += unparseWord(assignment.value);
+	}
+
+	return result;
+}
+
+function unparseSimpleCommand(cmd: BashSimpleCommand): string {
+	const parts: string[] = [];
+
+	for (const assignment of cmd.assignments) {
+		parts.push(unparseAssignment(assignment));
+	}
+
+	if (cmd.name !== undefined) {
+		parts.push(unparseWord(cmd.name));
+	}
+
+	for (const arg of cmd.args) {
+		parts.push(unparseWord(arg));
+	}
+
+	const wordParts = parts.join(' ');
+	const redirectParts = cmd.redirects.map(r => unparseRedirect(r)).join(' ');
+
+	if (redirectParts) {
+		return wordParts ? wordParts + ' ' + redirectParts : redirectParts;
+	}
+
+	return wordParts;
+}
+
+function unparseCommandUnit(unit: BashCommandUnit): string {
+	switch (unit.type) {
+		case 'simple':
+			return unparseSimpleCommand(unit);
+
+		case 'subshell':
+			return '(' + unparseCommand(unit.body) + ')';
+
+		case 'braceGroup':
+			return '{ ' + unparseCommand(unit.body) + ' }';
+	}
+}
+
+function unparsePipeline(pipeline: BashPipeline): string {
+	let result = '';
+	if (pipeline.negated) {
+		result += '! ';
+	}
+
+	result += pipeline.commands.map(cmd => unparseCommandUnit(cmd)).join(' | ');
+	return result;
+}
+
+function unparseCommand(command: BashCommand): string {
+	return unparseCommandList(command);
+}
+
+function unparseCommandList(list: BashCommandList): string {
+	let result = '';
+	for (let i = 0; i < list.entries.length; i++) {
+		const entry = list.entries[i]!;
+		if (i > 0) {
+			result += ' ';
+		}
+
+		result += unparsePipeline(entry.pipeline);
+		if (entry.separator !== undefined) {
+			result += entry.separator;
+		}
+	}
+
+	return result;
+}
+
+export const bashScriptUnparser: Unparser<BashCommand, string> = async function * (command) {
+	yield unparseCommand(command);
+};

package/src/bsonParser.ts

@@ -6,10 +6,10 @@ import { createTupleParser } from './tupleParser.js';
 import { createSkipParser } from './skipParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
 import { createTerminatedArrayParser } from './terminatedArrayParser.js';
-import { createElementParser } from './elementParser.js';
 import { createExactElementParser } from './exactElementParser.js';
 import { createUnionParser } from './unionParser.js';
 import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { createPredicateElementParser } from './predicateElementParser.js';
 
 const createFixedLengthBufferParser = (length: number): Parser<Buffer, Uint8Array> => promiseCompose(createFixedLengthSequenceParser<Uint8Array>(length), sequence => Buffer.from(sequence));
 
@@ -17,16 +17,13 @@ const buffer1Parser = createFixedLengthBufferParser(1);
 const buffer4Parser = createFixedLengthBufferParser(4);
 const buffer8Parser = createFixedLengthBufferParser(8);
 
-const elementParser: Parser<number, Uint8Array> = createElementParser();
-
 const nullByteParser: Parser<number, Uint8Array> = createExactElementParser(0);
 
+const nonNullByteParser: Parser<number, Uint8Array> = createPredicateElementParser((byte: number) => byte !== 0);
+
 const cstringParser: Parser<string, Uint8Array> = promiseCompose(
 	createTerminatedArrayParser(
-		parserCreatorCompose(
-			() => elementParser,
-			(byte: number) => async parserContext => parserContext.invariant(byte, 'Expected non-null byte'),
-		)(),
+		nonNullByteParser,
 		nullByteParser,
 	),
 	([ sequence ]) => Buffer.from(sequence).toString('utf8'),

package/src/dalvikExecutableParser/stringSyntaxParser.ts

@@ -1,84 +1,37 @@
-import invariant from 'invariant';
 import { type Parser, setParserName } from '../parser.js';
-import { type ParserContext } from '../parserContext.js';
 import { promiseCompose } from '../promiseCompose.js';
 import { createSeparatedArrayParser } from '../separatedArrayParser.js';
 import { createExactSequenceParser } from '../exactSequenceParser.js';
 import { createUnionParser } from '../unionParser.js';
 import { createTupleParser } from '../tupleParser.js';
 import { createArrayParser } from '../arrayParser.js';
-
-export const smaliSimpleNameParser: Parser<string, string> = async (parserContext: ParserContext<string, string>) => {
-	const characters: string[] = [];
-
-	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 >= 'a' && character <= 'z'
-			)
-			|| (
-				character >= 'A' && character <= 'Z'
-			)
-			|| (
-				character >= '0' && character <= '9'
-			)
-			|| (
-				character === ' '
-			)
-			|| (
-				character === '$'
-			)
-			|| (
-				character === '-'
-			)
-				|| (
-					character === '_'
-				)
-				|| (
-					character === '\u00A0'
-				)
-				|| (
-					character >= '\u00A1' && character <= '\u1FFF'
-				)
-				|| (
-					character >= '\u2000' && character <= '\u200A'
-				)
-				|| (
-					character >= '\u2010' && character <= '\u2027'
-				)
-				|| (
-					character === '\u202F'
-				)
-				|| (
-					character >= '\u2030' && character <= '\uD7FF'
-				)
-				|| (
-					character >= '\uE000' && character <= '\uFFEF'
-				)
-				|| (
-					character >= '\uD800' && character <= '\uDBFF'
-				)
-		) {
-			parserContext.skip(1);
-
-			characters.push(character);
-
-			continue;
-		}
-
-		parserContext.invariant(characters.length > 0, 'Expected at least one character');
-
-		break;
-	}
-
-	return characters.join('');
-};
+import { createNonEmptyArrayParser } from '../nonEmptyArrayParser.js';
+import { createPredicateElementParser } from '../predicateElementParser.js';
+
+function isSmaliSimpleNameChar(character: string): boolean {
+	return (
+		(character >= 'a' && character <= 'z')
+		|| (character >= 'A' && character <= 'Z')
+		|| (character >= '0' && character <= '9')
+		|| character === ' '
+		|| character === '$'
+		|| character === '-'
+		|| character === '_'
+		|| character === '\u00A0'
+		|| (character >= '\u00A1' && character <= '\u1FFF')
+		|| (character >= '\u2000' && character <= '\u200A')
+		|| (character >= '\u2010' && character <= '\u2027')
+		|| character === '\u202F'
+		|| (character >= '\u2030' && character <= '\uD7FF')
+		|| (character >= '\uE000' && character <= '\uFFEF')
+		|| (character >= '\uD800' && character <= '\uDBFF')
+	);
+}
+
+export const smaliSimpleNameParser: Parser<string, string> = promiseCompose(
+	createNonEmptyArrayParser(createPredicateElementParser(isSmaliSimpleNameChar)),
+	characters => characters.join(''),
+);
 
 setParserName(smaliSimpleNameParser, 'smaliSimpleNameParser');
 

package/src/dalvikExecutableParser.ts

@@ -13,6 +13,7 @@ import { createTupleParser } from './tupleParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
 import { createSkipToParser } from './skipToParser.js';
 import { createLookaheadParser } from './lookaheadParser.js';
+import { createPredicateElementParser } from './predicateElementParser.js';
 import {
 	getIsoTypedNumberArray,
 	type IndexIntoFieldIds,
@@ -843,16 +844,9 @@ type DalvikExecutableTaggedEncodedValue =
 	| { type: 'boolean'; value: boolean };
 
 const createByteWith5LeastSignificantBitsEqualParser = (leastSignificant5: number): Parser<number, Uint8Array> => {
-	const byteWith5LeastSignificantBitsEqualParser: Parser<number, Uint8Array> = async parserContext => {
-		const byte = await parserContext.read(0);
-		parserContext.invariant(
-			(byte & 0b0001_1111) === leastSignificant5,
-			'Expected byte with 5 least significant bits equal to %s, but got %s',
-			leastSignificant5.toString(2).padStart(8, '0'),
-			byte.toString(2).padStart(8, '0'),
-		);
-		return byte;
-	};
+	const byteWith5LeastSignificantBitsEqualParser: Parser<number, Uint8Array> = createPredicateElementParser(
+		(byte: number) => (byte & 0b0001_1111) === leastSignificant5,
+	);
 
 	setParserName(byteWith5LeastSignificantBitsEqualParser, `createByteWith5LeastSignificantBitsEqualParser(${leastSignificant5.toString(2).padStart(5, '0')})`);