@futpib/parser 1.0.0 → 1.0.1

package/src/listParser.ts

@@ -1,9 +1,9 @@
-import { createNegativeLookaheadParser } from "./negativeLookahead.js";
-import { Parser } from "./parser.js";
-import { createParserAccessorParser } from "./parserAccessorParser.js";
-import { promiseCompose } from "./promiseCompose.js";
-import { createTupleParser } from "./tupleParser.js";
-import { createUnionParser } from "./unionParser.js";
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { type Parser } from './parser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createUnionParser } from './unionParser.js';
 
 class Nil {}
 class Cons<Head, Tail> {

package/src/negativeLookaheadParser.ts

@@ -0,0 +1,24 @@
+import { getParserName, type Parser } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+
+export const createNegativeLookaheadParser = <Sequence>(
+	childParser: Parser<unknown, Sequence>,
+): Parser<void, Sequence> => async parserContext => {
+	const childParserContext = parserContext.lookahead();
+	try {
+		await childParser(childParserContext);
+		parserContext.invariant(
+			false,
+			'Negative lookahead assertion failed for child parser %s.',
+			getParserName(childParser),
+		);
+	} catch (error) {
+		if (error instanceof ParserParsingFailedError) {
+			return;
+		}
+
+		throw error;
+	} finally {
+		childParserContext.dispose();
+	}
+};

package/src/optionalParser.ts

@@ -1,5 +1,5 @@
-import { getParserName, Parser, setParserName } from "./parser.js";
-import { ParserParsingFailedError } from "./parserError.js";
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
 
 export const createOptionalParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,
@@ -24,4 +24,4 @@ export const createOptionalParser = <Output, Sequence>(
 	setParserName(optionalParser, getParserName(childParser, 'anonymousOptionalChild') + '?');
 
 	return optionalParser;
-}
+};

package/src/parser.test.ts

@@ -1,12 +1,14 @@
 import test from 'ava';
+import invariant from 'invariant';
 import { createUnionParser } from './unionParser.js';
-import { Parser, runParser } from './parser.js';
-import { stringInputCompanion, uint8ArrayInputCompanion } from './inputCompanion.js';
-import { ParserParsingInvariantError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinError, ParserParsingJoinFurthestError, ParserParsingJoinNoneError } from './parserError.js';
+import { type Parser, runParser } from './parser.js';
+import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import {
+	ParserParsingInvariantError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinError, ParserParsingJoinFurthestError, ParserParsingJoinNoneError,
+} from './parserError.js';
 import { createTupleParser } from './tupleParser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
-import invariant from 'invariant';
 import { createExactSequenceParser } from './exactSequenceParser.js';
 import { createArrayParser } from './arrayParser.js';
 import { createElementParser } from './elementParser.js';
@@ -55,14 +57,14 @@ function sortChildErrors(error: ParserParsingJoinNoneError) {
 }
 
 function removeStackLocations(errorStack: string) {
-	return errorStack.replace(/((at [^\n]+)[\s\n]+)+(at [^\n]+)/g, 'at [LOCATIONS]');
+	return errorStack.replaceAll(/((at [^\n]+)[\s\n]+)+(at [^\n]+)/g, 'at [LOCATIONS]');
 }
 
 test('errorJoinMode: none', async t => {
-	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
 		errorJoinMode: 'none',
 	}), {
-		instanceOf: ParserParsingJoinNoneError
+		instanceOf: ParserParsingJoinNoneError,
 	});
 
 	t.is(error.position, 12);
@@ -72,10 +74,10 @@ test('errorJoinMode: none', async t => {
 });
 
 test('errorJoinMode: all', async t => {
-	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
 		errorJoinMode: 'all',
 	}), {
-		instanceOf: ParserParsingJoinAllError
+		instanceOf: ParserParsingJoinAllError,
 	});
 
 	sortChildErrors(error);
@@ -107,7 +109,7 @@ test('errorJoinMode: all', async t => {
 });
 
 test('errorJoinMode: deepest', async t => {
-	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
 		errorJoinMode: 'deepest',
 	}), {
 		instanceOf: ParserParsingJoinDeepestError,
@@ -142,7 +144,7 @@ test('errorJoinMode: deepest', async t => {
 });
 
 test('errorJoinMode: furthest', async t => {
-	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
 		errorJoinMode: 'furthest',
 	}), {
 		instanceOf: ParserParsingJoinFurthestError,
@@ -162,15 +164,15 @@ test('errorJoinMode: furthest', async t => {
 	t.is(error1.position, 12);
 });
 
-test('throws on inputCompanion type mismatch', async t => {
+test('throws on parserInputCompanion type mismatch', async t => {
 	const anythingParser: Parser<any, any> = createArrayParser(createElementParser());
 
-	await runParser(anythingParser, asyncIteratorFromString('anything'), stringInputCompanion);
-	await runParser(anythingParser, 'anything', stringInputCompanion);
-	await runParser(anythingParser, Buffer.from('anything'), uint8ArrayInputCompanion);
-	await runParser(anythingParser, new Uint8Array([ 1, 2, 3 ]), uint8ArrayInputCompanion);
+	await runParser(anythingParser, asyncIteratorFromString('anything'), stringParserInputCompanion);
+	await runParser(anythingParser, 'anything', stringParserInputCompanion);
+	await runParser(anythingParser, Buffer.from('anything'), uint8ArrayParserInputCompanion);
+	await runParser(anythingParser, new Uint8Array([ 1, 2, 3 ]), uint8ArrayParserInputCompanion);
 
-	await t.throwsAsync(runParser(anythingParser, asyncIteratorFromString('anything'), uint8ArrayInputCompanion), {
+	await t.throwsAsync(runParser(anythingParser, asyncIteratorFromString('anything'), uint8ArrayParserInputCompanion), {
 		message: /input companion/,
 	});
 });

package/src/parser.ts

@@ -1,8 +1,8 @@
 import invariant from 'invariant';
-import { type InputCompanion } from './inputCompanion.js';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { InputReaderImplementation } from './inputReader.js';
 import { type ParserContext, ParserContextImplementation } from './parserContext.js';
-import { DeriveSequenceElement } from './sequence.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
 export type Parser<
 	Output,
@@ -32,7 +32,7 @@ export type RunParserOptions<
 	Element = DeriveSequenceElement<Sequence>,
 > = {
 	errorJoinMode?: 'none' | 'deepest' | 'furthest' | 'all';
-}
+};
 
 function isAsyncIterable<T>(value: any): value is AsyncIterable<T> {
 	return value && typeof value[Symbol.asyncIterator] === 'function';
@@ -57,7 +57,7 @@ function toAsyncIterator<T>(value: AsyncIterator<T> | AsyncIterable<T> | Iterabl
 		typeof value === 'string'
 		|| value instanceof Uint8Array
 	) {
-		return (async function*() {
+		return (async function * () {
 			yield value as any;
 		})();
 	}
@@ -88,13 +88,13 @@ export async function runParser<
 >(
 	parser: Parser<Output, Sequence, Element>,
 	input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence,
-	inputCompanion: InputCompanion<Sequence, Element>,
+	parserInputCompanion: ParserInputCompanion<Sequence, Element>,
 	options: RunParserOptions<Output, Sequence, Element> = {},
 ): Promise<Output> {
 	const inputAsyncIterator = toAsyncIterator(input);
 
-	const inputReader = new InputReaderImplementation<Sequence, Element>(inputCompanion, inputAsyncIterator);
-	const parserContext = new ParserContextImplementation<Sequence, Element>(inputCompanion, inputReader, undefined, {
+	const inputReader = new InputReaderImplementation<Sequence, Element>(parserInputCompanion, inputAsyncIterator);
+	const parserContext = new ParserContextImplementation<Sequence, Element>(parserInputCompanion, inputReader, undefined, {
 		...options,
 		debugName: 'root',
 	});

package/src/parserAccessorParser.ts

@@ -1,3 +1,3 @@
-import { Parser } from "./parser.js";
+import { type Parser } from './parser.js';
 
 export const createParserAccessorParser = <Output, Sequence>(parserAccessor: () => Parser<Output, Sequence>): Parser<Output, Sequence> => async parserContext => parserAccessor()(parserContext);

package/src/parserConsumedSequenceParser.ts

@@ -0,0 +1,20 @@
+import { createFixedLengthSequenceParser } from "./fixedLengthSequenceParser.js";
+import { Parser } from "./parser.js";
+
+export const createParserConsumedSequenceParser = <Output, Sequence>(
+	childParser: Parser<Output, Sequence>,
+): Parser<[Output, Sequence], Sequence> => async parserContext => {
+	const initialPosition = parserContext.position;
+	const childParserContext = parserContext.lookahead();
+	let value: Output;
+	let consumedLength: number;
+	try {
+		value = await childParser(childParserContext);
+		consumedLength = childParserContext.position - initialPosition;
+	} finally {
+		childParserContext.dispose();
+	}
+	const consumedSequenceParser = createFixedLengthSequenceParser<Sequence>(consumedLength);
+	const consumedSequence = await consumedSequenceParser(parserContext);
+	return [value, consumedSequence];
+}

package/src/parserContext.test.ts

@@ -1,6 +1,6 @@
 import test from 'ava';
 import { ParserContextImplementation } from './parserContext.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { InputReaderImplementation } from './inputReader.js';
 import { ParserUnexpectedEndOfInputError } from './parserError.js';
 
@@ -13,7 +13,7 @@ const commonParserContextArguments = [
 ] as const;
 
 test('parserContext.read', async t => {
-	const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield '';
 		yield 'abc';
 		yield 'def';
@@ -31,7 +31,7 @@ test('parserContext.read', async t => {
 });
 
 test('parserContext.lookahead', async t => {
-	const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
 	})()), ...commonParserContextArguments);
 
@@ -66,7 +66,7 @@ test('parserContext.lookahead', async t => {
 });
 
 test('parserContext.unlookahead', async t => {
-	const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
 	})()), ...commonParserContextArguments);
 
@@ -86,7 +86,7 @@ test('parserContext.unlookahead', async t => {
 });
 
 test('parserContext.unlookahead while peeking', async t => {
-	const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
 	})()), ...commonParserContextArguments);
 
@@ -103,7 +103,7 @@ test('parserContext.unlookahead while peeking', async t => {
 });
 
 test('parserContext deep unlookahead normal order', async t => {
-	const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
 	})()), ...commonParserContextArguments);
 
@@ -125,7 +125,7 @@ test('parserContext deep unlookahead normal order', async t => {
 });
 
 test('parserContext deep unlookahead weird order', async t => {
-	const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
 	})()), ...commonParserContextArguments);
 

package/src/parserContext.ts

@@ -1,9 +1,13 @@
+/* eslint-disable prefer-arrow-callback */
+
 import invariant from 'invariant';
-import { type InputCompanion } from './inputCompanion.js';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type InputReader } from './inputReader.js';
-import { ParserParsingFailedError, ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError } from './parserError.js';
-import { RunParserOptions } from './parser.js';
-import { Falsy, parserInvariant, ValueOrAccessor } from './parserInvariant.js';
+import {
+	type ParserParsingFailedError, ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError,
+} from './parserError.js';
+import { type RunParserOptions } from './parser.js';
+import { type Falsy, customInvariant, type ValueOrAccessor } from './customInvariant.js';
 
 type LookaheadOptions = {
 	debugName?: string;
@@ -43,7 +47,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	private _exclusiveChildParserContext: ParserContext<Sequence, Element> | undefined = undefined;
 
 	constructor(
-		private readonly _inputCompanion: InputCompanion<Sequence, Element>,
+		private readonly _parserInputCompanion: ParserInputCompanion<Sequence, Element>,
 		private _inputReader: InputReader<Sequence, Element>,
 		private _parentParserContext: ParserContextImplementation<Sequence, Element> | undefined = undefined,
 		private readonly _options: ParserContextOptions<Sequence, Element>,
@@ -65,15 +69,15 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	}
 
 	from(elements: Element[]): Sequence {
-		return this._inputCompanion.from(elements);
+		return this._parserInputCompanion.from(elements);
 	}
 
 	length(sequence: Sequence): number {
-		return this._inputCompanion.length(sequence);
+		return this._parserInputCompanion.length(sequence);
 	}
 
 	at(sequence: Sequence, index: number): Element | undefined {
-		return this._inputCompanion.at(sequence, index);
+		return this._parserInputCompanion.at(sequence, index);
 	}
 
 	get position() {
@@ -122,7 +126,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		);
 
 		const lookaheadParserContext = new ParserContextImplementation(
-			this._inputCompanion,
+			this._parserInputCompanion,
 			lookaheadInputReader,
 			this,
 			{
@@ -221,7 +225,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy> {
 		const parserContext = this;
 
-		return parserInvariant(function (message: string) {
+		return customInvariant(function (message: string) {
 			return new ParserParsingInvariantError(message, parserContext._depth, parserContext.position);
 		}, value, format, ...formatArguments);
 	}
@@ -233,13 +237,13 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		const parserContext = this;
 
 		if (errorJoinMode === 'none') {
-			return parserInvariant(function (message: string) {
+			return customInvariant(function (message: string) {
 				return new ParserParsingJoinNoneError(message, parserContext._depth, parserContext.position);
 			}, value, format, ...formatArguments);
 		}
 
 		if (errorJoinMode === 'furthest') {
-			return parserInvariant(function (message: string) {
+			return customInvariant(function (message: string) {
 				let furthestPosition = 0;
 				let furthestChildErrors: ParserParsingFailedError[] = [];
 
@@ -269,7 +273,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		}
 
 		if (errorJoinMode === 'deepest') {
-			return parserInvariant(function (message: string) {
+			return customInvariant(function (message: string) {
 				let deepestDepth = 0;
 				let deepestChildErrors: ParserParsingFailedError[] = [];
 
@@ -299,7 +303,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		}
 
 		if (errorJoinMode === 'all') {
-			return parserInvariant(function (message: string) {
+			return customInvariant(function (message: string) {
 				message += [
 					'',
 					'Child error stacks, indented:',

package/src/parserCreatorCompose.ts

@@ -1,5 +1,5 @@
-import { Parser } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
+import { type Parser } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
 export function parserCreatorCompose<
 	Arguments extends unknown[],
@@ -8,11 +8,11 @@ export function parserCreatorCompose<
 	Sequence,
 	Element = DeriveSequenceElement<Sequence>,
 >(
-	f1: (...args: Arguments) => Parser<OutputA, Sequence, Element>,
+	f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>,
 	f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>,
-): (...args: Arguments) => Parser<OutputB, Sequence, Element> {
-	return (...args) => {
-		const parserA = f1(...args);
+): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element> {
+	return (...arguments_) => {
+		const parserA = f1(...arguments_);
 
 		return async parserContext => {
 			const outputA = await parserA(parserContext);

package/src/parserImplementationInvariant.ts

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

package/src/{inputCompanion.ts → parserInputCompanion.ts}

@@ -1,12 +1,12 @@
 
-export type InputCompanion<Sequence, Element> = {
+export type ParserInputCompanion<Sequence, Element> = {
 	is(value: unknown): value is Sequence;
 	from(elements: Element[]): Sequence;
 	length(sequence: Sequence): number;
 	at(sequence: Sequence, index: number): Element | undefined;
 };
 
-export const stringInputCompanion = new class StringInputCompanion implements InputCompanion<string, string> {
+export class StringParserInputCompanion implements ParserInputCompanion<string, string> {
 	is(value: unknown): value is string {
 		return typeof value === 'string';
 	}
@@ -22,11 +22,13 @@ export const stringInputCompanion = new class StringInputCompanion implements In
 	at(sequence: string, index: number): string | undefined {
 		return sequence.at(index);
 	}
-}();
+}
 
-export const uint8ArrayInputCompanion = new class Uint8ArrayInputCompanion implements InputCompanion<Uint8Array, number> {
+export const stringParserInputCompanion = new StringParserInputCompanion();
+
+export class Uint8ArrayParserInputCompanion implements ParserInputCompanion<Uint8Array, number> {
 	is(value: unknown): value is Uint8Array {
-		return value instanceof Uint8Array
+		return value instanceof Uint8Array;
 	}
 
 	from(elements: number[]): Uint8Array {
@@ -40,4 +42,6 @@ export const uint8ArrayInputCompanion = new class Uint8ArrayInputCompanion imple
 	at(sequence: Uint8Array, index: number): number | undefined {
 		return sequence.at(index);
 	}
-}();
+}
+
+export const uint8ArrayParserInputCompanion = new Uint8ArrayParserInputCompanion();

package/src/quantifierParser.ts

@@ -0,0 +1,25 @@
+import { getParserName, type Parser, setParserName } from './parser.js';
+
+export const createQuantifierParser = <Output, Sequence>(
+	childParser: Parser<Output, Sequence>,
+	count: number,
+): Parser<Output[], Sequence> => {
+	const quantifierParser: Parser<Output[], Sequence> = async parserContext => {
+		const elements: Output[] = [];
+
+		for (let index = 0; index < count; index++) {
+			elements.push(await childParser(parserContext));
+		}
+
+		return elements;
+	};
+
+	setParserName(quantifierParser, [
+		getParserName(childParser, 'anonymousQuantifierChild'),
+		'{',
+		count,
+		'}',
+	].join(''));
+
+	return quantifierParser;
+};

package/src/sequenceBuffer.test.ts

@@ -1,9 +1,9 @@
 import test from 'ava';
 import { SequenceBufferImplementation } from './sequenceBuffer.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 
 test('sequenceBuffer', t => {
-	const sequenceBuffer = new SequenceBufferImplementation(stringInputCompanion);
+	const sequenceBuffer = new SequenceBufferImplementation(stringParserInputCompanion);
 
 	t.is(sequenceBuffer.peek(0), undefined);
 

package/src/sequenceBuffer.ts

@@ -1,5 +1,5 @@
 import invariant from 'invariant';
-import { type InputCompanion } from './inputCompanion.js';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 
 export type SequenceBuffer<Sequence, Element> = {
 	push(sequence: Sequence): void;
@@ -11,14 +11,14 @@ export class SequenceBufferImplementation<Sequence, Element> implements Sequence
 	private readonly _sequences: Sequence[] = [];
 	private _indexInFirstSequence = 0;
 
-	constructor(private readonly _inputCompanion: InputCompanion<Sequence, Element>) {}
+	constructor(private readonly _parserInputCompanion: ParserInputCompanion<Sequence, Element>) {}
 
 	push(sequence: Sequence) {
 		this._sequences.push(sequence);
 
 		while (this._sequences.length > 0) {
 			const firstSequence = this._sequences[0];
-			const firstSequenceLength = this._inputCompanion.length(firstSequence);
+			const firstSequenceLength = this._parserInputCompanion.length(firstSequence);
 
 			if (firstSequenceLength === 0) {
 				this._sequences.shift();
@@ -40,10 +40,10 @@ export class SequenceBufferImplementation<Sequence, Element> implements Sequence
 		let index = this._indexInFirstSequence + offset;
 
 		for (const sequence of this._sequences) {
-			const sequenceLength = this._inputCompanion.length(sequence);
+			const sequenceLength = this._parserInputCompanion.length(sequence);
 
 			if (index < sequenceLength) {
-				return this._inputCompanion.at(sequence, index);
+				return this._parserInputCompanion.at(sequence, index);
 			}
 
 			index -= sequenceLength;

package/src/sequenceUnparser.ts

@@ -0,0 +1,9 @@
+import { Unparser } from "./unparser.js";
+
+export const createSequenceUnparser = <Sequence>(): Unparser<Sequence, Sequence> => {
+	const sequenceUnparser: Unparser<Sequence, Sequence> = async function * (input) {
+		yield input;
+	};
+
+	return sequenceUnparser;
+}

package/src/sliceBoundedParser.test.ts

@@ -4,7 +4,7 @@ import { createElementParser } from './elementParser.js';
 import { createTupleParser } from './tupleParser.js';
 import { createSliceBoundedParser } from './sliceBoundedParser.js';
 import { runParser } from './parser.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 
 const anythingParser = createArrayParser(createElementParser<string>());
 
@@ -15,7 +15,7 @@ test('sliceBoundedParser', async t => {
 		createElementParser(),
 	]);
 
-	const result = await runParser(parser, 'abba', stringInputCompanion);
+	const result = await runParser(parser, 'abba', stringParserInputCompanion);
 
 	t.deepEqual(result, [
 		'a',

package/src/sliceBoundedParser.ts

@@ -1,4 +1,4 @@
-import { getParserName, Parser, setParserName } from "./parser.js";
+import { getParserName, type Parser, setParserName } from './parser.js';
 
 export const createSliceBoundedParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,
@@ -27,4 +27,4 @@ export const createSliceBoundedParser = <Output, Sequence>(
 	].join(''));
 
 	return sliceBoundedParser;
-}
+};

package/src/terminatedArrayParser.ts

@@ -1,6 +1,6 @@
-import { getParserName, Parser, setParserName } from "./parser.js";
-import { promiseCompose } from "./promiseCompose.js";
-import { createUnionParser } from "./unionParser.js";
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createUnionParser } from './unionParser.js';
 
 class Terminated<T> {
 	constructor(

package/src/uint8Array.ts

@@ -0,0 +1,10 @@
+
+export async function uint8ArrayAsyncIterableToUint8Array(
+	uint8ArrayAsyncIterable: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,
+): Promise<Uint8Array> {
+	const chunks: Uint8Array[] = [];
+	for await (const chunk of uint8ArrayAsyncIterable) {
+		chunks.push(chunk);
+	}
+	return Buffer.concat(chunks);
+}