@futpib/parser 1.0.7 → 1.0.8

package/src/hasExecutable.ts

@@ -1,7 +1,7 @@
 import { execa } from 'execa';
 
 export async function hasExecutable(executable: string) {
-	const hasExecutable = execa(executable).catch(() => false).then(() => true);
+	const hasExecutable = await execa(executable).then(() => true).catch(() => false);
 
 	if (!hasExecutable) {
 		console.warn('Executable %o not found', executable);

package/src/jsonParser.ts

@@ -11,8 +11,7 @@ import { createDisjunctionParser } from './disjunctionParser.js';
 import { createTerminatedArrayParser } from './terminatedArrayParser.js';
 import { createArrayParser } from './arrayParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
-import { createElementParser } from './elementParser.js';
-import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { createPredicateElementParser } from './predicateElementParser.js';
 import { createSeparatedArrayParser } from './separatedArrayParser.js';
 import { createRegExpParser } from './regexpParser.js';
 
@@ -52,17 +51,9 @@ const jsonStringEscapeSequenceParser: Parser<string, string> = createUnionParser
 	jsonUnicodeEscapeSequenceParser,
 ]);
 
-const elementParser: Parser<string, string> = createElementParser();
-
 const jsonStringCharacterParser: Parser<string, string> = createDisjunctionParser([
 	jsonStringEscapeSequenceParser,
-	parserCreatorCompose(
-		() => elementParser,
-		character => async parserContext => {
-			parserContext.invariant(character !== '"', 'Unexpected """');
-			return character;
-		},
-	)(),
+	createPredicateElementParser((character: string) => character !== '"'),
 ]);
 
 export const jsonStringParser: Parser<string, string> = promiseCompose(

package/src/regularExpression.ts

@@ -9,6 +9,16 @@ export type CharacterSet =
 
 export type RepeatBounds = number | { min: number; max?: number } | { min?: number; max: number };
 
+export enum AssertionSign {
+	POSITIVE = 0,
+	NEGATIVE = 1,
+}
+
+export enum AssertionDir {
+	AHEAD = 0,
+	BEHIND = 1,
+}
+
 export type RegularExpression =
 	| { type: 'epsilon' }
 	| { type: 'literal'; charset: CharacterSet }
@@ -19,6 +29,6 @@ export type RegularExpression =
 	| { type: 'optional'; inner: RegularExpression }
 	| { type: 'repeat'; inner: RegularExpression; bounds: RepeatBounds }
 	| { type: 'capture-group'; inner: RegularExpression; name?: string }
-	| { type: 'lookahead'; isPositive: boolean; inner: RegularExpression; right: RegularExpression }
+	| { type: 'assertion'; direction: AssertionDir; sign: AssertionSign; inner: RegularExpression; outer: RegularExpression }
 	| { type: 'start-anchor'; left: RegularExpression; right: RegularExpression }
 	| { type: 'end-anchor'; left: RegularExpression; right: RegularExpression };

package/src/regularExpressionParser.test.ts

@@ -9,7 +9,7 @@ import { parseRegExpString } from '../node_modules/@gruhn/regex-utils/dist/regex
 import { runParser } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
-import type { RegularExpression, CharacterSet } from './regularExpression.js';
+import { AssertionDir, AssertionSign, type RegularExpression, type CharacterSet } from './regularExpression.js';
 
 // Normalize AST for comparison - removes hashes from CharSets and normalizes structure
 function normalizeCharacterSet(charset: CharacterSet): CharacterSet {
@@ -47,8 +47,8 @@ function normalizeRegularExpression(ast: RegularExpression): RegularExpression {
 				return { type: 'capture-group', inner: normalizeRegularExpression(ast.inner), name: ast.name };
 			}
 			return { type: 'capture-group', inner: normalizeRegularExpression(ast.inner) };
-		case 'lookahead':
-			return { type: 'lookahead', isPositive: ast.isPositive, inner: normalizeRegularExpression(ast.inner), right: normalizeRegularExpression(ast.right) };
+		case 'assertion':
+			return { type: 'assertion', direction: ast.direction, sign: ast.sign, inner: normalizeRegularExpression(ast.inner), outer: normalizeRegularExpression(ast.outer) };
 		case 'start-anchor':
 			return { type: 'start-anchor', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
 		case 'end-anchor':

package/src/regularExpressionParser.ts

@@ -14,6 +14,8 @@ import { createDisjunctionParser } from './disjunctionParser.js';
 import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
 import { createObjectParser } from './objectParser.js';
 import {
+	AssertionDir,
+	AssertionSign,
 	type CharacterSet,
 	type CodePointRange,
 	type RegularExpression,
@@ -209,12 +211,14 @@ function characterSetFromArray(chars: string[]): CharacterSet {
 }
 
 function characterSetComplement(set: CharacterSet): CharacterSet {
-	return characterSetDifference(alphabet, set);
+	return characterSetDifference(bmpRange, set);
 }
 
 // Pre-defined character sets
+const bmpRange: CharacterSet = characterSetFromRange({ start: 0, end: 0xFFFF });
+
 const alphabet: CharacterSet = characterSetDifference(
-	characterSetFromRange({ start: 0, end: 0x10FFFF }),
+	bmpRange,
 	characterSetFromArray(['\r', '\n', '\u2028', '\u2029']),
 );
 
@@ -224,7 +228,7 @@ const wildcardCharacterSet: CharacterSet = characterSetDifference(
 );
 
 const digitChars: CharacterSet = characterSetCharRange('0', '9');
-const nonDigitChars: CharacterSet = characterSetComplement(digitChars);
+const nonDigitChars: CharacterSet = characterSetDifference(bmpRange, digitChars);
 
 const wordChars: CharacterSet = [
 	characterSetCharRange('a', 'z'),
@@ -232,7 +236,7 @@ const wordChars: CharacterSet = [
 	characterSetCharRange('0', '9'),
 	characterSetSingleton('_'),
 ].reduce(characterSetUnion);
-const nonWordChars: CharacterSet = characterSetComplement(wordChars);
+const nonWordChars: CharacterSet = characterSetDifference(bmpRange, wordChars);
 
 const whiteSpaceChars: CharacterSet = [
 	characterSetSingleton('\f'),
@@ -251,7 +255,7 @@ const whiteSpaceChars: CharacterSet = [
 	characterSetSingleton('\u3000'),
 	characterSetSingleton('\ufeff'),
 ].reduce(characterSetUnion);
-const nonWhiteSpaceChars: CharacterSet = characterSetComplement(whiteSpaceChars);
+const nonWhiteSpaceChars: CharacterSet = characterSetDifference(bmpRange, whiteSpaceChars);
 
 // AST constructors
 
@@ -292,8 +296,8 @@ function captureGroup(inner: RegularExpression, name?: string): RegularExpressio
 	return { type: 'capture-group', inner, name };
 }
 
-function lookahead(isPositive: boolean, inner: RegularExpression, right: RegularExpression): RegularExpression {
-	return { type: 'lookahead', isPositive, inner, right };
+function assertion(direction: AssertionDir, sign: AssertionSign, inner: RegularExpression, outer: RegularExpression): RegularExpression {
+	return { type: 'assertion', direction, sign, inner, outer };
 }
 
 function startAnchor(left: RegularExpression, right: RegularExpression): RegularExpression {
@@ -756,22 +760,24 @@ const nonCaptureGroupParser: Parser<RegularExpression, string> = promiseCompose(
 	([, inner]) => inner,
 );
 
-// Lookahead markers for internal use during parsing
-type LookaheadMarker = { type: 'lookahead-marker'; isPositive: boolean; inner: RegularExpression };
+// Assertion markers for internal use during parsing
+type AssertionMarker = { type: 'assertion-marker'; direction: AssertionDir; sign: AssertionSign; inner: RegularExpression };
 
 // Positive lookahead (?=...)
-const positiveLookaheadMarkerParser: Parser<LookaheadMarker, string> = createObjectParser({
-	type: 'lookahead-marker' as const,
-	isPositive: true as const,
+const positiveLookaheadMarkerParser: Parser<AssertionMarker, string> = createObjectParser({
+	type: 'assertion-marker' as const,
+	direction: AssertionDir.AHEAD as const,
+	sign: AssertionSign.POSITIVE as const,
 	_open: createExactSequenceParser('(?='),
 	inner: createParserAccessorParser(() => alternationParser),
 	_close: createExactSequenceParser(')'),
 });
 
 // Negative lookahead (?!...)
-const negativeLookaheadMarkerParser: Parser<LookaheadMarker, string> = createObjectParser({
-	type: 'lookahead-marker' as const,
-	isPositive: false as const,
+const negativeLookaheadMarkerParser: Parser<AssertionMarker, string> = createObjectParser({
+	type: 'assertion-marker' as const,
+	direction: AssertionDir.AHEAD as const,
+	sign: AssertionSign.NEGATIVE as const,
 	_open: createExactSequenceParser('(?!'),
 	inner: createParserAccessorParser(() => alternationParser),
 	_close: createExactSequenceParser(')'),
@@ -786,7 +792,7 @@ const groupParser: Parser<RegularExpression, string> = createUnionParser([
 // Anchors
 // Anchor markers for internal use during parsing
 type AnchorMarker = { type: 'start-anchor-marker' } | { type: 'end-anchor-marker' };
-type ParsedElement = RegularExpression | AnchorMarker | LookaheadMarker;
+type ParsedElement = RegularExpression | AnchorMarker | AssertionMarker;
 
 const startAnchorMarkerParser: Parser<AnchorMarker, string> = createObjectParser({
 	type: 'start-anchor-marker' as const,
@@ -847,9 +853,9 @@ function concatList(parts: RegularExpression[]): RegularExpression {
 	return parts.reduceRight((acc, part) => concat(part, acc));
 }
 
-// Process elements with anchor markers and lookahead markers into proper AST
-// Handles anchors and lookahead as infix operators like @gruhn/regex-utils
-// Precedence order (lowest to highest): union -> start-anchor -> end-anchor -> lookahead -> concat
+// Process elements with anchor markers and assertion markers into proper AST
+// Handles anchors and assertions as infix operators like @gruhn/regex-utils
+// Precedence order (lowest to highest): union -> start-anchor -> end-anchor -> assertion -> concat
 function processElements(elements: ParsedElement[]): RegularExpression {
 	if (elements.length === 0) {
 		return epsilon;
@@ -871,18 +877,31 @@ function processElements(elements: ParsedElement[]): RegularExpression {
 		return endAnchor(processElements(left), processElements(right));
 	}
 
-	// Then lookaheads (higher precedence than anchors)
-	const lookaheadIdx = elements.findIndex(e => 'type' in e && e.type === 'lookahead-marker');
-	if (lookaheadIdx !== -1) {
-		const marker = elements[lookaheadIdx] as LookaheadMarker;
-		const left = elements.slice(0, lookaheadIdx);
-		const right = elements.slice(lookaheadIdx + 1);
-		const lookaheadExpr = lookahead(marker.isPositive, marker.inner, processElements(right));
-		if (left.length === 0) {
-			return lookaheadExpr;
+	// Then assertions (higher precedence than anchors)
+	// Special handling: Negative lookahead at the start with more content after it
+	// forms a concat with epsilon outer, instead of consuming everything into outer
+	const assertionIdx = elements.findIndex(e => 'type' in e && e.type === 'assertion-marker');
+	if (assertionIdx !== -1) {
+		const marker = elements[assertionIdx] as AssertionMarker;
+		const left = elements.slice(0, assertionIdx);
+		const right = elements.slice(assertionIdx + 1);
+		
+		// Special case: Negative lookahead at the start followed by more content
+		// Creates concat instead of nesting
+		if (left.length === 0 && marker.sign === AssertionSign.NEGATIVE && right.length > 0) {
+			const assertionExpr = assertion(marker.direction, marker.sign, marker.inner, epsilon);
+			return concat(assertionExpr, processElements(right));
+		}
+		
+		// Assertion after content: always concat with epsilon outer
+		if (left.length > 0) {
+			const assertionExpr = assertion(marker.direction, marker.sign, marker.inner, epsilon);
+			return concat(processElements(left), concat(assertionExpr, processElements(right)));
 		}
-		// If there's content before the lookahead, concatenate it
-		return concat(processElements(left), lookaheadExpr);
+		
+		// Assertion at start (not negative lookahead with content after): consume everything
+		const assertionExpr = assertion(marker.direction, marker.sign, marker.inner, processElements(right));
+		return assertionExpr;
 	}
 
 	// No markers, just regular expressions - concatenate them

package/src/smaliParser.ts

@@ -8,7 +8,6 @@ import {
 import { createExactSequenceParser } from './exactSequenceParser.js';
 import { createObjectParser } from './objectParser.js';
 import { cloneParser, type Parser, setParserName } from './parser.js';
-import { type ParserContext } from './parserContext.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createTupleParser } from './tupleParser.js';
 import { createUnionParser } from './unionParser.js';
@@ -18,6 +17,7 @@ import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
 import { createOptionalParser } from './optionalParser.js';
 import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
 import { createSeparatedArrayParser } from './separatedArrayParser.js';
+import { createPredicateElementParser } from './predicateElementParser.js';
 import { smaliMemberNameParser, smaliTypeDescriptorParser } from './dalvikExecutableParser/stringSyntaxParser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
 import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
@@ -348,28 +348,16 @@ const smaliCharacterLiteralParser: Parser<number, string> = promiseCompose(
 setParserName(smaliCharacterLiteralParser, 'smaliCharacterLiteralParser');
 
 // Parser that matches identifier continuation characters (letters, digits, $, -, _)
-const smaliIdentifierContinuationParser: Parser<string, string> = async (parserContext: ParserContext<string, string>) => {
-	const character = await parserContext.peek(0);
-	
-	parserContext.invariant(character !== undefined, 'Unexpected end of input');
-	
-	invariant(character !== undefined, 'Unexpected end of input');
-	
-	parserContext.invariant(
-		(character >= 'a' && character <= 'z')
-		|| (character >= 'A' && character <= 'Z')
-		|| (character >= '0' && character <= '9')
-		|| character === '$'
-		|| character === '-'
-		|| character === '_',
-		'Expected identifier continuation character, got "%s"',
-		character,
-	);
-	
-	parserContext.skip(1);
-	
-	return character;
-};
+const smaliIdentifierContinuationParser: Parser<string, string> = createPredicateElementParser(
+	function isSmaliIdentifierContinuation(character: string) {
+		return (character >= 'a' && character <= 'z')
+			|| (character >= 'A' && character <= 'Z')
+			|| (character >= '0' && character <= '9')
+			|| character === '$'
+			|| character === '-'
+			|| character === '_';
+	},
+);
 
 setParserName(smaliIdentifierContinuationParser, 'smaliIdentifierContinuationParser');
 

package/src/symbolicExpressionParser.ts

@@ -60,13 +60,19 @@ const symbolicExpressionStringParser: Parser<SymbolicExpressionString, string> =
 setParserName(symbolicExpressionStringParser, 'symbolicExpressionStringParser');
 
 // Atom parser: unquoted symbols (any chars except whitespace, parens, quotes, etc.)
-// Supports backslash escapes: \x becomes x, trailing \ becomes nothing
+// Supports backslash escapes: \x becomes x
+// Note: A lone backslash or one that produces an empty atom should fail parsing
 const symbolicExpressionAtomParser: Parser<SymbolicExpressionAtom, string> = promiseCompose(
-	createRegExpParser(/(?:[^\s()"'`,;\\]|\\.)+\\?|\\$/),
+	createRegExpParser(/(?:[^\s()"'`,;\\]|\\.)+\\?/),
 	match => {
 		const raw = match[0];
-		// Process backslash escapes: \x becomes x, trailing \ becomes nothing
+		// Process backslash escapes: \x becomes x
 		const value = raw.replace(/\\(.?)/g, '$1');
+		// Reject atoms that result in empty strings
+		if (value.length === 0) {
+			throw new Error('Atom cannot be empty');
+		}
+
 		return {
 			type: 'atom' as const,
 			value,