@futpib/parser 1.0.7 → 1.0.8

package/build/arbitraryBash.d.ts

@@ -0,0 +1,3 @@
+import * as fc from 'fast-check';
+import { type BashCommandList } from './bash.js';
+export declare const arbitraryBashCommandList: fc.Arbitrary<BashCommandList>;

package/build/arbitraryBash.js

@@ -0,0 +1,142 @@
+import * as fc from 'fast-check';
+const arbitraryBashIdentifier = 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.record({
+    type: fc.constant('literal'),
+    value: fc.stringMatching(/^[a-zA-Z0-9][a-zA-Z0-9._@%,:^~-]*$/),
+});
+// Single-quoted: no single quotes, no newlines inside (keep simple)
+const arbitraryBashWordPartSingleQuoted = fc.record({
+    type: fc.constant('singleQuoted'),
+    value: fc.stringMatching(/^[^'\n]*$/),
+});
+const arbitraryBashWordPartVariable = fc.record({
+    type: fc.constant('variable'),
+    name: arbitraryBashIdentifier,
+});
+// variableBraced without operator/operand (always include the optional keys so deepEqual matches parser output)
+const arbitraryBashWordPartVariableBraced = fc.record({
+    type: fc.constant('variableBraced'),
+    name: arbitraryBashIdentifier,
+    operator: fc.constant(undefined),
+    operand: fc.constant(undefined),
+});
+const arbitraryBashWordPartArithmeticExpansion = fc.record({
+    type: fc.constant('arithmeticExpansion'),
+    expression: fc.stringMatching(/^[0-9+\- ]*$/),
+});
+const recursiveArbitraries = fc.letrec(tie => {
+    const arbitraryCommandList = tie('commandList');
+    // Double-quoted literal: no shell-special chars inside double quotes
+    const arbitraryDoubleQuotedLiteral = fc.record({
+        type: fc.constant('literal'),
+        value: fc.stringMatching(/^[^"\\$`\n]+$/),
+    });
+    const arbitraryBashWordPartDoubleQuoted = fc.record({
+        type: fc.constant('doubleQuoted'),
+        parts: fc.array(fc.oneof({ weight: 3, arbitrary: arbitraryDoubleQuotedLiteral }, { weight: 1, arbitrary: arbitraryBashWordPartVariable }, { weight: 1, arbitrary: arbitraryBashWordPartVariableBraced }), { 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'),
+        command: arbitraryCommandList,
+    });
+    const arbitraryBashWordPart = fc.oneof({ weight: 4, arbitrary: arbitraryBashWordPartLiteral }, { weight: 2, arbitrary: arbitraryBashWordPartSingleQuoted }, { weight: 2, arbitrary: arbitraryBashWordPartDoubleQuoted }, { weight: 2, arbitrary: arbitraryBashWordPartVariable }, { weight: 1, arbitrary: arbitraryBashWordPartVariableBraced }, { weight: 1, arbitrary: arbitraryBashWordPartArithmeticExpansion }, { weight: 1, arbitrary: arbitraryBashWordPartCommandSubstitution });
+    function isIdentChar(ch) {
+        return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch === '_';
+    }
+    const arbitraryWord = 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.record({
+        name: arbitraryBashIdentifier,
+        value: fc.option(arbitraryWord, { nil: undefined }),
+    });
+    // Always include fd key (even if undefined) to match createObjectParser behavior
+    const arbitraryBashRedirect = fc.record({
+        fd: fc.constant(undefined),
+        operator: fc.oneof(fc.constant('>'), fc.constant('>>'), fc.constant('<')),
+        target: arbitraryWord,
+    });
+    const arbitraryBashSimpleCommandWithName = fc.record({
+        type: fc.constant('simple'),
+        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.record({
+        type: fc.constant('simple'),
+        name: fc.constant(undefined),
+        args: fc.constant([]),
+        redirects: fc.array(arbitraryBashRedirect, { maxLength: 1 }),
+        assignments: fc.array(arbitraryBashAssignment, { minLength: 1, maxLength: 2 }),
+    });
+    const arbitraryBashSimpleCommand = fc.oneof({ weight: 4, arbitrary: arbitraryBashSimpleCommandWithName }, { weight: 1, arbitrary: arbitraryBashSimpleCommandNoName });
+    const arbitraryBashSubshell = fc.record({
+        type: fc.constant('subshell'),
+        body: arbitraryCommandList,
+    });
+    // Brace group bodies need trailing ';' on last entry (required by "{ cmd; }" syntax)
+    const arbitraryBraceGroupBody = arbitraryCommandList.map(list => {
+        const entries = list.entries.map((entry, i) => {
+            if (i === list.entries.length - 1 && entry.separator === undefined) {
+                return { pipeline: entry.pipeline, separator: ';' };
+            }
+            return entry;
+        });
+        return { ...list, entries };
+    });
+    const arbitraryBashBraceGroup = fc.record({
+        type: fc.constant('braceGroup'),
+        body: arbitraryBraceGroupBody,
+    });
+    const arbitraryBashCommandUnit = fc.oneof({ weight: 5, arbitrary: arbitraryBashSimpleCommand }, { weight: 1, arbitrary: arbitraryBashSubshell }, { weight: 1, arbitrary: arbitraryBashBraceGroup });
+    const arbitraryBashPipeline = fc.record({
+        type: fc.constant('pipeline'),
+        negated: fc.boolean(),
+        commands: fc.array(arbitraryBashCommandUnit, { minLength: 1, maxLength: 2 }),
+    });
+    const commandListArbitrary = fc.record({
+        type: fc.constant('list'),
+        entries: fc.array(fc.record({
+            pipeline: arbitraryBashPipeline,
+            separator: fc.option(fc.oneof(fc.constant('&&'), fc.constant('||'), fc.constant(';')), { 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: ';' };
+            }
+            return entry;
+        });
+        return { ...list, entries };
+    });
+    return {
+        commandList: commandListArbitrary,
+    };
+});
+export const arbitraryBashCommandList = recursiveArbitraries.commandList;

package/build/arbitraryJavaScript.js

@@ -164,7 +164,7 @@ const arbitraryFunctionBodyBlockStatement = fc.record({
 const arbitraryArrowFunctionExpression = fc.oneof(fc.record({
     type: fc.constant('ArrowFunctionExpression'),
     id: fc.constant(null),
-    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id) => id.name }),
     body: arbitraryFunctionBodyBlockStatement,
     expression: fc.constant(false),
     generator: fc.constant(false),
@@ -172,7 +172,7 @@ const arbitraryArrowFunctionExpression = fc.oneof(fc.record({
 }), fc.record({
     type: fc.constant('ArrowFunctionExpression'),
     id: fc.constant(null),
-    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id) => id.name }),
     body: arbitraryLeafExpression,
     expression: fc.constant(true),
     generator: fc.constant(false),
@@ -181,7 +181,7 @@ const arbitraryArrowFunctionExpression = fc.oneof(fc.record({
 const arbitraryFunctionExpression = fc.record({
     type: fc.constant('FunctionExpression'),
     id: fc.constant(null),
-    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id) => id.name }),
     body: arbitraryFunctionBodyBlockStatement,
     expression: fc.constant(false),
     generator: fc.constant(false),
@@ -232,7 +232,7 @@ const arbitraryTryStatement = fc.oneof(fc.record({
 const arbitraryFunctionDeclaration = fc.record({
     type: fc.constant('FunctionDeclaration'),
     id: arbitraryIdentifier,
-    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id) => id.name }),
     body: arbitraryFunctionBodyBlockStatement,
     expression: fc.constant(false),
     generator: fc.constant(false),

package/build/arbitraryZipStream.d.ts

@@ -2,4 +2,4 @@ import { type ZipEntry } from './zip.js';
 export declare const arbitraryZipStream: import("fast-check").Arbitrary<readonly [{
     comment: string;
     entries: ZipEntry[];
-}, import("stream/web").ReadableStream<Uint8Array<ArrayBufferLike>>]>;
+}, import("node:stream/web").ReadableStream<Uint8Array<ArrayBufferLike>>]>;

package/build/bashUnparser.d.ts

@@ -0,0 +1,3 @@
+import { type Unparser } from './unparser.js';
+import { type BashCommand } from './bash.js';
+export declare const bashScriptUnparser: Unparser<BashCommand, string>;

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/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/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 = {}));