@futpib/parser 1.0.0

package/src/sequenceBuffer.ts

@@ -0,0 +1,58 @@
+import invariant from 'invariant';
+import { type InputCompanion } from './inputCompanion.js';
+
+export type SequenceBuffer<Sequence, Element> = {
+	push(sequence: Sequence): void;
+	peek(offset: number): Element | undefined;
+	skip(offset: number): void;
+};
+
+export class SequenceBufferImplementation<Sequence, Element> implements SequenceBuffer<Sequence, Element> {
+	private readonly _sequences: Sequence[] = [];
+	private _indexInFirstSequence = 0;
+
+	constructor(private readonly _inputCompanion: InputCompanion<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);
+
+			if (firstSequenceLength === 0) {
+				this._sequences.shift();
+				continue;
+			}
+
+			if (this._indexInFirstSequence < firstSequenceLength) {
+				break;
+			}
+
+			this._sequences.shift();
+			this._indexInFirstSequence -= firstSequenceLength;
+		}
+	}
+
+	peek(offset: number): Element | undefined {
+		invariant(offset >= 0, 'Offset must be non-negative.');
+
+		let index = this._indexInFirstSequence + offset;
+
+		for (const sequence of this._sequences) {
+			const sequenceLength = this._inputCompanion.length(sequence);
+
+			if (index < sequenceLength) {
+				return this._inputCompanion.at(sequence, index);
+			}
+
+			index -= sequenceLength;
+		}
+
+		return undefined;
+	}
+
+	skip(offset: number) {
+		this._indexInFirstSequence += offset;
+	}
+}

package/src/skipParser.ts

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

package/src/sliceBoundedParser.test.ts

@@ -0,0 +1,28 @@
+import test from 'ava';
+import { createArrayParser } from './arrayParser.js';
+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';
+
+const anythingParser = createArrayParser(createElementParser<string>());
+
+test('sliceBoundedParser', async t => {
+	const parser = createTupleParser([
+		createElementParser<string>(),
+		createSliceBoundedParser(anythingParser, 2),
+		createElementParser(),
+	]);
+
+	const result = await runParser(parser, 'abba', stringInputCompanion);
+
+	t.deepEqual(result, [
+		'a',
+		[
+			'b',
+			'b',
+		],
+		'a',
+	]);
+});

package/src/sliceBoundedParser.ts

@@ -0,0 +1,30 @@
+import { getParserName, Parser, setParserName } from "./parser.js";
+
+export const createSliceBoundedParser = <Output, Sequence>(
+	childParser: Parser<Output, Sequence>,
+	sliceEnd: number,
+): Parser<Output, Sequence> => {
+	const sliceBoundedParser: typeof childParser = async parserContext => {
+		const childParserContext = parserContext.lookahead({
+			sliceEnd: parserContext.position + sliceEnd,
+		});
+
+		try {
+			const value = await childParser(childParserContext);
+			childParserContext.unlookahead();
+			return value;
+		} finally {
+			childParserContext.dispose();
+		}
+	};
+
+	setParserName(sliceBoundedParser, [
+		'sliceBounded(',
+		getParserName(childParser, 'anonymousSliceBoundedChild'),
+		',',
+		sliceEnd,
+		')',
+	].join(''));
+
+	return sliceBoundedParser;
+}

package/src/terminatedArrayParser.ts

@@ -0,0 +1,40 @@
+import { getParserName, Parser, setParserName } from "./parser.js";
+import { promiseCompose } from "./promiseCompose.js";
+import { createUnionParser } from "./unionParser.js";
+
+class Terminated<T> {
+	constructor(
+		public readonly value: T,
+	) {}
+}
+
+export const createTerminatedArrayParser = <ElementOutput, TerminatorOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+	terminatorParser: Parser<unknown, Sequence>,
+): Parser<[ElementOutput[], TerminatorOutput], Sequence> => {
+	const wrappedTerminatorParser = promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue));
+
+	setParserName(
+		wrappedTerminatorParser,
+		getParserName(terminatorParser, 'anonymousTerminator'),
+	);
+
+	const elementOrTerminatorParser = createUnionParser<ElementOutput | Terminated<TerminatorOutput>, Sequence>([
+		elementParser,
+		promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue)),
+	]);
+
+	return async parserContext => {
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const elementOrTerminator = await elementOrTerminatorParser(parserContext);
+
+			if (elementOrTerminator instanceof Terminated) {
+				return [ elements, elementOrTerminator.value ];
+			}
+
+			elements.push(elementOrTerminator);
+		}
+	};
+};

package/src/tupleParser.ts

@@ -0,0 +1,33 @@
+import { getParserName, setParserName, type Parser } from './parser.js';
+
+export function createTupleParser<A, B, Sequence>([ parserA, parserB ]: [Parser<A, Sequence>, Parser<B, Sequence>]): Parser<[A, B], Sequence>;
+export function createTupleParser<A, B, C, Sequence>([ parserA, parserB, parserC ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>]): Parser<[A, B, C], Sequence>;
+export function createTupleParser<A, B, C, D, Sequence>([ parserA, parserB, parserC, parserD ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>]): Parser<[A, B, C, D], Sequence>;
+export function createTupleParser<A, B, C, D, E, Sequence>([ parserA, parserB, parserC, parserD, parserE ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>]): Parser<[A, B, C, D, E], Sequence>;
+export function createTupleParser<A, B, C, D, E, F, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>]): Parser<[A, B, C, D, E, F], Sequence>;
+export function createTupleParser<A, B, C, D, E, F, G, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>]): Parser<[A, B, C, D, E, F, G], Sequence>;
+export function createTupleParser<A, B, C, D, E, F, G, H, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>]): Parser<[A, B, C, D, E, F, G, H], Sequence>;
+export function createTupleParser<A, B, C, D, E, F, G, H, I, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I], Sequence>;
+export function createTupleParser<A, B, C, D, E, F, G, H, I, J, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J], Sequence>;
+export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K], Sequence>;
+export function createTupleParser<Sequence>(parsers: Array<Parser<unknown, Sequence>>): Parser<unknown[], Sequence> {
+	const tupleParser: Parser<unknown[], Sequence> = async parserContext => {
+		const values: unknown[] = [];
+
+		for (const parser of parsers) {
+			const value = await parser(parserContext);
+
+			values.push(value);
+		}
+
+		return values;
+	};
+
+	setParserName(tupleParser, [
+		'[',
+		parsers.map(parser => getParserName(parser, 'anonymousTupleChild')).join(','),
+		']',
+	].join(''));
+
+	return tupleParser;
+}

package/src/unionParser.ts

@@ -0,0 +1,104 @@
+import { allSettledStream } from './allSettledStream.js';
+import { getParserName, setParserName, type Parser } from './parser.js';
+import { type ParserContext } from './parserContext.js';
+import { ParserParsingFailedError } from './parserError.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+
+export const createUnionParser = <
+	Output,
+	Sequence,
+>(
+	childParsers: Array<Parser<any, Sequence, any>>,
+): Parser<Output, Sequence, unknown> => {
+	parserImplementationInvariant(childParsers.length > 0, 'Union parser must have at least one child parser.');
+
+	const unionParser: Parser<Output, Sequence, unknown> = async parserContext => {
+		let runningChildParserContexts: Array<ParserContext<unknown, unknown>> = [];
+
+		const childParserResults = allSettledStream(childParsers.map(childParser => {
+			const childParserContext = parserContext.lookahead({
+				debugName: getParserName(childParser, 'anonymousUnionChild'),
+			});
+
+			runningChildParserContexts.push(childParserContext);
+
+			const promise = childParser(childParserContext);
+
+			return {
+				promise,
+				context: childParserContext,
+			};
+		}));
+
+		const parserParsingFailedErrors: ParserParsingFailedError[] = [];
+		const successfulParserOutputs: Output[] = [];
+		const successfulParserContexts: Array<ParserContext<unknown, unknown>> = [];
+		let didUnlookahead = false;
+
+		for await (const childParserResult of childParserResults) {
+			runningChildParserContexts = runningChildParserContexts.filter(
+				runningChildParserContext => runningChildParserContext !== childParserResult.context,
+			);
+
+			if (childParserResult.status === 'fulfilled') {
+				successfulParserOutputs.push(childParserResult.value);
+				successfulParserContexts.push(childParserResult.context);
+			} else {
+				const error = childParserResult.reason;
+
+				if (error instanceof ParserParsingFailedError) {
+					parserParsingFailedErrors.push(error);
+				} else {
+					throw error;
+				}
+			}
+
+			if (
+				runningChildParserContexts.length === 1
+				&& successfulParserOutputs.length === 0
+			) {
+				parserImplementationInvariant(!didUnlookahead, 'Union parser unlookaheaded multiple times.');
+				didUnlookahead = true;
+				const [ runningChildParserContext ] = runningChildParserContexts;
+				runningChildParserContext.unlookahead();
+			}
+		}
+
+		parserImplementationInvariant(
+			successfulParserOutputs.length <= 1,
+			[
+				'Multiple union child parsers succeeded.',
+				'Successful parser outputs, indented, separated by newlines:',
+				'%s',
+				'End of successful parser outputs.',
+			],
+			() => successfulParserOutputs.map(output => '  ' + JSON.stringify(output)).join('\n'),
+		);
+
+		parserContext.invariantJoin(
+			successfulParserOutputs.length === 1,
+			parserParsingFailedErrors,
+			'No union child parser succeeded.',
+		);
+
+		const [ successfulParserContext ] = successfulParserContexts;
+
+		if (!didUnlookahead) {
+			successfulParserContext.unlookahead();
+		}
+
+		successfulParserContext.dispose();
+
+		const [ successfulParserOutput ] = successfulParserOutputs;
+
+		return successfulParserOutput;
+	};
+
+	const name = [
+		'(',
+		...childParsers.map(childParser => getParserName(childParser, 'anonymousUnionChild')).join('|'),
+		')',
+	].join('');
+
+	return setParserName(unionParser, name);
+};

package/src/zip.ts

@@ -0,0 +1,48 @@
+
+export type ZipCompression =
+	| 'store'
+	| 'deflate'
+;
+
+export type ZipUnixPermissions = {
+	type: 'unix';
+	unixPermissions: number;
+};
+
+export type ZipDosPermissions = {
+	type: 'dos';
+	dosPermissions: number;
+};
+
+export type ZipPermissions =
+	| ZipUnixPermissions
+	| ZipDosPermissions
+;
+
+export type ZipFileEntry = {
+	type: 'file';
+	path: string;
+	date: Date;
+	comment: string;
+	permissions: ZipPermissions;
+	compression: ZipCompression;
+	content: Uint8Array;
+};
+
+export type ZipDirectoryEntry = {
+	type: 'directory';
+	path: string;
+	date: Date;
+	comment: string;
+	permissions: ZipPermissions;
+};
+
+export type ZipEntry =
+	| ZipFileEntry
+	| ZipDirectoryEntry
+;
+
+export type Zip = {
+	comment: string;
+	entries: ZipEntry[];
+}

package/src/zipParser.test.ts

@@ -0,0 +1,31 @@
+import { testProp } from '@fast-check/ava';
+import { arbitraryZipStream } from './arbitraryZipStream.js';
+import { zipParser } from './zipParser.js';
+import { uint8ArrayInputCompanion } from './inputCompanion.js';
+import { runParser } from './parser.js';
+
+async function * readableStreamToUint8ArrayAsyncIterator(stream: ReadableStream<Uint8Array>) {
+	for await (const chunk of stream) {
+		yield chunk;
+	}
+}
+
+testProp(
+	'zip',
+	[
+		arbitraryZipStream,
+	],
+	async (t, [ zip, zipStream ]) => {
+		const actual = await runParser(zipParser, readableStreamToUint8ArrayAsyncIterator(zipStream), uint8ArrayInputCompanion, {
+			errorJoinMode: 'all',
+		});
+
+		actual.entries.sort((a, b) => a.path.localeCompare(b.path));
+		zip.entries.sort((a, b) => a.path.localeCompare(b.path));
+
+		t.deepEqual(actual, zip);
+	},
+	{
+		verbose: true,
+	},
+);