@futpib/parser 1.0.1 → 1.0.3

package/src/parserContext.ts

@@ -1,13 +1,16 @@
 /* eslint-disable prefer-arrow-callback */
 
-import invariant from 'invariant';
 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,25 +20,35 @@ type LookaheadOptions = {
 type ParserContextOptions<Sequence, Element> =
 	& RunParserOptions<unknown, Sequence, Element>
 	& LookaheadOptions
+	& {
+		errorsModule: typeof normalParserErrorModule | typeof noStackCaptureOverheadParserErrorModule;
+	}
 ;
 
 export type ParserContext<Sequence, Element> = {
 	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;
 
 	get position(): number;
 	peek(offset: number): Promise<Element | undefined>;
+	peekSequence(start: number, end: number): Promise<Sequence | undefined>;
 	skip(offset: number): void;
 
 	read(offset: number): Promise<Element>;
+	readSequence(start: number, end: number): Promise<Sequence>;
 
 	lookahead(options?: LookaheadOptions): 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;
@@ -72,6 +85,10 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return this._parserInputCompanion.from(elements);
 	}
 
+	concat(sequences: Sequence[]): Sequence {
+		return this._parserInputCompanion.concat(sequences);
+	}
+
 	length(sequence: Sequence): number {
 		return this._parserInputCompanion.length(sequence);
 	}
@@ -80,6 +97,22 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return this._parserInputCompanion.at(sequence, index);
 	}
 
+	subsequence(sequence: Sequence, start: number, end: number): Sequence {
+		return this._parserInputCompanion.subsequence(sequence, start, end);
+	}
+
+	indexOf(sequence: Sequence, element: Element, fromIndex?: number): number {
+		return this._parserInputCompanion.indexOf(sequence, element, fromIndex);
+	}
+
+	indexOfSubsequence(sequence: Sequence, subsequence: Sequence, fromIndex?: number): number {
+		return this._parserInputCompanion.indexOfSubsequence(sequence, subsequence, fromIndex);
+	}
+
+	equals(sequenceA: Sequence, sequenceB: Sequence): boolean {
+		return this._parserInputCompanion.equals(sequenceA, sequenceB);
+	}
+
 	get position() {
 		return this._inputReader.position;
 	}
@@ -87,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;
 		}
@@ -95,6 +128,39 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return this._inputReader.peek(offset);
 	}
 
+	async peekSequence(start: number, end: number): Promise<Sequence | undefined> {
+		if (
+			this._options.sliceEnd !== undefined
+			&& (this.position + end - 1) >= this._options.sliceEnd
+		) {
+			return undefined;
+		}
+
+		parserImplementationInvariant(
+			start >= 0,
+			'start (%s) >= 0',
+			start,
+		);
+		parserImplementationInvariant(
+			end >= start,
+			'end (%s) >= start (%s)',
+			start,
+			end,
+		);
+		parserImplementationInvariant(
+			Number.isSafeInteger(start),
+			'start (%d) is not a safe integer',
+			start,
+		);
+		parserImplementationInvariant(
+			Number.isSafeInteger(end),
+			'end (%d) is not a safe integer',
+			end,
+		);
+
+		return this._inputReader.peekSequence(start, end);
+	}
+
 	skip(offset: number) {
 		this._inputReader.skip(offset);
 	}
@@ -103,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);
@@ -111,21 +177,31 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return element;
 	}
 
-	lookahead(options: LookaheadOptions = {}): ParserContext<Sequence, Element> {
-		const lookaheadInputReader = this._inputReader.lookahead();
+	async readSequence(start: number, end: number): Promise<Sequence> {
+		const sequence = await this.peekSequence(start, end);
 
-		if (this.position !== lookaheadInputReader.position) {
-			debugger;
+		if (sequence === undefined) {
+			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
 		}
 
-		invariant(
+		this.skip(end);
+
+		return sequence;
+	}
+
+	lookahead(options: LookaheadOptions = {}): ParserContext<Sequence, Element> {
+		const lookaheadInputReader = this._inputReader.lookahead();
+
+		parserImplementationInvariant(
 			this.position === lookaheadInputReader.position,
 			'lookahead this.position (%s) === lookaheadInputReader.position (%s)',
 			this.position,
 			lookaheadInputReader.position,
 		);
 
-		const lookaheadParserContext = new ParserContextImplementation(
+		const ParserContext = this._options.parserContextClass ?? ParserContextImplementation;
+
+		const lookaheadParserContext = new ParserContext<Sequence, Element>(
 			this._parserInputCompanion,
 			lookaheadInputReader,
 			this,
@@ -143,11 +219,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 			},
 		);
 
-		if (this.position !== lookaheadParserContext.position) {
-			debugger;
-		}
-
-		invariant(
+		parserImplementationInvariant(
 			this.position === lookaheadParserContext.position,
 			'lookahead this.position (%s) === lookaheadParserContext.position (%s)',
 			this.position,
@@ -158,42 +230,45 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	}
 
 	unlookahead() {
-		invariant(this._parentParserContext !== undefined, 'this._parentParserContext !== undefined');
-		invariant(
+		const parentParserContext = parserImplementationInvariant(
+			this._parentParserContext,
+			'this._parentParserContext !== undefined',
+		);
+		parserImplementationInvariant(
 			(
-				this._parentParserContext._exclusiveChildParserContext === undefined
-				|| this._parentParserContext._exclusiveChildParserContext === this
+				parentParserContext._exclusiveChildParserContext === undefined
+				|| parentParserContext._exclusiveChildParserContext === this
 			),
 			[
 				'Parent\'s exclusive child must be undefined or this',
 				'this: %s',
 				'parent: %s',
 				'parent.exclusiveChild: %s',
-			].join('\n'),
-			this.toString(),
-			this._parentParserContext.toString(),
-			this._parentParserContext._exclusiveChildParserContext?.toString(),
+			],
+			() => this.toString(),
+			() => parentParserContext.toString(),
+			() => parentParserContext._exclusiveChildParserContext?.toString(),
 		);
-		invariant(
-			this._parentParserContext.position <= this.position,
+		parserImplementationInvariant(
+			parentParserContext.position <= this.position,
 			'unlookahead this._parentParserContext.position (%s) <= this.position (%s)',
-			this._parentParserContext.position,
+			parentParserContext.position,
 			this.position,
 		);
 
-		const offset = this._inputReader.position - this._parentParserContext._inputReader.position;
+		const offset = this._inputReader.position - parentParserContext._inputReader.position;
 
-		this._parentParserContext.skip(offset);
+		parentParserContext.skip(offset);
 
-		invariant(
-			this._parentParserContext.position === this.position,
+		parserImplementationInvariant(
+			parentParserContext.position === this.position,
 			'unlookahead this._parentParserContext.position (%s) === this.position (%s)',
-			this._parentParserContext.position,
+			parentParserContext.position,
 			this.position,
 		);
 
-		this._inputReader = this._parentParserContext._inputReader;
-		this._parentParserContext._exclusiveChildParserContext = this;
+		this._inputReader = parentParserContext._inputReader;
+		parentParserContext._exclusiveChildParserContext = this;
 
 		if (this._exclusiveChildParserContext) {
 			this._exclusiveChildParserContext.unlookahead();
@@ -201,49 +276,52 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	}
 
 	dispose() {
-		invariant(this._parentParserContext !== undefined, 'this._parentParserContext !== undefined');
-		invariant(
+		const parentParserContext = parserImplementationInvariant(
+			this._parentParserContext,
+			'this._parentParserContext !== undefined',
+		);
+		parserImplementationInvariant(
 			(
-				this._parentParserContext._exclusiveChildParserContext === undefined
-				|| this._parentParserContext._exclusiveChildParserContext === this
+				parentParserContext._exclusiveChildParserContext === undefined
+				|| parentParserContext._exclusiveChildParserContext === this
 			),
 			[
 				'Parent\'s exclusive child must be undefined or this',
 				'this: %s',
 				'parent: %s',
 				'parent.exclusiveChild: %s',
-			].join('\n'),
-			this.toString(),
-			this._parentParserContext.toString(),
-			this._parentParserContext._exclusiveChildParserContext?.toString(),
+			],
+			() => this.toString(),
+			() => parentParserContext.toString(),
+			() => parentParserContext._exclusiveChildParserContext?.toString(),
 		);
 
-		this._parentParserContext._exclusiveChildParserContext = undefined;
+		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> {
-		invariant(childErrors.length > 0, 'childErrors.length > 0');
+	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[] = [];
 
@@ -261,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;
 					}
@@ -291,30 +381,46 @@ 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);
 		}
 
-		invariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);
+		return parserImplementationInvariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);
 	}
 }

package/src/parserCreatorCompose.ts

@@ -1,3 +1,4 @@
+import mem from 'mem';
 import { type Parser } from './parser.js';
 import { type DeriveSequenceElement } from './sequence.js';
 
@@ -11,13 +12,30 @@ export function parserCreatorCompose<
 	f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>,
 	f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>,
 ): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element> {
-	return (...arguments_) => {
+	const parserCreatorComposedOuter: (...arguments_: Arguments) => Parser<OutputB, Sequence, Element> = (...arguments_) => {
 		const parserA = f1(...arguments_);
 
-		return async parserContext => {
+		const parserCreatorComposedInner: Parser<OutputB, Sequence, Element> = async parserContext => {
 			const outputA = await parserA(parserContext);
 			const parserB = f2(outputA);
 			return parserB(parserContext);
 		};
+
+		return parserCreatorComposedInner;
 	};
+
+	return parserCreatorComposedOuter;
+}
+
+export function parserCreatorComposeMem<
+	Arguments extends unknown[],
+	OutputA,
+	OutputB,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>,
+	f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>,
+): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element> {
+	return parserCreatorCompose(mem(f1), mem(f2));
 }