@futpib/parser 1.0.3 → 1.0.6

package/src/parserContext.ts

@@ -36,6 +36,8 @@ export type ParserContext<Sequence, Element> = {
 	equals(sequenceA: Sequence, sequenceB: Sequence): boolean;
 
 	get position(): number;
+	get furthestReadPosition(): number;
+	get furthestPeekedPosition(): number;
 	peek(offset: number): Promise<Element | undefined>;
 	peekSequence(start: number, end: number): Promise<Sequence | undefined>;
 	skip(offset: number): void;
@@ -46,6 +48,7 @@ export type ParserContext<Sequence, Element> = {
 	lookahead(options?: LookaheadOptions): ParserContext<Sequence, Element>;
 	unlookahead(): void;
 	dispose(): void;
+	[Symbol.dispose](): void;
 
 	invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;
 	invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;
@@ -117,6 +120,14 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return this._inputReader.position;
 	}
 
+	get furthestReadPosition() {
+		return this._inputReader.furthestReadPosition;
+	}
+
+	get furthestPeekedPosition() {
+		return this._inputReader.furthestPeekedPosition;
+	}
+
 	async peek(offset: number): Promise<Element | undefined> {
 		if (
 			this._options.sliceEnd !== undefined
@@ -169,7 +180,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		const element = await this.peek(offset);
 
 		if (element === undefined) {
-			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
+			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position, this._inputReader.furthestReadPosition, this._inputReader.furthestPeekedPosition);
 		}
 
 		this.skip(offset + 1);
@@ -181,7 +192,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		const sequence = await this.peekSequence(start, end);
 
 		if (sequence === undefined) {
-			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
+			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position, this._inputReader.furthestReadPosition, this._inputReader.furthestPeekedPosition);
 		}
 
 		this.skip(end);
@@ -300,11 +311,15 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		this._parentParserContext = undefined;
 	}
 
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+
 	invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy> {
 		const parserContext = this;
 
 		return customInvariant(function (lazyMessage: LazyMessage) {
-			return new parserContext._options.errorsModule.ParserParsingInvariantError(lazyMessage, parserContext._depth, parserContext.position);
+			return new parserContext._options.errorsModule.ParserParsingInvariantError(lazyMessage, parserContext._depth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition);
 		}, value, format, ...formatArguments);
 	}
 
@@ -316,22 +331,22 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 
 		if (errorJoinMode === 'none') {
 			return customInvariant(function (lazyMessage: LazyMessage) {
-				return new parserContext._options.errorsModule.ParserParsingJoinNoneError(lazyMessage, parserContext._depth, parserContext.position);
+				return new parserContext._options.errorsModule.ParserParsingJoinNoneError(lazyMessage, parserContext._depth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition);
 			}, value, format, ...formatArguments);
 		}
 
 		if (errorJoinMode === 'furthest') {
 			return customInvariant(function (userLazyMessage: LazyMessage) {
-				let furthestPosition = 0;
+				let furthestChildErrorPosition = 0;
 				let furthestChildErrors: ParserParsingFailedError[] = [];
 
 				for (const childError of childErrors) {
-					if (childError.position < furthestPosition) {
+					if (childError.position < furthestChildErrorPosition) {
 						continue;
 					}
 
-					if (childError.position > furthestPosition) {
-						furthestPosition = childError.position;
+					if (childError.position > furthestChildErrorPosition) {
+						furthestChildErrorPosition = childError.position;
 						furthestChildErrors = [ childError ];
 						continue;
 					}
@@ -354,7 +369,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 
 						return furthestChildError.stack?.split('\n').map(line => '  ' + line);
 					}).join('\n'),
-				], parserContext._depth, furthestPosition, furthestChildErrors);
+				], parserContext._depth, furthestChildErrorPosition, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition, furthestChildErrors);
 			}, value, format, ...formatArguments);
 		}
 
@@ -396,7 +411,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 
 						return deepestChildError.stack?.split('\n').map(line => '  ' + line);
 					}).join('\n'),
-				], deepestDepth, parserContext.position, deepestChildErrors);
+				], deepestDepth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition, deepestChildErrors);
 			}, value, format, ...formatArguments);
 		}
 
@@ -417,7 +432,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 
 						return childError.stack?.split('\n').map(line => '  ' + line);
 					}).join('\n'),
-				], parserContext._depth, parserContext.position, childErrors);
+				], parserContext._depth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition, childErrors);
 			}, value, format, ...formatArguments);
 		}
 

package/src/parserError.ts

@@ -23,6 +23,8 @@ type ParserErrorInterface = ParserError;
 export interface ParserParsingFailedError extends ParserErrorInterface {
 	depth: number;
 	position: number;
+	furthestReadPosition: number;
+	furthestPeekedPosition: number;
 }
 
 export function isParserParsingFailedError(value: unknown): value is ParserParsingFailedError {
@@ -34,6 +36,10 @@ export function isParserParsingFailedError(value: unknown): value is ParserParsi
 			&& typeof value.depth === 'number'
 			&& 'position' in value
 			&& typeof value.position === 'number'
+			&& 'furthestReadPosition' in value
+			&& typeof value.furthestReadPosition === 'number'
+			&& 'furthestPeekedPosition' in value
+			&& typeof value.furthestPeekedPosition === 'number'
 	);
 }
 
@@ -80,6 +86,8 @@ function createParserErrorModule(
 			message: LazyMessage,
 			public readonly depth: number,
 			public readonly position: number,
+			public readonly furthestReadPosition: number,
+			public readonly furthestPeekedPosition: number,
 		) {
 			super(message);
 		}
@@ -102,9 +110,11 @@ function createParserErrorModule(
 			message: LazyMessage,
 			depth: number,
 			position: number,
+			furthestReadPosition: number,
+			furthestPeekedPosition: number,
 			public readonly childErrors: ParserParsingFailedErrorInterface[],
 		) {
-			super(message, depth, position);
+			super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
 		}
 	}
 
@@ -115,9 +125,11 @@ function createParserErrorModule(
 			message: LazyMessage,
 			depth: number,
 			position: number,
+			furthestReadPosition: number,
+			furthestPeekedPosition: number,
 			public readonly childErrors: ParserParsingFailedErrorInterface[],
 		) {
-			super(message, depth, position);
+			super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
 		}
 	}
 
@@ -128,9 +140,11 @@ function createParserErrorModule(
 			message: LazyMessage,
 			depth: number,
 			position: number,
+			furthestReadPosition: number,
+			furthestPeekedPosition: number,
 			public readonly childErrors: ParserParsingFailedErrorInterface[],
 		) {
-			super(message, depth, position);
+			super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
 		}
 	}
 

package/src/regexpParser.test.ts

@@ -0,0 +1,264 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createRegExpParser } from './regexpParser.js';
+
+test('regexpParser matches digits', async t => {
+	const regexpParser = createRegExpParser(/\d+/);
+
+	const result = await runParser(
+		regexpParser,
+		'123',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '123');
+});
+
+test('regexpParser matches at start only', async t => {
+	const regexpParser = createRegExpParser(/\d+/);
+
+	const { output, remainingInput } = await runParserWithRemainingInput(
+		regexpParser,
+		'123abc',
+		stringParserInputCompanion,
+	);
+
+	t.is(output[0], '123');
+	t.truthy(remainingInput);
+});
+
+test('regexpParser fails when no match at start', async t => {
+	const regexpParser = createRegExpParser(/\d+/);
+
+	await t.throwsAsync(
+		runParser(
+			regexpParser,
+			'abc123',
+			stringParserInputCompanion,
+		),
+	);
+});
+
+test('regexpParser with capture groups', async t => {
+	const regexpParser = createRegExpParser(/(\d+)-(\d+)/);
+
+	const result = await runParser(
+		regexpParser,
+		'123-456',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '123-456');
+	t.is(result[1], '123');
+	t.is(result[2], '456');
+});
+
+test('regexpParser greedy matching', async t => {
+	const regexpParser = createRegExpParser(/a+/);
+
+	const { output } = await runParserWithRemainingInput(
+		regexpParser,
+		'aaab',
+		stringParserInputCompanion,
+	);
+
+	t.is(output[0], 'aaa');
+});
+
+test('regexpParser with anchored regexp', async t => {
+	const regexpParser = createRegExpParser(/^hello/);
+
+	const { output } = await runParserWithRemainingInput(
+		regexpParser,
+		'hello world',
+		stringParserInputCompanion,
+	);
+
+	t.is(output[0], 'hello');
+});
+
+testProp.serial(
+	'regexpParser matches word characters',
+	[
+		fc.tuple(
+			fc.stringMatching(/^\w+$/),
+			fc.stringMatching(/^\W*$/),
+		),
+	],
+	async (t, [ word, nonWord ]) => {
+		const regexpParser = createRegExpParser(/\w+/);
+
+		const { output, position } = await runParserWithRemainingInput(
+			regexpParser,
+			word + nonWord,
+			stringParserInputCompanion,
+		);
+
+		t.is(output[0], word);
+		t.is(position, word.length);
+	},
+	{
+		verbose: true,
+	},
+);
+
+// Tests for zero-width/optional patterns at end of input
+
+test('regexpParser with star quantifier on empty input', async t => {
+	const regexpParser = createRegExpParser(/a*/);
+
+	const result = await runParser(
+		regexpParser,
+		'',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '');
+});
+
+test('regexpParser with optional whitespace on empty input', async t => {
+	const regexpParser = createRegExpParser(/[ \t]*/);
+
+	const result = await runParser(
+		regexpParser,
+		'',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '');
+});
+
+test('regexpParser with star quantifier at end of input (no match)', async t => {
+	const regexpParser = createRegExpParser(/a*/);
+
+	const { output } = await runParserWithRemainingInput(
+		regexpParser,
+		'bbb',
+		stringParserInputCompanion,
+	);
+
+	t.is(output[0], '');
+});
+
+test('regexpParser with optional group on empty input', async t => {
+	const regexpParser = createRegExpParser(/(?:foo)?/);
+
+	const result = await runParser(
+		regexpParser,
+		'',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '');
+});
+
+// Tests for negative lookahead
+
+test('regexpParser with negative lookahead should not match when followed by same char', async t => {
+	// This regex should NOT match anything in '||' - the | is followed by another |
+	const regexpParser = createRegExpParser(/\|(?!\|)/);
+
+	await t.throwsAsync(
+		runParser(
+			regexpParser,
+			'||',
+			stringParserInputCompanion,
+		),
+	);
+});
+
+test('regexpParser with negative lookahead should match single char', async t => {
+	// This regex should match single '|' when followed by something else
+	const regexpParser = createRegExpParser(/\|(?!\|)/);
+
+	const { output, position, remainingInput } = await runParserWithRemainingInput(
+		regexpParser,
+		'| ',
+		stringParserInputCompanion,
+	);
+
+	t.is(output[0], '|');
+	t.is(position, 1); // Consumed 1 character
+	t.truthy(remainingInput); // There's remaining input (the space)
+});
+
+test('regexpParser should match exact 6-character input', async t => {
+	const regexpParser = createRegExpParser(/abcdef/);
+
+	const result = await runParser(
+		regexpParser,
+		'abcdef',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], 'abcdef');
+});
+
+test('regexpParser should match quoted string of length 6', async t => {
+	const regexpParser = createRegExpParser(/"[^"]*"/);
+
+	const result = await runParser(
+		regexpParser,
+		'"abcd"', // 6 characters total
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '"abcd"');
+});
+
+// Property-based tests for fixed-length patterns
+
+testProp(
+	'regexpParser should match exact n-character input for any length',
+	[fc.integer({ min: 1, max: 20 })],
+	async (t, length) => {
+		const input = 'a'.repeat(length);
+		const regex = new RegExp(`a{${length}}`);
+		const regexpParser = createRegExpParser(regex);
+
+		const result = await runParser(
+			regexpParser,
+			input,
+			stringParserInputCompanion,
+		);
+
+		t.is(result[0], input);
+	},
+);
+
+testProp(
+	'regexpParser should match quoted strings of any length',
+	[fc.integer({ min: 0, max: 20 })],
+	async (t, contentLength) => {
+		const content = 'x'.repeat(contentLength);
+		const input = `"${content}"`;
+		const regexpParser = createRegExpParser(/"[^"]*"/);
+
+		const result = await runParser(
+			regexpParser,
+			input,
+			stringParserInputCompanion,
+		);
+
+		t.is(result[0], input);
+	},
+);
+
+testProp(
+	'regexpParser greedy patterns should match any length input',
+	[fc.stringMatching(/^[a-z]+$/).filter(s => s.length > 0 && s.length <= 20)],
+	async (t, input) => {
+		const regexpParser = createRegExpParser(/[a-z]+/);
+
+		const result = await runParser(
+			regexpParser,
+			input,
+			stringParserInputCompanion,
+		);
+
+		t.is(result[0], input);
+	},
+);

package/src/regexpParser.ts

@@ -0,0 +1,126 @@
+import { type Parser, setParserName } from './parser.js';
+
+export const createRegExpParser = (
+	regexp: RegExp,
+): Parser<RegExpExecArray, string, string> => {
+	const regexpParser: Parser<RegExpExecArray, string, string> = async parserContext => {
+		let start = 0;
+		let window = 1;
+		let lastMatch: RegExpExecArray | undefined;
+		let reachedEndOfInput = false;
+		let inputLength: number | undefined;
+
+		while (true) {
+			const sequence = await parserContext.peekSequence(start, start + window);
+
+			if (sequence === undefined) {
+				if (!reachedEndOfInput) {
+					reachedEndOfInput = true;
+
+					// Binary search to find actual input length
+					// We know: length >= start (we've peeked successfully before)
+					// We know: length < start + window (current peek failed)
+					let lo = start;
+					let hi = start + window;
+					while (hi - lo > 1) {
+						const mid = (lo + hi) >> 1;
+						const probe = await parserContext.peekSequence(0, mid);
+						if (probe !== undefined) {
+							lo = mid;
+						} else {
+							hi = mid;
+						}
+					}
+					inputLength = lo;
+
+					// Try matching against the full input
+					if (inputLength > 0) {
+						const fullInput = await parserContext.peekSequence(0, inputLength);
+						if (fullInput !== undefined) {
+							const match = regexp.exec(fullInput);
+							if (match !== null && match.index === 0) {
+								parserContext.skip(match[0].length);
+								return match;
+							}
+						}
+					}
+				}
+
+				window = Math.floor(window / 2);
+
+				if (window === 0) {
+					// Get the full sequence we've accumulated to verify matches
+					const fullSequence = await parserContext.peekSequence(0, inputLength ?? start);
+
+					// Verify any previous match is still valid with full context
+					// For lookahead/lookbehind assertions, additional input might invalidate a match
+					if (fullSequence !== undefined) {
+						const verifyMatch = regexp.exec(fullSequence);
+						if (verifyMatch !== null && verifyMatch.index === 0) {
+							parserContext.skip(verifyMatch[0].length);
+							return verifyMatch;
+						}
+					} else if (lastMatch !== undefined) {
+						// No full sequence available but we have a previous match
+						parserContext.skip(lastMatch[0].length);
+						return lastMatch;
+					}
+
+					// No previous match - try matching against empty string for zero-width patterns (e.g., /a*/, /[ \t]*/)
+					const emptyMatch = regexp.exec('');
+					if (emptyMatch !== null && emptyMatch.index === 0) {
+						return emptyMatch;
+					}
+
+					return parserContext.invariant(false, 'Unexpected end of input without regex match');
+				}
+
+				continue;
+			}
+
+			const fullSequence = await parserContext.peekSequence(0, inputLength ?? start + window);
+
+			if (fullSequence === undefined) {
+				continue;
+			}
+
+			const match = regexp.exec(fullSequence);
+
+			if (match === null || match.index !== 0) {
+				if (lastMatch !== undefined) {
+					// Verify lastMatch is still valid with current full context
+					// For lookahead/lookbehind assertions, a match on shorter input might be
+					// invalidated by additional input (e.g., /\|(?!\|)/ matches '|' but not '||')
+					const verifyMatch = regexp.exec(fullSequence);
+					if (verifyMatch !== null && verifyMatch.index === 0) {
+						parserContext.skip(verifyMatch[0].length);
+						return verifyMatch;
+					}
+					// lastMatch was invalidated by additional context
+					lastMatch = undefined;
+				}
+
+				if (reachedEndOfInput) {
+					parserContext.invariant(
+						false,
+						'Regex did not match at start of input',
+					);
+				}
+
+				start += window;
+				window *= 2;
+
+				continue;
+			}
+
+			lastMatch = match;
+
+			start += window;
+			window *= 2;
+		}
+	};
+
+	setParserName(regexpParser, regexp.toString());
+
+	return regexpParser;
+};

package/src/regularExpression.ts

@@ -0,0 +1,24 @@
+export type CodePointRange = {
+	start: number;
+	end: number;
+};
+
+export type CharacterSet =
+	| { type: 'empty' }
+	| { type: 'node'; range: CodePointRange; left: CharacterSet; right: CharacterSet };
+
+export type RepeatBounds = number | { min: number; max?: number } | { min?: number; max: number };
+
+export type RegularExpression =
+	| { type: 'epsilon' }
+	| { type: 'literal'; charset: CharacterSet }
+	| { type: 'concat'; left: RegularExpression; right: RegularExpression }
+	| { type: 'union'; left: RegularExpression; right: RegularExpression }
+	| { type: 'star'; inner: RegularExpression }
+	| { type: 'plus'; inner: 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: 'start-anchor'; left: RegularExpression; right: RegularExpression }
+	| { type: 'end-anchor'; left: RegularExpression; right: RegularExpression };

package/src/regularExpressionParser.test.ts

@@ -0,0 +1,102 @@
+import { testProp, fc } from '@fast-check/ava';
+import { regularExpressionParser } from './regularExpressionParser.js';
+
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+
+// Import directly from file path to bypass package exports
+// eslint-disable-next-line import/no-unresolved
+import { parseRegExpString } from '../node_modules/@gruhn/regex-utils/dist/regex-parser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
+import type { RegularExpression, CharacterSet } from './regularExpression.js';
+
+// Normalize AST for comparison - removes hashes from CharSets and normalizes structure
+function normalizeCharacterSet(charset: CharacterSet): CharacterSet {
+	if (charset.type === 'empty') {
+		return { type: 'empty' };
+	}
+	return {
+		type: 'node',
+		range: { start: charset.range.start, end: charset.range.end },
+		left: normalizeCharacterSet(charset.left),
+		right: normalizeCharacterSet(charset.right),
+	};
+}
+
+function normalizeRegularExpression(ast: RegularExpression): RegularExpression {
+	switch (ast.type) {
+		case 'epsilon':
+			return { type: 'epsilon' };
+		case 'literal':
+			return { type: 'literal', charset: normalizeCharacterSet(ast.charset) };
+		case 'concat':
+			return { type: 'concat', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+		case 'union':
+			return { type: 'union', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+		case 'star':
+			return { type: 'star', inner: normalizeRegularExpression(ast.inner) };
+		case 'plus':
+			return { type: 'plus', inner: normalizeRegularExpression(ast.inner) };
+		case 'optional':
+			return { type: 'optional', inner: normalizeRegularExpression(ast.inner) };
+		case 'repeat':
+			return { type: 'repeat', inner: normalizeRegularExpression(ast.inner), bounds: ast.bounds };
+		case 'capture-group':
+			if (ast.name !== undefined) {
+				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 'start-anchor':
+			return { type: 'start-anchor', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+		case 'end-anchor':
+			return { type: 'end-anchor', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+	}
+}
+
+// Generate regex patterns that are likely to be supported
+const supportedRegexArbitrary = fc.stringMatching(
+	/^([a-zA-Z0-9]|\\[dDwWsS.]|\[(\^)?([a-zA-Z0-9](-[a-zA-Z0-9])?|\\[dDwWsS])*\]|\.|\((\?[:=!])?[a-zA-Z0-9]*\)|[*+?]|\{[0-9]+(,[0-9]*)?\}|\||\^|\$)*$/,
+).filter(s => {
+	// Filter out patterns that JavaScript doesn't support
+	try {
+		new RegExp(s);
+	} catch {
+		return false;
+	}
+	// Filter out patterns that @gruhn/regex-utils doesn't support
+	try {
+		parseRegExpString(s);
+	} catch {
+		return false;
+	}
+	// Filter out quantified lookaheads - @gruhn/regex-utils has a bug where it treats
+	// quantifiers after lookaheads as literals instead of quantifiers.
+	// See: https://github.com/gruhn/regex-utils/issues/13
+	// JavaScript allows (?=a){2} but @gruhn/regex-utils parses {2} as literal text.
+	if (/\(\?[=!][^)]*\)[*+?]|\(\?[=!][^)]*\)\{[0-9]/.test(s)) {
+		return false;
+	}
+	return true;
+});
+
+testProp(
+	'regularExpressionParser matches @gruhn/regex-utils',
+	[
+		arbitrarilySlicedAsyncIterator(supportedRegexArbitrary),
+	],
+	async (t, [regexStr, regexStringChunkIterator]) => {
+		const expected = normalizeRegularExpression(parseRegExpString(regexStr));
+		const actual = normalizeRegularExpression(await runParser(regularExpressionParser, regexStringChunkIterator, stringParserInputCompanion, {
+			errorJoinMode: 'none',
+		}));
+
+		t.deepEqual(actual, expected);
+	},
+	{
+		verbose: true,
+		seed,
+	},
+);