@futpib/parser 1.0.1 → 1.0.2

package/src/parserError.ts

@@ -1,6 +1,10 @@
+import { InputReaderState } from "./inputReaderState.js";
 
 export class ParserError extends Error {
 	name = 'ParserError';
+
+	public position: undefined | number = undefined;
+	public inputReaderSate: undefined | InputReaderState<unknown> = undefined;
 }
 
 export class ParserImplementationError extends ParserError {
@@ -18,12 +22,7 @@ export class ParserParsingFailedError extends ParserError {
 		public readonly depth: number,
 		public readonly position: number,
 	) {
-		super([
-			'(position: ',
-			position,
-			') ',
-			message,
-		].join(''));
+		super(message);
 	}
 }
 
@@ -83,3 +82,7 @@ export class ParserParsingInvariantError extends ParserParsingFailedError {
 export class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
 	name = 'ParserUnexpectedEndOfInputError';
 }
+
+export class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
+	name = 'ParserUnexpectedRemainingInputError';
+}

package/src/parserInputCompanion.ts

@@ -2,8 +2,13 @@
 export type ParserInputCompanion<Sequence, Element> = {
 	is(value: unknown): value is Sequence;
 	from(elements: Element[]): Sequence;
+	concat(sequences: Sequence[]): Sequence;
 	length(sequence: Sequence): number;
 	at(sequence: Sequence, index: number): Element | undefined;
+	subsequence(sequence: Sequence, start: number, end: number): Sequence;
+	indexOf(sequence: Sequence, element: Element, fromIndex?: number): number;
+	indexOfSubsequence(sequence: Sequence, subsequence: Sequence, fromIndex?: number): number;
+	equals(sequenceA: Sequence, sequenceB: Sequence): boolean;
 };
 
 export class StringParserInputCompanion implements ParserInputCompanion<string, string> {
@@ -15,6 +20,10 @@ export class StringParserInputCompanion implements ParserInputCompanion<string,
 		return elements.join('');
 	}
 
+	concat(sequences: string[]): string {
+		return sequences.join('');
+	}
+
 	length(sequence: string): number {
 		return sequence.length;
 	}
@@ -22,6 +31,22 @@ export class StringParserInputCompanion implements ParserInputCompanion<string,
 	at(sequence: string, index: number): string | undefined {
 		return sequence.at(index);
 	}
+
+	subsequence(sequence: string, start: number, end: number): string {
+		return sequence.slice(start, end);
+	}
+
+	indexOf(sequence: string, element: string, fromIndex?: number): number {
+		return sequence.indexOf(element, fromIndex);
+	}
+
+	indexOfSubsequence(sequence: string, subsequence: string, fromIndex?: number): number {
+		return sequence.indexOf(subsequence, fromIndex);
+	}
+
+	equals(sequenceA: string, sequenceB: string): boolean {
+		return sequenceA === sequenceB;
+	}
 }
 
 export const stringParserInputCompanion = new StringParserInputCompanion();
@@ -35,6 +60,10 @@ export class Uint8ArrayParserInputCompanion implements ParserInputCompanion<Uint
 		return new Uint8Array(elements);
 	}
 
+	concat(sequences: Uint8Array[]): Uint8Array {
+		return new Uint8Array(Buffer.concat(sequences));
+	}
+
 	length(sequence: Uint8Array): number {
 		return sequence.length;
 	}
@@ -42,6 +71,32 @@ export class Uint8ArrayParserInputCompanion implements ParserInputCompanion<Uint
 	at(sequence: Uint8Array, index: number): number | undefined {
 		return sequence.at(index);
 	}
+
+	subsequence(sequence: Uint8Array, start: number, end: number): Uint8Array {
+		return sequence.subarray(start, end);
+	}
+
+	indexOf(sequence: Uint8Array, element: number, fromIndex?: number): number {
+		return sequence.indexOf(element, fromIndex);
+	}
+
+	indexOfSubsequence(sequence: Uint8Array, subsequence: Uint8Array, fromIndex?: number): number {
+		return Buffer.from(sequence).indexOf(Buffer.from(subsequence), fromIndex);
+	}
+
+	equals(sequenceA: Uint8Array, sequenceB: Uint8Array): boolean {
+		if (sequenceA.length !== sequenceB.length) {
+			return false;
+		}
+
+		for (let index = 0; index < sequenceA.length; index++) {
+			if (sequenceA[index] !== sequenceB[index]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
 }
 
 export const uint8ArrayParserInputCompanion = new Uint8ArrayParserInputCompanion();

package/src/promiseCompose.ts

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

package/src/promiseSettled.ts

@@ -0,0 +1,6 @@
+
+export async function promiseSettled<T>(promise: Promise<T>): Promise<PromiseSettledResult<T>> {
+	const [ promiseSettledResult ] = await Promise.allSettled([ promise ]);
+
+	return promiseSettledResult;
+}

package/src/separatedArrayParser.test.ts

@@ -0,0 +1,34 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedArrayParser } from './separatedArrayParser.js';
+import { type Parser, runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+
+test('does not loop forever with a child parser that does not consume anything', async t => {
+	const parser: Parser<undefined[], string> = createSeparatedArrayParser(async () => undefined, () => undefined);
+	const { output } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
+
+	t.deepEqual(output, []);
+});
+
+testProp(
+	'separatedArray',
+	[
+		fc.array(fc.constant('element')),
+	],
+	async (t, elements) => {
+		const separatedArrayParser = createSeparatedArrayParser(
+			createExactSequenceParser('element'),
+			createExactSequenceParser('separator'),
+		);
+
+		const actual = await runParser(separatedArrayParser, elements.join('separator'), stringParserInputCompanion);
+		const expected = elements;
+
+		t.deepEqual(actual, expected);
+	},
+	{
+		verbose: true,
+	},
+);

package/src/separatedArrayParser.ts

@@ -0,0 +1,55 @@
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+
+export const createSeparatedArrayParser = <ElementOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+	separatorParser: Parser<unknown, Sequence>,
+): Parser<ElementOutput[], Sequence> => {
+	const separatorThenElementParser: Parser<ElementOutput, Sequence> = promiseCompose(
+		createTupleParser([
+			separatorParser,
+			elementParser,
+		]),
+		([ , element ]) => element,
+	);
+
+	const separatedArrayParser: Parser<ElementOutput[], Sequence> = async parserContext => {
+		let parser = elementParser;
+
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const elementParserContext = parserContext.lookahead();
+			const initialPosition = elementParserContext.position;
+
+			try {
+				const element = await parser(elementParserContext);
+
+				if (elementParserContext.position === initialPosition) {
+					break;
+				}
+
+				elements.push(element);
+				elementParserContext.unlookahead();
+			} catch (error) {
+				if (error instanceof ParserParsingFailedError) {
+					break;
+				}
+
+				throw error;
+			} finally {
+				elementParserContext.dispose();
+			}
+
+			parser = separatorThenElementParser
+		}
+
+		return elements;
+	};
+
+	setParserName(separatedArrayParser, getParserName(elementParser, 'anonymousSeparatedArrayChild') + '*');
+
+	return separatedArrayParser;
+};

package/src/sequenceBuffer.test.ts

@@ -5,46 +5,116 @@ import { stringParserInputCompanion } from './parserInputCompanion.js';
 test('sequenceBuffer', t => {
 	const sequenceBuffer = new SequenceBufferImplementation(stringParserInputCompanion);
 
+	t.is(sequenceBuffer.length, 0);
 	t.is(sequenceBuffer.peek(0), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: [],
+	});
+
 	sequenceBuffer.push('');
 
+	t.is(sequenceBuffer.length, 0);
 	t.is(sequenceBuffer.peek(0), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: [],
+	});
+
 	sequenceBuffer.push('abc');
 
+	t.is(sequenceBuffer.length, 3);
 	t.is(sequenceBuffer.peek(0), 'a');
 	t.is(sequenceBuffer.peek(1), 'b');
 	t.is(sequenceBuffer.peek(2), 'c');
 	t.is(sequenceBuffer.peek(3), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: ['abc'],
+	});
+
 	sequenceBuffer.push('def');
 
+	t.is(sequenceBuffer.length, 6);
 	t.is(sequenceBuffer.peek(0), 'a');
 	t.is(sequenceBuffer.peek(3), 'd');
 	t.is(sequenceBuffer.peek(6), undefined);
 
+	t.is(sequenceBuffer.peekSequence(1, 4), 'abcdef'.slice(1, 4), 'bcd');
+	t.is(sequenceBuffer.peekSequence(1, 5), 'abcdef'.slice(1, 5), 'bcde');
+	t.is(sequenceBuffer.peekSequence(1, 6), 'abcdef'.slice(1, 6), 'bcdef');
+	t.is(sequenceBuffer.peekSequence(1, 7), undefined, 'bcdef?');
+
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: ['abc', 'def'],
+	});
+
 	sequenceBuffer.push('');
 
+	t.is(sequenceBuffer.length, 6);
 	t.is(sequenceBuffer.peek(0), 'a');
 	t.is(sequenceBuffer.peek(3), 'd');
 	t.is(sequenceBuffer.peek(6), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: ['abc', 'def', ''],
+	});
+
 	sequenceBuffer.skip(1);
 
+	t.is(sequenceBuffer.length, 5);
 	t.is(sequenceBuffer.peek(0), 'b');
 	t.is(sequenceBuffer.peek(3), 'e');
 	t.is(sequenceBuffer.peek(5), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: ['a'],
+		unconsumedBufferedSequences: ['bc', 'def', ''],
+	});
+
 	sequenceBuffer.skip(3);
 
+	t.is(sequenceBuffer.length, 2);
 	t.is(sequenceBuffer.peek(0), 'e');
 	t.is(sequenceBuffer.peek(2), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: ['d'],
+		unconsumedBufferedSequences: ['ef', ''],
+	});
+
 	sequenceBuffer.push('gh');
 
+	t.is(sequenceBuffer.length, 4);
 	t.is(sequenceBuffer.peek(0), 'e');
 	t.is(sequenceBuffer.peek(2), 'g');
 	t.is(sequenceBuffer.peek(3), 'h');
 	t.is(sequenceBuffer.peek(4), undefined);
+
+	t.is(sequenceBuffer.peekSequence(1, 3), 'efgh'.slice(1, 3), 'fg');
+	t.is(sequenceBuffer.peekSequence(1, 4), 'efgh'.slice(1, 4), 'fgh');
+	t.is(sequenceBuffer.peekSequence(1, 5), undefined, 'fgh?');
+
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: ['d'],
+		unconsumedBufferedSequences: ['ef', '', 'gh'],
+	});
+});
+
+test('skip more then first sequence length', t => {
+	const sequenceBuffer = new SequenceBufferImplementation(stringParserInputCompanion);
+
+	sequenceBuffer.push('a');
+	sequenceBuffer.push('b');
+	sequenceBuffer.skip(2);
+
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: [],
+	});
 });

package/src/sequenceBuffer.ts

@@ -1,10 +1,18 @@
 import invariant from 'invariant';
 import { type ParserInputCompanion } from './parserInputCompanion.js';
 
+export type SequenceBufferState<Sequence> = {
+	consumedBufferedSequences: Sequence[];
+	unconsumedBufferedSequences: Sequence[];
+};
+
 export type SequenceBuffer<Sequence, Element> = {
 	push(sequence: Sequence): void;
 	peek(offset: number): Element | undefined;
+	peekSequence(start: number, end: number): Sequence | undefined;
 	skip(offset: number): void;
+
+	toSequenceBufferState(): SequenceBufferState<Sequence>;
 };
 
 export class SequenceBufferImplementation<Sequence, Element> implements SequenceBuffer<Sequence, Element> {
@@ -13,9 +21,14 @@ export class SequenceBufferImplementation<Sequence, Element> implements Sequence
 
 	constructor(private readonly _parserInputCompanion: ParserInputCompanion<Sequence, Element>) {}
 
-	push(sequence: Sequence) {
-		this._sequences.push(sequence);
+	get length() {
+		return this._sequences.reduce(
+			(sequenceLength, sequence) => sequenceLength + this._parserInputCompanion.length(sequence),
+			0 - this._indexInFirstSequence,
+		);
+	}
 
+	private _shift() {
 		while (this._sequences.length > 0) {
 			const firstSequence = this._sequences[0];
 			const firstSequenceLength = this._parserInputCompanion.length(firstSequence);
@@ -34,6 +47,12 @@ export class SequenceBufferImplementation<Sequence, Element> implements Sequence
 		}
 	}
 
+	push(sequence: Sequence) {
+		this._sequences.push(sequence);
+
+		this._shift();
+	}
+
 	peek(offset: number): Element | undefined {
 		invariant(offset >= 0, 'Offset must be non-negative.');
 
@@ -52,7 +71,74 @@ export class SequenceBufferImplementation<Sequence, Element> implements Sequence
 		return undefined;
 	}
 
+	peekSequence(start: number, end: number): Sequence | undefined {
+		invariant(start >= 0, 'Start must be non-negative.');
+		invariant(end >= start, 'End must be greater than or equal to start.');
+
+		let startIndex = this._indexInFirstSequence + start;
+		let endIndex = this._indexInFirstSequence + end;
+
+		const sequences: Sequence[] = [];
+
+		for (const sequence of this._sequences) {
+			const sequenceLength = this._parserInputCompanion.length(sequence);
+
+			if (startIndex < sequenceLength) {
+				const subsequence = this._parserInputCompanion.subsequence(
+					sequence,
+					Math.max(0, startIndex),
+					Math.min(sequenceLength, endIndex),
+				)
+				sequences.push(subsequence);
+			}
+
+			startIndex -= sequenceLength;
+			endIndex -= sequenceLength;
+
+			if (endIndex <= 0) {
+				break;
+			}
+		}
+
+		return endIndex > 0 ? undefined : this._parserInputCompanion.concat(sequences);
+	}
+
 	skip(offset: number) {
 		this._indexInFirstSequence += offset;
+
+		this._shift();
+	}
+
+	toSequenceBufferState(): SequenceBufferState<Sequence> {
+		if (this._sequences.length === 0) {
+			return {
+				consumedBufferedSequences: [],
+				unconsumedBufferedSequences: [],
+			};
+		}
+
+		if (this._indexInFirstSequence === 0) {
+			return {
+				consumedBufferedSequences: [],
+				unconsumedBufferedSequences: this._sequences.slice(),
+			};
+		}
+
+		const firstSequence = this._sequences[0];
+		const firstSequenceLength = this._parserInputCompanion.length(firstSequence);
+
+		const consumedFirstSequence = this._parserInputCompanion.subsequence(firstSequence, 0, this._indexInFirstSequence);
+		const unconsumedFirstSequence = this._parserInputCompanion.subsequence(firstSequence, this._indexInFirstSequence, firstSequenceLength);
+
+		const unconsumedFirstSequenceLength = this._parserInputCompanion.length(unconsumedFirstSequence);
+
+		return {
+			consumedBufferedSequences: [consumedFirstSequence],
+			unconsumedBufferedSequences: (
+				unconsumedFirstSequenceLength === 0
+					? this._sequences.slice(1)
+					: [unconsumedFirstSequence, ...this._sequences.slice(1)]
+			),
+		};
 	}
 }

package/src/sequenceTerminatedSequenceParser.test.ts

@@ -0,0 +1,60 @@
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { Parser, runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createSequenceTerminatedSequenceParser } from './sequenceTerminatedSequenceParser.js';
+
+testProp.serial(
+	'sequenceTerminatedSequenceParser',
+	[
+		fc.tuple(
+			fc
+				.string({
+					minLength: 1,
+				}),
+			fc
+				.integer({
+					min: 1,
+				}),
+		)
+			.map(([ string, terminatorLength ]) => ({
+				string,
+				terminator: string.slice(-terminatorLength),
+			}))
+			.filter(({ string, terminator }) => string.split(terminator).length === 2)
+	],
+	async (t, { string, terminator }) => {
+		const sequenceTerminatedSequenceParser = createSequenceTerminatedSequenceParser<string>(
+			terminator,
+		);
+
+		const createTestWrapperParser = (innerParser: typeof sequenceTerminatedSequenceParser): Parser<{
+			string: string;
+			nextPeek: string | undefined;
+			position: number;
+		}, string> => async parserContext => {
+			const string = await innerParser(parserContext);
+
+			return {
+				string,
+				nextPeek: await parserContext.peek(0),
+				position: parserContext.position,
+			};
+		};
+
+		const actual = await runParser(
+			createTestWrapperParser(sequenceTerminatedSequenceParser),
+			string,
+			stringParserInputCompanion,
+		);
+
+		t.deepEqual(actual, {
+			string: string.split(terminator)[0],
+			nextPeek: undefined,
+			position: string.length,
+		});
+	},
+	{
+		verbose: true,
+	},
+);

package/src/sequenceTerminatedSequenceParser.ts

@@ -0,0 +1,62 @@
+import { inspect } from "./inspect.js";
+import { Parser, setParserName } from "./parser.js";
+import { DeriveSequenceElement } from "./sequence.js";
+
+function clamp(x: number, min: number, max: number) {
+	return Math.max(min, Math.min(x, max));
+}
+
+export const createSequenceTerminatedSequenceParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(
+	terminatorSequence: Sequence,
+	{
+		consumeTerminator = true,
+	}: {
+		consumeTerminator?: boolean;
+	} = {},
+): Parser<Sequence, Sequence, Element> => {
+	const elementTerminatedSequenceParser: Parser<Sequence, Sequence, Element> = async parserContext => {
+		let window = 1;
+		let nonEndOfInputWindow = 0;
+
+		while (true) {
+			const sequence = await parserContext.peekSequence(0, window);
+
+			if (sequence === undefined) {
+				window = clamp(
+					Math.floor(window * 0.75),
+					nonEndOfInputWindow + 1,
+					window - 1,
+				);
+
+				parserContext.invariant(
+					window !== nonEndOfInputWindow,
+					'Unexpected end of input without terminated sequence',
+				);
+
+				continue;
+			}
+
+			nonEndOfInputWindow = Math.max(window, nonEndOfInputWindow);
+
+			const terminatorIndex = parserContext.indexOfSubsequence(sequence, terminatorSequence);
+
+			if (terminatorIndex === -1) {
+				window = window * 2;
+
+				continue;
+			}
+
+			const sequence_ = await parserContext.readSequence(0, terminatorIndex);
+
+			if (consumeTerminator) {
+				parserContext.skip(parserContext.length(terminatorSequence));
+			}
+
+			return sequence_;
+		}
+	};
+
+	setParserName(elementTerminatedSequenceParser, `.*?${inspect(terminatorSequence)}`);
+
+	return elementTerminatedSequenceParser;
+};

package/src/skipParser.ts

@@ -1,12 +1,14 @@
-import { type Parser } from './parser.js';
+import { setParserName, type Parser } from './parser.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 
-export const createSkipParser = <Sequence>(length: number): Parser<undefined, Sequence, unknown> => {
+export const createSkipParser = <Sequence>(length: number): Parser<void, Sequence, unknown> => {
 	parserImplementationInvariant(length > 0, 'Length must be positive.');
 
-	return async parserContext => {
+	const skipParser: Parser<void, Sequence, unknown> = parserContext => {
 		parserContext.skip(length);
-
-		return undefined;
 	};
+
+	setParserName(skipParser, `createSkipParser(${length})`);
+
+	return skipParser;
 };

package/src/skipToParser.ts

@@ -0,0 +1,16 @@
+import { Parser, setParserName } from "./parser.js";
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+
+export const createSkipToParser = (offset: number): Parser<void, Uint8Array> => {
+	const skipToParser: Parser<void, Uint8Array> = (parserContext) => {
+		const length = offset - parserContext.position;
+
+		parserImplementationInvariant(length >= 0, 'Skip length must be positive, got %s (position: %s)', length, parserContext.position);
+
+		parserContext.skip(length);
+	};
+
+	setParserName(skipToParser, `createSkipToParser(${offset})`);
+
+	return skipToParser;
+};