@futpib/parser 1.0.6 → 1.0.8

package/build/bashUnparser.js

@@ -0,0 +1,157 @@
+function isIdentChar(ch) {
+    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch === '_';
+}
+function nextPartStartsWithIdentChar(parts, index) {
+    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) {
+    return word.parts.map((part, i) => unparseWordPartInContext(part, word.parts, i)).join('');
+}
+function unparseWordPartInContext(part, parts, index) {
+    return unparseWordPart(part);
+}
+function unparseWordPart(part) {
+    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) {
+    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) {
+    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) {
+    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);
+    }
+    return result;
+}
+function unparseAssignment(assignment) {
+    let result = assignment.name + '=';
+    if (assignment.value !== undefined) {
+        result += unparseWord(assignment.value);
+    }
+    return result;
+}
+function unparseSimpleCommand(cmd) {
+    const parts = [];
+    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) {
+    switch (unit.type) {
+        case 'simple':
+            return unparseSimpleCommand(unit);
+        case 'subshell':
+            return '(' + unparseCommand(unit.body) + ')';
+        case 'braceGroup':
+            return '{ ' + unparseCommand(unit.body) + ' }';
+    }
+}
+function unparsePipeline(pipeline) {
+    let result = '';
+    if (pipeline.negated) {
+        result += '! ';
+    }
+    result += pipeline.commands.map(cmd => unparseCommandUnit(cmd)).join(' | ');
+    return result;
+}
+function unparseCommand(command) {
+    return unparseCommandList(command);
+}
+function unparseCommandList(list) {
+    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 = async function* (command) {
+    yield unparseCommand(command);
+};

package/build/bashUnparser.test.d.ts

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

package/build/bashUnparser.test.js

@@ -0,0 +1,24 @@
+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) {
+    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/build/bsonParser.js

@@ -5,17 +5,17 @@ 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) => promiseCompose(createFixedLengthSequenceParser(length), sequence => Buffer.from(sequence));
 const buffer1Parser = createFixedLengthBufferParser(1);
 const buffer4Parser = createFixedLengthBufferParser(4);
 const buffer8Parser = createFixedLengthBufferParser(8);
-const elementParser = createElementParser();
 const nullByteParser = createExactElementParser(0);
-const cstringParser = promiseCompose(createTerminatedArrayParser(parserCreatorCompose(() => elementParser, (byte) => async (parserContext) => parserContext.invariant(byte, 'Expected non-null byte'))(), nullByteParser), ([sequence]) => Buffer.from(sequence).toString('utf8'));
+const nonNullByteParser = createPredicateElementParser((byte) => byte !== 0);
+const cstringParser = promiseCompose(createTerminatedArrayParser(nonNullByteParser, nullByteParser), ([sequence]) => Buffer.from(sequence).toString('utf8'));
 const doubleParser = promiseCompose(buffer8Parser, buffer => buffer.readDoubleLE(0));
 setParserName(doubleParser, 'doubleParser');
 const int32Parser = promiseCompose(buffer4Parser, buffer => buffer.readInt32LE(0));

package/build/dalvikExecutableParser/stringSyntaxParser.js

@@ -1,4 +1,3 @@
-import invariant from 'invariant';
 import { setParserName } from '../parser.js';
 import { promiseCompose } from '../promiseCompose.js';
 import { createSeparatedArrayParser } from '../separatedArrayParser.js';
@@ -6,36 +5,26 @@ import { createExactSequenceParser } from '../exactSequenceParser.js';
 import { createUnionParser } from '../unionParser.js';
 import { createTupleParser } from '../tupleParser.js';
 import { createArrayParser } from '../arrayParser.js';
-export const smaliSimpleNameParser = 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 >= '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) {
+    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 = promiseCompose(createNonEmptyArrayParser(createPredicateElementParser(isSmaliSimpleNameChar)), characters => characters.join(''));
 setParserName(smaliSimpleNameParser, 'smaliSimpleNameParser');
 export const smaliMemberNameParser = createUnionParser([
     smaliSimpleNameParser,

package/build/dalvikExecutableParser.js

@@ -12,6 +12,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, isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoPrototypeIds, isoIndexIntoStringIds, isoIndexIntoTypeIds, isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler, isoOffsetToAnnotationItem, isoOffsetToAnnotationsDirectoryItem, isoOffsetToAnnotationSetItem, isoOffsetToAnnotationSetRefListItem, isoOffsetToClassDataItem, isoOffsetToCodeItem, isoOffsetToDebugInfoItem, isoOffsetToEncodedArrayItem, isoOffsetToStringDataItem, isoOffsetToTypeList, } from './dalvikExecutableParser/typedNumbers.js';
 import { sleb128NumberParser, uleb128NumberParser } from './leb128Parser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
@@ -354,11 +355,7 @@ const createSkipToThenClassDataItemsParser = (sizeOffset) => createSkipToThenIte
     parserName: 'skipToThenClassDataItemsParser',
 });
 const createByteWith5LeastSignificantBitsEqualParser = (leastSignificant5) => {
-    const byteWith5LeastSignificantBitsEqualParser = 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 = createPredicateElementParser((byte) => (byte & 0b0001_1111) === leastSignificant5);
     setParserName(byteWith5LeastSignificantBitsEqualParser, `createByteWith5LeastSignificantBitsEqualParser(${leastSignificant5.toString(2).padStart(5, '0')})`);
     return byteWith5LeastSignificantBitsEqualParser;
 };

package/build/hasExecutable.js

@@ -1,6 +1,6 @@
 import { execa } from 'execa';
 export async function hasExecutable(executable) {
-    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/build/index.d.ts

@@ -16,6 +16,7 @@ export { createUnionParser, } from './unionParser.js';
 export { createDisjunctionParser, } from './disjunctionParser.js';
 export { createParserAccessorParser, } from './parserAccessorParser.js';
 export { createElementParser, } from './elementParser.js';
+export { createPredicateElementParser, } from './predicateElementParser.js';
 export { createTerminatedArrayParser, } from './terminatedArrayParser.js';
 export { createSliceBoundedParser, } from './sliceBoundedParser.js';
 export { createExactElementParser, } from './exactElementParser.js';

package/build/index.js

@@ -14,6 +14,7 @@ export { createUnionParser, } from './unionParser.js';
 export { createDisjunctionParser, } from './disjunctionParser.js';
 export { createParserAccessorParser, } from './parserAccessorParser.js';
 export { createElementParser, } from './elementParser.js';
+export { createPredicateElementParser, } from './predicateElementParser.js';
 export { createTerminatedArrayParser, } from './terminatedArrayParser.js';
 export { createSliceBoundedParser, } from './sliceBoundedParser.js';
 export { createExactElementParser, } from './exactElementParser.js';

package/build/jsonParser.js

@@ -8,8 +8,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';
 const whitespaceParser = createArrayParser(createUnionParser([
@@ -41,13 +40,9 @@ const jsonStringEscapeSequenceParser = createUnionParser([
     jsonTabEscapeSequenceParser,
     jsonUnicodeEscapeSequenceParser,
 ]);
-const elementParser = createElementParser();
 const jsonStringCharacterParser = createDisjunctionParser([
     jsonStringEscapeSequenceParser,
-    parserCreatorCompose(() => elementParser, character => async (parserContext) => {
-        parserContext.invariant(character !== '"', 'Unexpected """');
-        return character;
-    })(),
+    createPredicateElementParser((character) => character !== '"'),
 ]);
 export const jsonStringParser = promiseCompose(createTupleParser([
     createExactSequenceParser('"'),

package/build/predicateElementParser.d.ts

@@ -0,0 +1,3 @@
+import { type Parser } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
+export declare const createPredicateElementParser: <Sequence, Element = DeriveSequenceElement<Sequence>>(predicate: (element: Element) => boolean) => Parser<Element, Sequence, Element>;

package/build/predicateElementParser.js

@@ -0,0 +1,10 @@
+import { setParserName } from './parser.js';
+export const createPredicateElementParser = (predicate) => {
+    const predicateElementParser = async (parserContext) => {
+        const element = await parserContext.read(0);
+        parserContext.invariant(predicate(element), 'Element does not match predicate: %s', element);
+        return element;
+    };
+    setParserName(predicateElementParser, `createPredicateElementParser(${predicate.name || 'anonymous'})`);
+    return predicateElementParser;
+};

package/build/regularExpression.d.ts

@@ -17,6 +17,14 @@ export type RepeatBounds = number | {
     min?: number;
     max: number;
 };
+export declare enum AssertionSign {
+    POSITIVE = 0,
+    NEGATIVE = 1
+}
+export declare enum AssertionDir {
+    AHEAD = 0,
+    BEHIND = 1
+}
 export type RegularExpression = {
     type: 'epsilon';
 } | {
@@ -48,10 +56,11 @@ export type RegularExpression = {
     inner: RegularExpression;
     name?: string;
 } | {
-    type: 'lookahead';
-    isPositive: boolean;
+    type: 'assertion';
+    direction: AssertionDir;
+    sign: AssertionSign;
     inner: RegularExpression;
-    right: RegularExpression;
+    outer: RegularExpression;
 } | {
     type: 'start-anchor';
     left: RegularExpression;

package/build/regularExpression.js

@@ -1 +1,10 @@
-export {};
+export var AssertionSign;
+(function (AssertionSign) {
+    AssertionSign[AssertionSign["POSITIVE"] = 0] = "POSITIVE";
+    AssertionSign[AssertionSign["NEGATIVE"] = 1] = "NEGATIVE";
+})(AssertionSign || (AssertionSign = {}));
+export var AssertionDir;
+(function (AssertionDir) {
+    AssertionDir[AssertionDir["AHEAD"] = 0] = "AHEAD";
+    AssertionDir[AssertionDir["BEHIND"] = 1] = "BEHIND";
+})(AssertionDir || (AssertionDir = {}));

package/build/regularExpressionParser.js

@@ -12,6 +12,7 @@ import { createTerminatedArrayParser } from './terminatedArrayParser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
 import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
 import { createObjectParser } from './objectParser.js';
+import { AssertionDir, AssertionSign, } from './regularExpression.js';
 // CharacterSet helpers
 const emptyCharacterSet = { type: 'empty' };
 function codePointRangeIsEmpty(range) {
@@ -168,20 +169,21 @@ function characterSetFromArray(chars) {
     return chars.map(characterSetSingleton).reduce(characterSetUnion, emptyCharacterSet);
 }
 function characterSetComplement(set) {
-    return characterSetDifference(alphabet, set);
+    return characterSetDifference(bmpRange, set);
 }
 // Pre-defined character sets
-const alphabet = characterSetDifference(characterSetFromRange({ start: 0, end: 0x10FFFF }), characterSetFromArray(['\r', '\n', '\u2028', '\u2029']));
+const bmpRange = characterSetFromRange({ start: 0, end: 0xFFFF });
+const alphabet = characterSetDifference(bmpRange, characterSetFromArray(['\r', '\n', '\u2028', '\u2029']));
 const wildcardCharacterSet = characterSetDifference(alphabet, characterSetFromArray(['\r', '\n', '\u2028', '\u2029']));
 const digitChars = characterSetCharRange('0', '9');
-const nonDigitChars = characterSetComplement(digitChars);
+const nonDigitChars = characterSetDifference(bmpRange, digitChars);
 const wordChars = [
     characterSetCharRange('a', 'z'),
     characterSetCharRange('A', 'Z'),
     characterSetCharRange('0', '9'),
     characterSetSingleton('_'),
 ].reduce(characterSetUnion);
-const nonWordChars = characterSetComplement(wordChars);
+const nonWordChars = characterSetDifference(bmpRange, wordChars);
 const whiteSpaceChars = [
     characterSetSingleton('\f'),
     characterSetSingleton('\n'),
@@ -199,7 +201,7 @@ const whiteSpaceChars = [
     characterSetSingleton('\u3000'),
     characterSetSingleton('\ufeff'),
 ].reduce(characterSetUnion);
-const nonWhiteSpaceChars = characterSetComplement(whiteSpaceChars);
+const nonWhiteSpaceChars = characterSetDifference(bmpRange, whiteSpaceChars);
 // AST constructors
 const epsilon = { type: 'epsilon' };
 function literal(charset) {
@@ -229,8 +231,8 @@ function captureGroup(inner, name) {
     }
     return { type: 'capture-group', inner, name };
 }
-function lookahead(isPositive, inner, right) {
-    return { type: 'lookahead', isPositive, inner, right };
+function assertion(direction, sign, inner, outer) {
+    return { type: 'assertion', direction, sign, inner, outer };
 }
 function startAnchor(left, right) {
     return { type: 'start-anchor', left, right };
@@ -476,16 +478,18 @@ const nonCaptureGroupParser = promiseCompose(createTupleParser([
 ]), ([, inner]) => inner);
 // Positive lookahead (?=...)
 const positiveLookaheadMarkerParser = createObjectParser({
-    type: 'lookahead-marker',
-    isPositive: true,
+    type: 'assertion-marker',
+    direction: AssertionDir.AHEAD,
+    sign: AssertionSign.POSITIVE,
     _open: createExactSequenceParser('(?='),
     inner: createParserAccessorParser(() => alternationParser),
     _close: createExactSequenceParser(')'),
 });
 // Negative lookahead (?!...)
 const negativeLookaheadMarkerParser = createObjectParser({
-    type: 'lookahead-marker',
-    isPositive: false,
+    type: 'assertion-marker',
+    direction: AssertionDir.AHEAD,
+    sign: AssertionSign.NEGATIVE,
     _open: createExactSequenceParser('(?!'),
     inner: createParserAccessorParser(() => alternationParser),
     _close: createExactSequenceParser(')'),
@@ -545,9 +549,9 @@ function concatList(parts) {
     }
     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) {
     if (elements.length === 0) {
         return epsilon;
@@ -566,18 +570,28 @@ function processElements(elements) {
         const right = elements.slice(endAnchorIdx + 1);
         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];
-        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];
+        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));
         }
-        // If there's content before the lookahead, concatenate it
-        return concat(processElements(left), lookaheadExpr);
+        // 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)));
+        }
+        // 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
     const regexParts = elements;

package/build/regularExpressionParser.test.js

@@ -42,8 +42,8 @@ function normalizeRegularExpression(ast) {
                 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/build/smaliParser.js

@@ -14,6 +14,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';
@@ -236,19 +237,14 @@ const smaliCharacterLiteralParser = promiseCompose(createTupleParser([
 ]), ([, character]) => character.charCodeAt(0));
 setParserName(smaliCharacterLiteralParser, 'smaliCharacterLiteralParser');
 // Parser that matches identifier continuation characters (letters, digits, $, -, _)
-const smaliIdentifierContinuationParser = async (parserContext) => {
-    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')
+const smaliIdentifierContinuationParser = createPredicateElementParser(function isSmaliIdentifierContinuation(character) {
+    return (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;
-};
+        || character === '_';
+});
 setParserName(smaliIdentifierContinuationParser, 'smaliIdentifierContinuationParser');
 // Helper to create an access flag parser with word boundary check
 const createAccessFlagParser = (keyword) => promiseCompose(createTupleParser([

package/build/symbolicExpressionParser.js

@@ -34,11 +34,16 @@ const symbolicExpressionStringParser = promiseCompose(createRegExpParser(/"(?:[^
 });
 setParserName(symbolicExpressionStringParser, 'symbolicExpressionStringParser');
 // Atom parser: unquoted symbols (any chars except whitespace, parens, quotes, etc.)
-// Supports backslash escapes: \x becomes x, trailing \ becomes nothing
-const symbolicExpressionAtomParser = promiseCompose(createRegExpParser(/(?:[^\s()"'`,;\\]|\\.)+\\?|\\$/), match => {
+// Supports backslash escapes: \x becomes x
+// Note: A lone backslash or one that produces an empty atom should fail parsing
+const symbolicExpressionAtomParser = promiseCompose(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',
         value,