@futpib/parser 1.0.3 → 1.0.6

package/src/index.test.ts

@@ -1,3 +1,24 @@
 import test from 'ava';
+import {
+	runParser,
+	createExactSequenceParser,
+	createTupleParser,
+	stringParserInputCompanion,
+} from './index.js';
 
-test.todo('TODO');
+test('exports main parser functions', async t => {
+	// Test that runParser is exported and works
+	const parser = createExactSequenceParser('hello');
+	const result = await runParser(parser, 'hello', stringParserInputCompanion);
+	t.is(result, 'hello');
+});
+
+test('exports parser combinators', async t => {
+	// Test that createTupleParser is exported and works
+	const tupleParser = createTupleParser([
+		createExactSequenceParser('a'),
+		createExactSequenceParser('b'),
+	]);
+	const result = await runParser(tupleParser, 'ab', stringParserInputCompanion);
+	t.deepEqual(result, [ 'a', 'b' ]);
+});

package/src/index.ts

@@ -1,20 +1,69 @@
-
 export {
 	type Parser,
+	type ParserOutput,
+	type ParserSequence,
 	runParser,
-
+	runParserWithRemainingInput,
 	setParserName,
 	getParserName,
+	cloneParser,
+	type RunParserOptions,
+	type RunParserWithRemainingInputResult,
 } from './parser.js';
 
 export type {
 	ParserContext,
 } from './parserContext.js';
 
+export {
+	type ParserInputCompanion,
+	StringParserInputCompanion,
+	stringParserInputCompanion,
+	Uint8ArrayParserInputCompanion,
+	uint8ArrayParserInputCompanion,
+} from './parserInputCompanion.js';
+
+export {
+	type UnparserOutputCompanion,
+	StringUnparserOutputCompanion,
+	stringUnparserOutputCompanion,
+	Uint8ArrayUnparserOutputCompanion,
+	uint8ArrayUnparserOutputCompanion,
+} from './unparserOutputCompanion.js';
+
+export {
+	type ParserError,
+	type ParserParsingFailedError,
+	type ParserParsingJoinError,
+	type ParserErrorModule,
+	isParserError,
+	isParserParsingFailedError,
+	isParserParsingJoinError,
+	normalParserErrorModule,
+	noStackCaptureOverheadParserErrorModule,
+} from './parserError.js';
+
+export {
+	parserCreatorCompose,
+	parserCreatorComposeMem,
+} from './parserCreatorCompose.js';
+
+export {
+	promiseCompose,
+} from './promiseCompose.js';
+
+export type {
+	DeriveSequenceElement,
+} from './sequence.js';
+
 export {
 	createTupleParser,
 } from './tupleParser.js';
 
+export {
+	createObjectParser,
+} from './objectParser.js';
+
 export {
 	createExactSequenceParser,
 } from './exactSequenceParser.js';
@@ -75,11 +124,75 @@ export {
 	createDebugLogParser,
 } from './debugLogParser.js';
 
+export {
+	createNonEmptyArrayParser,
+} from './nonEmptyArrayParser.js';
+
+export {
+	createSeparatedArrayParser,
+} from './separatedArrayParser.js';
+
+export {
+	createSeparatedNonEmptyArrayParser,
+} from './separatedNonEmptyArrayParser.js';
+
+export {
+	createLookaheadParser,
+} from './lookaheadParser.js';
+
+export {
+	createNegativeLookaheadParser,
+} from './negativeLookaheadParser.js';
+
+export {
+	createElementTerminatedSequenceParser,
+} from './elementTerminatedSequenceParser.js';
+
+export {
+	createElementTerminatedSequenceArrayParser,
+} from './elementTerminatedSequenceArrayParser.js';
+
+export {
+	createElementTerminatedArrayParserUnsafe,
+} from './elementTerminatedArrayParser.js';
+
+export {
+	createSequenceTerminatedSequenceParser,
+} from './sequenceTerminatedSequenceParser.js';
+
+export {
+	createQuantifierParser,
+} from './quantifierParser.js';
+
+export {
+	createSkipToParser,
+} from './skipToParser.js';
+
+export {
+	createDebugLogInputParser,
+} from './debugLogInputParser.js';
+
+export {
+	createElementSwitchParser,
+} from './elementSwitchParser.js';
+
+export {
+	createParserConsumedSequenceParser,
+} from './parserConsumedSequenceParser.js';
+
 export {
 	type Unparser,
+	type UnparserResult,
 	runUnparser,
 } from './unparser.js';
 
+export {
+	type UnparserContext,
+	WriteLater,
+	WriteEarlier,
+	UnparserContextImplementation,
+} from './unparserContext.js';
+
 export {
 	createArrayUnparser,
 } from './arrayUnparser.js';
@@ -87,3 +200,7 @@ export {
 export {
 	createSequenceUnparser,
 } from './sequenceUnparser.js';
+
+export {
+	createRegExpParser,
+} from './regexpParser.js';

package/src/inputReader.ts

@@ -7,11 +7,16 @@ import { type InputReaderState } from './inputReaderState.js';
 
 export type InputReader<Sequence, Element> = {
 	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;
 
+	updateFurthestReadPosition(position: number): void;
+	updateFurthestPeekedPosition(position: number): void;
+
 	lookahead(): InputReader<Sequence, Element>;
 
 	toInputReaderState(): InputReaderState<Sequence>;
@@ -23,6 +28,8 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 	private readonly _id = inputReaderId++;
 
 	private _position = 0;
+	private _furthestReadPosition = 0;
+	private _furthestPeekedPosition = 0;
 	private _uncommitedSkipOffset = 0;
 	private _inputAsyncIteratorDone = false;
 
@@ -49,9 +56,27 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 		return this._position;
 	}
 
+	get furthestReadPosition() {
+		return this._furthestReadPosition;
+	}
+
+	get furthestPeekedPosition() {
+		return this._furthestPeekedPosition;
+	}
+
+	updateFurthestReadPosition(position: number) {
+		this._furthestReadPosition = Math.max(this._furthestReadPosition, position);
+	}
+
+	updateFurthestPeekedPosition(position: number) {
+		this._furthestPeekedPosition = Math.max(this._furthestPeekedPosition, position);
+	}
+
 	async peek(offset: number): Promise<Element | undefined> {
 		parserImplementationInvariant(offset >= 0, 'offset >= 0');
 
+		this.updateFurthestPeekedPosition(this._position + offset);
+
 		offset += this._uncommitedSkipOffset;
 
 		const element = this._sequenceBuffer.peek(offset);
@@ -115,6 +140,10 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 			end,
 		);
 
+		if (end > start) {
+			this.updateFurthestPeekedPosition(this._position + end - 1);
+		}
+
 		start += this._uncommitedSkipOffset;
 		end += this._uncommitedSkipOffset;
 
@@ -137,6 +166,7 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 		parserImplementationInvariant(offset >= 0, 'offset >= 0');
 
 		this._position += offset;
+		this.updateFurthestReadPosition(this._position);
 
 		if (this._promiseMutex.isLocked) {
 			this._uncommitedSkipOffset += offset;
@@ -185,12 +215,30 @@ class InputReaderLookaheadImplementation<Sequence, Element> implements InputRead
 		return this._initialInputReaderPosition + this._offset;
 	}
 
+	get furthestReadPosition() {
+		return this._inputReader.furthestReadPosition;
+	}
+
+	get furthestPeekedPosition() {
+		return this._inputReader.furthestPeekedPosition;
+	}
+
+	updateFurthestReadPosition(position: number) {
+		this._inputReader.updateFurthestReadPosition(position);
+	}
+
+	updateFurthestPeekedPosition(position: number) {
+		this._inputReader.updateFurthestPeekedPosition(position);
+	}
+
 	async peek(offset: number): Promise<Element | undefined> {
 		const inputReaderMovedForward = this._inputReader.position - this._initialInputReaderPosition;
 
 		this._initialInputReaderPosition = this._inputReader.position;
 		this._offset -= inputReaderMovedForward;
 
+		this.updateFurthestPeekedPosition(this.position + offset);
+
 		return this._inputReader.peek(this._offset + offset);
 	}
 
@@ -200,6 +248,10 @@ class InputReaderLookaheadImplementation<Sequence, Element> implements InputRead
 		this._initialInputReaderPosition = this._inputReader.position;
 		this._offset -= inputReaderMovedForward;
 
+		if (end > start) {
+			this.updateFurthestPeekedPosition(this.position + end - 1);
+		}
+
 		return this._inputReader.peekSequence(this._offset + start, this._offset + end);
 	}
 
@@ -207,6 +259,7 @@ class InputReaderLookaheadImplementation<Sequence, Element> implements InputRead
 		parserImplementationInvariant(offset >= 0, 'offset >= 0');
 
 		this._offset += offset;
+		this.updateFurthestReadPosition(this.position);
 	}
 
 	lookahead(): InputReader<Sequence, Element> {