@futpib/parser 1.0.2 → 1.0.3

package/src/parserContext.ts

@@ -3,11 +3,14 @@
 import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type InputReader } from './inputReader.js';
 import {
-	type ParserParsingFailedError, ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError,
+    normalParserErrorModule,
+    noStackCaptureOverheadParserErrorModule,
+    ParserParsingFailedError,
 } from './parserError.js';
 import { type RunParserOptions } from './parser.js';
 import { type Falsy, customInvariant, type ValueOrAccessor } from './customInvariant.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { formatLazyMessage, isLazyMessageError, LazyMessage } from './lazyMessageError.js';
 
 type LookaheadOptions = {
 	debugName?: string;
@@ -17,6 +20,9 @@ type LookaheadOptions = {
 type ParserContextOptions<Sequence, Element> =
 	& RunParserOptions<unknown, Sequence, Element>
 	& LookaheadOptions
+	& {
+		errorsModule: typeof normalParserErrorModule | typeof noStackCaptureOverheadParserErrorModule;
+	}
 ;
 
 export type ParserContext<Sequence, Element> = {
@@ -41,8 +47,8 @@ export type ParserContext<Sequence, Element> = {
 	unlookahead(): void;
 	dispose(): void;
 
-	invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
-	invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
+	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>;
 };
 
 let parserContextId = 0;
@@ -114,7 +120,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	async peek(offset: number): Promise<Element | undefined> {
 		if (
 			this._options.sliceEnd !== undefined
-				&& (this.position + offset) >= this._options.sliceEnd
+			&& (this.position + offset) >= this._options.sliceEnd
 		) {
 			return undefined;
 		}
@@ -125,7 +131,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	async peekSequence(start: number, end: number): Promise<Sequence | undefined> {
 		if (
 			this._options.sliceEnd !== undefined
-				&& (this.position + end - 1) >= this._options.sliceEnd
+			&& (this.position + end - 1) >= this._options.sliceEnd
 		) {
 			return undefined;
 		}
@@ -163,7 +169,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		const element = await this.peek(offset);
 
 		if (element === undefined) {
-			throw new ParserUnexpectedEndOfInputError('', this._depth, this.position);
+			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
 		}
 
 		this.skip(offset + 1);
@@ -175,7 +181,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		const sequence = await this.peekSequence(start, end);
 
 		if (sequence === undefined) {
-			throw new ParserUnexpectedEndOfInputError('', this._depth, this.position);
+			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
 		}
 
 		this.skip(end);
@@ -238,10 +244,10 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 				'this: %s',
 				'parent: %s',
 				'parent.exclusiveChild: %s',
-			].join('\n'),
-			this.toString(),
-			parentParserContext.toString(),
-			parentParserContext._exclusiveChildParserContext?.toString(),
+			],
+			() => this.toString(),
+			() => parentParserContext.toString(),
+			() => parentParserContext._exclusiveChildParserContext?.toString(),
 		);
 		parserImplementationInvariant(
 			parentParserContext.position <= this.position,
@@ -284,38 +290,38 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 				'this: %s',
 				'parent: %s',
 				'parent.exclusiveChild: %s',
-			].join('\n'),
-			this.toString(),
-			parentParserContext.toString(),
-			parentParserContext._exclusiveChildParserContext?.toString(),
+			],
+			() => this.toString(),
+			() => parentParserContext.toString(),
+			() => parentParserContext._exclusiveChildParserContext?.toString(),
 		);
 
 		parentParserContext._exclusiveChildParserContext = undefined;
 		this._parentParserContext = undefined;
 	}
 
-	invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy> {
+	invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy> {
 		const parserContext = this;
 
-		return customInvariant(function (message: string) {
-			return new ParserParsingInvariantError(message, parserContext._depth, parserContext.position);
+		return customInvariant(function (lazyMessage: LazyMessage) {
+			return new parserContext._options.errorsModule.ParserParsingInvariantError(lazyMessage, parserContext._depth, parserContext.position);
 		}, value, format, ...formatArguments);
 	}
 
-	invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy> {
+	invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy> {
 		parserImplementationInvariant(childErrors.length > 0, 'childErrors.length > 0');
 
 		const errorJoinMode = this._options.errorJoinMode ?? 'none';
 		const parserContext = this;
 
 		if (errorJoinMode === 'none') {
-			return customInvariant(function (message: string) {
-				return new ParserParsingJoinNoneError(message, parserContext._depth, parserContext.position);
+			return customInvariant(function (lazyMessage: LazyMessage) {
+				return new parserContext._options.errorsModule.ParserParsingJoinNoneError(lazyMessage, parserContext._depth, parserContext.position);
 			}, value, format, ...formatArguments);
 		}
 
 		if (errorJoinMode === 'furthest') {
-			return customInvariant(function (message: string) {
+			return customInvariant(function (userLazyMessage: LazyMessage) {
 				let furthestPosition = 0;
 				let furthestChildErrors: ParserParsingFailedError[] = [];
 
@@ -333,23 +339,35 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 					furthestChildErrors.push(childError);
 				}
 
-				message += [
-					'',
-					'Furthest child error stacks, indented:',
-					...furthestChildErrors.flatMap(furthestChildError => furthestChildError.stack?.split('\n').map(line => '  ' + line)),
-					'End of furthest child error stacks',
-				].join('\n');
-
-				return new ParserParsingJoinFurthestError(message, parserContext._depth, furthestPosition, furthestChildErrors);
+				return new parserContext._options.errorsModule.ParserParsingJoinFurthestError([
+					[
+						'%s',
+						'Furthest child error stacks, indented:',
+						'%s',
+						'End of furthest child error stacks',
+					],
+					() => formatLazyMessage(userLazyMessage),
+					() => furthestChildErrors.flatMap(furthestChildError => {
+						if (isLazyMessageError(furthestChildError)) {
+							furthestChildError.computeMessage();
+						}
+
+						return furthestChildError.stack?.split('\n').map(line => '  ' + line);
+					}).join('\n'),
+				], parserContext._depth, furthestPosition, furthestChildErrors);
 			}, value, format, ...formatArguments);
 		}
 
 		if (errorJoinMode === 'deepest') {
-			return customInvariant(function (message: string) {
+			return customInvariant(function (userLazyMessage: LazyMessage) {
 				let deepestDepth = 0;
 				let deepestChildErrors: ParserParsingFailedError[] = [];
 
 				for (const childError of childErrors) {
+					if (isLazyMessageError(childError)) {
+						childError.computeMessage();
+					}
+
 					if (childError.depth < deepestDepth) {
 						continue;
 					}
@@ -363,27 +381,43 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 					deepestChildErrors.push(childError);
 				}
 
-				message += [
-					'',
-					'Deepest child error stacks, indented:',
-					...deepestChildErrors.flatMap(deepestChildError => deepestChildError.stack?.split('\n').map(line => '  ' + line)),
-					'End of deepest child error stacks',
-				].join('\n');
-
-				return new ParserParsingJoinDeepestError(message, deepestDepth, parserContext.position, deepestChildErrors);
+				return new parserContext._options.errorsModule.ParserParsingJoinDeepestError([
+					[
+						'%s',
+						'Deepest child error stacks, indented:',
+						'%s',
+						'End of deepest child error stacks',
+					],
+					() => formatLazyMessage(userLazyMessage),
+					() => deepestChildErrors.flatMap(deepestChildError => {
+						if (isLazyMessageError(deepestChildError)) {
+							deepestChildError.computeMessage();
+						}
+
+						return deepestChildError.stack?.split('\n').map(line => '  ' + line);
+					}).join('\n'),
+				], deepestDepth, parserContext.position, deepestChildErrors);
 			}, value, format, ...formatArguments);
 		}
 
 		if (errorJoinMode === 'all') {
-			return customInvariant(function (message: string) {
-				message += [
-					'',
-					'Child error stacks, indented:',
-					...childErrors.flatMap(childError => childError.stack?.split('\n').map(line => '  ' + line)),
-					'End of child error stacks',
-				].join('\n');
-
-				return new ParserParsingJoinAllError(message, parserContext._depth, parserContext.position, childErrors);
+			return customInvariant(function (userLazyMessage: LazyMessage) {
+				return new parserContext._options.errorsModule.ParserParsingJoinAllError([
+					[
+						'%s',
+						'All child error stacks, indented:',
+						'%s',
+						'End of all child error stacks',
+					],
+					() => formatLazyMessage(userLazyMessage),
+					() => childErrors.flatMap(childError => {
+						if (isLazyMessageError(childError)) {
+							childError.computeMessage();
+						}
+
+						return childError.stack?.split('\n').map(line => '  ' + line);
+					}).join('\n'),
+				], parserContext._depth, parserContext.position, childErrors);
 			}, value, format, ...formatArguments);
 		}
 

package/src/parserError.ts

@@ -1,88 +1,168 @@
-import { InputReaderState } from "./inputReaderState.js";
+import { type InputReaderState } from './inputReaderState.js';
+import { LazyMessage, NormalLazyMessageError, NoStackCaptureOverheadLazyMessageError } from './lazyMessageError.js';
 
-export class ParserError extends Error {
-	name = 'ParserError';
-
-	public position: undefined | number = undefined;
-	public inputReaderSate: undefined | InputReaderState<unknown> = undefined;
+export interface ParserError extends Error {
+	position: undefined | number;
+	inputReaderSate: undefined | InputReaderState<unknown>;
 }
 
-export class ParserImplementationError extends ParserError {
-	name = 'ParserImplementationError';
-}
-export class ParserImplementationInvariantError extends ParserImplementationError {
-	name = 'ParserImplementationInvariantError';
+export function isParserError(value: unknown): value is ParserError {
+	return (
+		typeof value === 'object'
+			&& value !== null
+			&& value instanceof Error
+			&& 'position' in value
+			&& (typeof value.position === 'number' || value.position === undefined)
+			&& 'inputReaderSate' in value
+			&& (value.inputReaderSate === undefined || typeof value.inputReaderSate === 'object')
+	);
 }
 
-export class ParserParsingFailedError extends ParserError {
-	name = 'ParserParsingFailedError';
+type ParserErrorInterface = ParserError;
 
-	constructor(
-		message: string,
-		public readonly depth: number,
-		public readonly position: number,
-	) {
-		super(message);
-	}
+export interface ParserParsingFailedError extends ParserErrorInterface {
+	depth: number;
+	position: number;
 }
 
-export class ParserParsingJoinError extends ParserParsingFailedError {
-	name = 'ParserParsingJoinError';
+export function isParserParsingFailedError(value: unknown): value is ParserParsingFailedError {
+	return (
+		typeof value === 'object'
+			&& value !== null
+			&& value instanceof Error
+			&& 'depth' in value
+			&& typeof value.depth === 'number'
+			&& 'position' in value
+			&& typeof value.position === 'number'
+	);
+}
 
-	public readonly childErrors: ParserParsingFailedError[] = [];
+type ParserParsingFailedErrorInterface = ParserParsingFailedError;
+
+export interface ParserParsingJoinError extends ParserParsingFailedErrorInterface {
+	childErrors: ParserParsingFailedErrorInterface[];
 }
 
-export class ParserParsingJoinNoneError extends ParserParsingJoinError {
-	name = 'ParserParsingJoinNoneError';
+export function isParserParsingJoinError(value: unknown): value is ParserParsingJoinError {
+	return (
+		typeof value === 'object'
+			&& value !== null
+			&& value instanceof Error
+			&& 'childErrors' in value
+			&& Array.isArray(value.childErrors)
+			&& value.childErrors.every((childError: unknown) => isParserParsingFailedError(childError))
+	);
 }
 
-export class ParserParsingJoinAllError extends ParserParsingJoinError {
-	name = 'ParserParsingJoinAllError';
+type ParserParsingJoinErrorInterface = ParserParsingJoinError;
+
+function createParserErrorModule(
+	BaseLazyMessageError: typeof NormalLazyMessageError | typeof NoStackCaptureOverheadLazyMessageError,
+) {
+	class ParserError extends BaseLazyMessageError implements ParserErrorInterface {
+		name = 'ParserError';
 
-	constructor(
-		message: string,
-		depth: number,
-		position: number,
-		public readonly childErrors: ParserParsingFailedError[],
-	) {
-		super(message, depth, position);
+		public position: undefined | number = undefined;
+		public inputReaderSate: undefined | InputReaderState<unknown> = undefined;
 	}
-}
 
-export class ParserParsingJoinDeepestError extends ParserParsingJoinError {
-	name = 'ParserParsingJoinDeepestError';
+	class ParserImplementationError extends ParserError {
+		name = 'ParserImplementationError';
+	}
+	class ParserImplementationInvariantError extends ParserImplementationError {
+		name = 'ParserImplementationInvariantError';
+	}
 
-	constructor(
-		message: string,
-		depth: number,
-		position: number,
-		public readonly childErrors: ParserParsingFailedError[],
-	) {
-		super(message, depth, position);
+	class ParserParsingFailedError extends ParserError implements ParserParsingFailedErrorInterface {
+		name = 'ParserParsingFailedError';
+
+		constructor(
+			message: LazyMessage,
+			public readonly depth: number,
+			public readonly position: number,
+		) {
+			super(message);
+		}
 	}
-}
 
-export class ParserParsingJoinFurthestError extends ParserParsingJoinError {
-	name = 'ParserParsingJoinFurthestError';
+	class ParserParsingJoinError extends ParserParsingFailedError implements ParserParsingJoinErrorInterface {
+		name = 'ParserParsingJoinError';
 
-	constructor(
-		message: string,
-		depth: number,
-		position: number,
-		public readonly childErrors: ParserParsingFailedError[],
-	) {
-		super(message, depth, position);
+		public readonly childErrors: ParserParsingFailedErrorInterface[] = [];
 	}
-}
 
-export class ParserParsingInvariantError extends ParserParsingFailedError {
-	name = 'ParserParsingInvariantError';
-}
+	class ParserParsingJoinNoneError extends ParserParsingJoinError {
+		name = 'ParserParsingJoinNoneError';
+	}
 
-export class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
-	name = 'ParserUnexpectedEndOfInputError';
-}
+	class ParserParsingJoinAllError extends ParserParsingJoinError {
+		name = 'ParserParsingJoinAllError';
+
+		constructor(
+			message: LazyMessage,
+			depth: number,
+			position: number,
+			public readonly childErrors: ParserParsingFailedErrorInterface[],
+		) {
+			super(message, depth, position);
+		}
+	}
+
+	class ParserParsingJoinDeepestError extends ParserParsingJoinError {
+		name = 'ParserParsingJoinDeepestError';
+
+		constructor(
+			message: LazyMessage,
+			depth: number,
+			position: number,
+			public readonly childErrors: ParserParsingFailedErrorInterface[],
+		) {
+			super(message, depth, position);
+		}
+	}
+
+	class ParserParsingJoinFurthestError extends ParserParsingJoinError {
+		name = 'ParserParsingJoinFurthestError';
+
+		constructor(
+			message: LazyMessage,
+			depth: number,
+			position: number,
+			public readonly childErrors: ParserParsingFailedErrorInterface[],
+		) {
+			super(message, depth, position);
+		}
+	}
+
+	class ParserParsingInvariantError extends ParserParsingFailedError {
+		name = 'ParserParsingInvariantError';
+	}
+
+	class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
+		name = 'ParserUnexpectedEndOfInputError';
+	}
 
-export class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
-	name = 'ParserUnexpectedRemainingInputError';
+	class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
+		name = 'ParserUnexpectedRemainingInputError';
+	}
+
+	return {
+		ParserError,
+		ParserImplementationError,
+		ParserImplementationInvariantError,
+		ParserParsingFailedError,
+		ParserParsingJoinError,
+		ParserParsingJoinNoneError,
+		ParserParsingJoinAllError,
+		ParserParsingJoinDeepestError,
+		ParserParsingJoinFurthestError,
+		ParserParsingInvariantError,
+		ParserUnexpectedEndOfInputError,
+		ParserUnexpectedRemainingInputError,
+	};
 }
+
+export type ParserErrorModule = ReturnType<typeof createParserErrorModule>;
+
+export const normalParserErrorModule = createParserErrorModule(NormalLazyMessageError);
+export const noStackCaptureOverheadParserErrorModule = createParserErrorModule(NoStackCaptureOverheadLazyMessageError);

package/src/parserImplementationInvariant.ts

@@ -1,6 +1,6 @@
-import { ParserImplementationInvariantError } from './parserError.js';
 import { type Falsy, customInvariant, type ValueOrAccessor } from './customInvariant.js';
+import { normalParserErrorModule } from './parserError.js';
 
-export function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy> {
-	return customInvariant(ParserImplementationInvariantError, value, format, ...formatArguments);
+export function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy> {
+	return customInvariant(normalParserErrorModule.ParserImplementationInvariantError, value, format, ...formatArguments);
 }

package/src/parserInputCompanion.ts

@@ -89,8 +89,8 @@ export class Uint8ArrayParserInputCompanion implements ParserInputCompanion<Uint
 			return false;
 		}
 
-		for (let index = 0; index < sequenceA.length; index++) {
-			if (sequenceA[index] !== sequenceB[index]) {
+		for (const [ index, element ] of sequenceA.entries()) {
+			if (element !== sequenceB[index]) {
 				return false;
 			}
 		}

package/src/promiseCompose.ts

@@ -3,7 +3,7 @@ export function promiseCompose<A, B, C>(
 	f1: (a: A) => B | Promise<B>,
 	f2: (b: B) => C | Promise<C>,
 ): (a: A) => C | Promise<C> {
-	function promiseComposed(a: A) {
+	async function promiseComposed(a: A) {
 		const bOrBPromise = f1(a);
 
 		if (bOrBPromise instanceof Promise) {
@@ -11,7 +11,7 @@ export function promiseCompose<A, B, C>(
 		}
 
 		return f2(bOrBPromise);
-	};
+	}
 
 	Object.defineProperty(promiseComposed, 'name', {
 		value: `promiseCompose(${f1.name}, ${f2.name})`,

package/src/separatedArrayParser.ts

@@ -1,5 +1,5 @@
 import { getParserName, type Parser, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createTupleParser } from './tupleParser.js';
 
@@ -34,7 +34,7 @@ export const createSeparatedArrayParser = <ElementOutput, Sequence>(
 				elements.push(element);
 				elementParserContext.unlookahead();
 			} catch (error) {
-				if (error instanceof ParserParsingFailedError) {
+				if (isParserParsingFailedError(error)) {
 					break;
 				}
 
@@ -43,7 +43,7 @@ export const createSeparatedArrayParser = <ElementOutput, Sequence>(
 				elementParserContext.dispose();
 			}
 
-			parser = separatorThenElementParser
+			parser = separatorThenElementParser;
 		}
 
 		return elements;

package/src/separatedNonEmptyArrayParser.test.ts

@@ -0,0 +1,117 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
+import { type Parser, runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { stringFromAsyncIterable } from './stringFromAsyncIterable.js';
+
+test('empty input throws error', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	await t.throwsAsync(async () => runParser(parser, '', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});
+
+test('single element without separator matches', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	const result = await runParser(parser, 'element', stringParserInputCompanion);
+	t.deepEqual(result, [ 'element' ]);
+});
+
+test('two elements with separator matches', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	const result = await runParser(parser, 'element,element', stringParserInputCompanion);
+	t.deepEqual(result, [ 'element', 'element' ]);
+});
+
+test('multiple elements with separator matches', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('a'),
+		createExactSequenceParser(','),
+	);
+
+	const result = await runParser(parser, 'a,a,a,a', stringParserInputCompanion);
+	t.deepEqual(result, [ 'a', 'a', 'a', 'a' ]);
+});
+
+test('does not consume trailing separator', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	const { output, remainingInput } = await runParserWithRemainingInput(parser, 'element,element,', stringParserInputCompanion);
+	t.deepEqual(output, [ 'element', 'element' ]);
+	t.is(await stringFromAsyncIterable(remainingInput!), ',');
+});
+
+test('does not loop forever with a child parser that does not consume anything', async t => {
+	const parser: Parser<undefined[], string> = createSeparatedNonEmptyArrayParser(
+		async () => undefined,
+		() => undefined,
+	);
+
+	await t.throwsAsync(async () => runParser(parser, 'foo', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});
+
+test('partial match throws error', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	await t.throwsAsync(async () => runParser(parser, 'elem', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});
+
+testProp(
+	'separatedNonEmptyArray with at least one element',
+	[
+		fc.array(fc.constant('element'), { minLength: 1 }),
+	],
+	async (t, elements) => {
+		const separatedNonEmptyArrayParser = createSeparatedNonEmptyArrayParser(
+			createExactSequenceParser('element'),
+			createExactSequenceParser('separator'),
+		);
+
+		const actual = await runParser(separatedNonEmptyArrayParser, elements.join('separator'), stringParserInputCompanion);
+		const expected = elements;
+
+		t.deepEqual(actual, expected);
+	},
+	{
+		verbose: true,
+	},
+);
+
+test('separatedNonEmptyArray throws on empty array', async t => {
+	const separatedNonEmptyArrayParser = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser('separator'),
+	);
+
+	await t.throwsAsync(async () => runParser(separatedNonEmptyArrayParser, '', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});