@futpib/parser 1.0.3 → 1.0.6

package/build/objectParser.test.js

@@ -0,0 +1,55 @@
+import test from 'ava';
+import { createObjectParser } from './objectParser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+// Type tests are in objectParser.test-d.ts (using tsd)
+test('parses object with parsers only', async (t) => {
+    const parser = createObjectParser({
+        first: createFixedLengthSequenceParser(3),
+        second: createFixedLengthSequenceParser(3),
+    });
+    const output = await runParser(parser, 'foobar', stringParserInputCompanion);
+    t.deepEqual(output, { first: 'foo', second: 'bar' });
+});
+test('parses object with literals', async (t) => {
+    const parser = createObjectParser({
+        type: 'block',
+        value: createFixedLengthSequenceParser(3),
+    });
+    const output = await runParser(parser, 'foo', stringParserInputCompanion);
+    t.deepEqual(output, { type: 'block', value: 'foo' });
+});
+test('excludes underscore-prefixed keys from result but runs parsers', async (t) => {
+    const parser = createObjectParser({
+        first: createFixedLengthSequenceParser(3),
+        _separator: createExactSequenceParser(':'),
+        second: createFixedLengthSequenceParser(3),
+    });
+    const output = await runParser(parser, 'foo:bar', stringParserInputCompanion);
+    t.deepEqual(output, { first: 'foo', second: 'bar' });
+    t.false('_separator' in output);
+});
+test('preserves property order', async (t) => {
+    const parser = createObjectParser({
+        c: createFixedLengthSequenceParser(1),
+        a: createFixedLengthSequenceParser(1),
+        b: createFixedLengthSequenceParser(1),
+    });
+    const output = await runParser(parser, 'xyz', stringParserInputCompanion);
+    t.deepEqual(Object.keys(output), ['c', 'a', 'b']);
+    t.deepEqual(output, { c: 'x', a: 'y', b: 'z' });
+});
+test('mixed parsers and literals with underscore keys', async (t) => {
+    const parser = createObjectParser({
+        type: 'assignment',
+        _open: createExactSequenceParser('('),
+        name: createFixedLengthSequenceParser(1),
+        _eq: createExactSequenceParser('='),
+        value: createFixedLengthSequenceParser(1),
+        _close: createExactSequenceParser(')'),
+    });
+    const output = await runParser(parser, '(x=5)', stringParserInputCompanion);
+    t.deepEqual(output, { type: 'assignment', name: 'x', value: '5' });
+});

package/build/optionalParser.js

@@ -1,21 +1,80 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { getParserName, setParserName } from './parser.js';
 import { isParserParsingFailedError } from './parserError.js';
 export const createOptionalParser = (childParser) => {
     const optionalParser = async (parserContext) => {
-        const childParserContext = parserContext.lookahead();
+        const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            const value = await childParser(childParserContext);
-            childParserContext.unlookahead();
-            return value;
-        }
-        catch (error) {
-            if (isParserParsingFailedError(error)) {
-                return undefined;
+            const childParserContext = __addDisposableResource(env_1, parserContext.lookahead(), false);
+            try {
+                const value = await childParser(childParserContext);
+                childParserContext.unlookahead();
+                return value;
             }
-            throw error;
+            catch (error) {
+                if (isParserParsingFailedError(error)) {
+                    return undefined;
+                }
+                throw error;
+            }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
         }
         finally {
-            childParserContext.dispose();
+            __disposeResources(env_1);
         }
     };
     setParserName(optionalParser, getParserName(childParser, 'anonymousOptionalChild') + '?');

package/build/parser.d.ts

@@ -3,6 +3,8 @@ import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type ParserContext } from './parserContext.js';
 import { type DeriveSequenceElement } from './sequence.js';
 export type Parser<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = (parserContext: ParserContext<Sequence, Element>) => Output | Promise<Output>;
+export type ParserOutput<P> = P extends Parser<infer O, any, any> ? O : never;
+export type ParserSequence<P> = P extends Parser<any, infer S, any> ? S : never;
 export declare function getParserName(parser: Parser<any, any, any>, default_?: string): string;
 export declare function setParserName<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>, name: string): Parser<Output, Sequence, Element>;
 export declare function cloneParser<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>): Parser<Output, Sequence, Element>;
@@ -14,6 +16,8 @@ export type RunParserOptions<Output, Sequence, Element = DeriveSequenceElement<S
 export type RunParserWithRemainingInputResult<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = {
     output: Output;
     position: number;
+    furthestReadPosition: number;
+    furthestPeekedPosition: number;
     remainingInput: undefined | AsyncIterable<Sequence>;
 };
 export declare function runParserWithRemainingInput<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>, input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence, parserInputCompanion: ParserInputCompanion<Sequence, Element>, options?: RunParserOptions<Output, Sequence, Element>): Promise<RunParserWithRemainingInputResult<Output, Sequence, Element>>;

package/build/parser.js

@@ -86,6 +86,8 @@ export async function runParserWithRemainingInput(parser, input, parserInputComp
         return {
             output,
             position: parserContext.position,
+            furthestReadPosition: inputReader.furthestReadPosition,
+            furthestPeekedPosition: inputReader.furthestPeekedPosition,
             remainingInput,
         };
     });
@@ -96,7 +98,7 @@ export async function runParser(parser, input, parserInputCompanion, options = {
         const output = await outputPromise;
         const inputReaderState = inputReader.toInputReaderState();
         if (!inputReaderStateCompanion.isDone(inputReaderState)) {
-            throw new normalParserErrorModule.ParserUnexpectedRemainingInputError('Unexpected remaining input', 0, parserContext.position);
+            throw new normalParserErrorModule.ParserUnexpectedRemainingInputError('Unexpected remaining input', 0, parserContext.position, inputReader.furthestReadPosition, inputReader.furthestPeekedPosition);
         }
         return output;
     });

package/build/parser.test.js

@@ -12,6 +12,8 @@ import { createArrayParser } from './arrayParser.js';
 import { createElementParser } from './elementParser.js';
 import { toAsyncIterable } from './toAsyncIterable.js';
 import { stringFromAsyncIterable } from './stringFromAsyncIterable.js';
+import { createLookaheadParser } from './lookaheadParser.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
 const aUnionParser = createUnionParser([
     createExactSequenceNaiveParser('1'),
     createExactSequenceNaiveParser('aa'),
@@ -228,11 +230,13 @@ test('runParser does not throw without remaining input', async (t) => {
 });
 test('runParserWithRemainingInput with remaining input', async (t) => {
     const parser = createExactSequenceNaiveParser('foo');
-    const { output, remainingInput, position, ...resultRest } = await runParserWithRemainingInput(parser, 'foobar', stringParserInputCompanion);
+    const { output, remainingInput, position, furthestReadPosition, furthestPeekedPosition, ...resultRest } = await runParserWithRemainingInput(parser, 'foobar', stringParserInputCompanion);
     t.deepEqual(resultRest, {});
     t.is(output, 'foo');
     t.is(await stringFromAsyncIterable(remainingInput), 'bar');
     t.is(position, 3);
+    t.is(furthestReadPosition, 3);
+    t.is(furthestPeekedPosition, 3);
 });
 test('runParserWithRemainingInput without remaining input', async (t) => {
     const parser = createExactSequenceNaiveParser('foo');
@@ -240,3 +244,112 @@ test('runParserWithRemainingInput without remaining input', async (t) => {
     t.is(output, 'foo');
     t.is(remainingInput, undefined);
 });
+test('furthestReadPosition equals position when no backtracking', async (t) => {
+    const parser = createExactSequenceNaiveParser('foo');
+    const result = await runParserWithRemainingInput(parser, 'foobar', stringParserInputCompanion);
+    t.is(result.position, 3);
+    t.is(result.furthestReadPosition, 3);
+    t.is(result.furthestPeekedPosition, 3);
+});
+test('furthestReadPosition tracks lookahead that succeeded', async (t) => {
+    // Parser: lookahead('foo') followed by 'foobar'
+    // The lookahead parses 'foo' (position 3) but doesn't consume it
+    // Then 'foobar' is parsed (position 6)
+    const parser = createTupleParser([
+        createLookaheadParser(createExactSequenceNaiveParser('foo')),
+        createExactSequenceNaiveParser('foobar'),
+    ]);
+    const result = await runParserWithRemainingInput(parser, 'foobar', stringParserInputCompanion);
+    t.is(result.position, 6);
+    t.is(result.furthestReadPosition, 6);
+    t.is(result.furthestPeekedPosition, 6);
+});
+test('furthestReadPosition tracks failed lookahead with backtracking', async (t) => {
+    // Parser: try 'foobar' OR 'foo'
+    // First tries 'foobar', reads 'f','o','o','q' (position 4) then fails because 'q' != 'b'
+    // Backtracks and tries 'foo', succeeds at position 3
+    // furthestReadPosition should be 4 (from the failed 'foobar' attempt that read up to 'q')
+    const parser = createDisjunctionParser([
+        createExactSequenceNaiveParser('foobar'),
+        createExactSequenceNaiveParser('foo'),
+    ]);
+    const result = await runParserWithRemainingInput(parser, 'fooqux', stringParserInputCompanion);
+    t.is(result.output, 'foo');
+    t.is(result.position, 3);
+    t.is(result.furthestReadPosition, 4);
+    t.is(result.furthestPeekedPosition, 3);
+});
+test('furthestReadPosition exceeds position after backtracking from longer match', async (t) => {
+    // Parser: try 'foobarqux' OR 'foo'
+    // First tries 'foobarqux', reads up to position 6 ('foobar'), then fails
+    // Backtracks and tries 'foo', succeeds at position 3
+    // furthestReadPosition should be 6 (from the failed 'foobarqux' attempt)
+    const parser = createDisjunctionParser([
+        createExactSequenceNaiveParser('foobarqux'),
+        createExactSequenceNaiveParser('foo'),
+    ]);
+    const result = await runParserWithRemainingInput(parser, 'foobar', stringParserInputCompanion);
+    t.is(result.output, 'foo');
+    t.is(result.position, 3);
+    t.is(result.furthestReadPosition, 6);
+    t.is(result.furthestPeekedPosition, 6);
+});
+test('furthestPeekedPosition differs from furthestReadPosition with lookahead', async (t) => {
+    // Parser: lookahead('foobar') then 'foo'
+    // The lookahead parses 'foobar':
+    // - Each read() calls peek(0) at positions 0,1,2,3,4,5 then skip(1) advancing to 1,2,3,4,5,6
+    // - This updates furthestReadPosition to 6 and furthestPeekedPosition to 5
+    // Then 'foo' is parsed from position 0, position becomes 3
+    // furthestReadPosition=6 (from lookahead's skip calls)
+    // furthestPeekedPosition=5 (from lookahead's peek calls at positions 0-5)
+    const parser = createTupleParser([
+        createLookaheadParser(createExactSequenceNaiveParser('foobar')),
+        createExactSequenceNaiveParser('foo'),
+    ]);
+    const result = await runParserWithRemainingInput(parser, 'foobar', stringParserInputCompanion);
+    t.is(result.output[1], 'foo');
+    t.is(result.position, 3);
+    t.is(result.furthestReadPosition, 6);
+    t.is(result.furthestPeekedPosition, 5);
+});
+test('error has furthestReadPosition after backtracking', async (t) => {
+    // Parser: try 'foobarqux' OR 'foobaz'
+    // Input: 'foobar'
+    // First tries 'foobarqux', reads up to position 6 ('foobar'), then fails (no 'qux')
+    // Then tries 'foobaz', reads up to position 4 ('foob'), then fails ('b' != 'z')
+    // Both fail, error at position 0, but furthestReadPosition should be 6
+    const parser = createDisjunctionParser([
+        createExactSequenceNaiveParser('foobarqux'),
+        createExactSequenceNaiveParser('foobaz'),
+    ]);
+    const error = await t.throwsAsync(runParser(parser, 'foobar', stringParserInputCompanion, { errorStack: true }));
+    t.is(error.position, 0);
+    t.is(error.furthestReadPosition, 6);
+    t.is(error.furthestPeekedPosition, 6);
+});
+test('error from negative lookahead has furthestReadPosition from lookahead content', async (t) => {
+    // Parser: negativeLookahead('foobar') then 'foo'
+    // Input: 'foobar'
+    // Negative lookahead tries 'foobar', succeeds (reads to position 6)
+    // Since lookahead succeeded, negative lookahead fails
+    // Error position is 0 (where negative lookahead started), but furthestReadPosition is 6
+    const parser = createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceNaiveParser('foobar')),
+        createExactSequenceNaiveParser('foo'),
+    ]);
+    const error = await t.throwsAsync(runParser(parser, 'foobar', stringParserInputCompanion, { errorStack: true }), {
+        name: 'ParserParsingInvariantError',
+    });
+    t.is(error.position, 0);
+    t.is(error.furthestReadPosition, 6);
+    t.is(error.furthestPeekedPosition, 5);
+});
+test('furthestReadPosition on ParserUnexpectedRemainingInputError', async (t) => {
+    const parser = createExactSequenceNaiveParser('foo');
+    const error = await t.throwsAsync(runParser(parser, 'foobar', stringParserInputCompanion), {
+        name: 'ParserUnexpectedRemainingInputError',
+    });
+    t.is(error.position, 3);
+    t.is(error.furthestReadPosition, 3);
+    t.is(error.furthestPeekedPosition, 3);
+});

package/build/parserConsumedSequenceParser.js

@@ -1,17 +1,76 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
 import { getParserName, setParserName } from './parser.js';
 export const createParserConsumedSequenceParser = (childParser) => {
     const parserConsumedSequenceParser = async (parserContext) => {
         const initialPosition = parserContext.position;
-        const childParserContext = parserContext.lookahead();
         let value;
         let consumedLength;
-        try {
-            value = await childParser(childParserContext);
-            consumedLength = childParserContext.position - initialPosition;
-        }
-        finally {
-            childParserContext.dispose();
+        {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const childParserContext = __addDisposableResource(env_1, parserContext.lookahead(), false);
+                value = await childParser(childParserContext);
+                consumedLength = childParserContext.position - initialPosition;
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
         }
         const consumedSequenceParser = createFixedLengthSequenceParser(consumedLength);
         const consumedSequence = await consumedSequenceParser(parserContext);

package/build/parserContext.d.ts

@@ -20,6 +20,8 @@ export type ParserContext<Sequence, Element> = {
     indexOfSubsequence(sequence: Sequence, subsequence: Sequence, fromIndex?: number): number;
     equals(sequenceA: Sequence, sequenceB: Sequence): boolean;
     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;
@@ -28,6 +30,7 @@ export type ParserContext<Sequence, Element> = {
     lookahead(options?: LookaheadOptions): ParserContext<Sequence, Element>;
     unlookahead(): void;
     dispose(): void;
+    [Symbol.dispose](): void;
     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>;
 };
@@ -50,6 +53,8 @@ export declare class ParserContextImplementation<Sequence, Element> implements P
     indexOfSubsequence(sequence: Sequence, subsequence: Sequence, fromIndex?: number): number;
     equals(sequenceA: Sequence, sequenceB: Sequence): boolean;
     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;
@@ -58,6 +63,7 @@ export declare class ParserContextImplementation<Sequence, Element> implements P
     lookahead(options?: LookaheadOptions): ParserContext<Sequence, Element>;
     unlookahead(): void;
     dispose(): void;
+    [Symbol.dispose](): void;
     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>;
 }

package/build/parserContext.js

@@ -57,6 +57,12 @@ export class ParserContextImplementation {
     get position() {
         return this._inputReader.position;
     }
+    get furthestReadPosition() {
+        return this._inputReader.furthestReadPosition;
+    }
+    get furthestPeekedPosition() {
+        return this._inputReader.furthestPeekedPosition;
+    }
     async peek(offset) {
         if (this._options.sliceEnd !== undefined
             && (this.position + offset) >= this._options.sliceEnd) {
@@ -81,7 +87,7 @@ export class ParserContextImplementation {
     async read(offset) {
         const element = await this.peek(offset);
         if (element === undefined) {
-            throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
+            throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position, this._inputReader.furthestReadPosition, this._inputReader.furthestPeekedPosition);
         }
         this.skip(offset + 1);
         return element;
@@ -89,7 +95,7 @@ export class ParserContextImplementation {
     async readSequence(start, end) {
         const sequence = await this.peekSequence(start, end);
         if (sequence === undefined) {
-            throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
+            throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position, this._inputReader.furthestReadPosition, this._inputReader.furthestPeekedPosition);
         }
         this.skip(end);
         return sequence;
@@ -144,10 +150,13 @@ export class ParserContextImplementation {
         parentParserContext._exclusiveChildParserContext = undefined;
         this._parentParserContext = undefined;
     }
+    [Symbol.dispose]() {
+        this.dispose();
+    }
     invariant(value, format, ...formatArguments) {
         const parserContext = this;
         return customInvariant(function (lazyMessage) {
-            return new parserContext._options.errorsModule.ParserParsingInvariantError(lazyMessage, parserContext._depth, parserContext.position);
+            return new parserContext._options.errorsModule.ParserParsingInvariantError(lazyMessage, parserContext._depth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition);
         }, value, format, ...formatArguments);
     }
     invariantJoin(value, childErrors, format, ...formatArguments) {
@@ -156,19 +165,19 @@ export class ParserContextImplementation {
         const parserContext = this;
         if (errorJoinMode === 'none') {
             return customInvariant(function (lazyMessage) {
-                return new parserContext._options.errorsModule.ParserParsingJoinNoneError(lazyMessage, parserContext._depth, parserContext.position);
+                return new parserContext._options.errorsModule.ParserParsingJoinNoneError(lazyMessage, parserContext._depth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'furthest') {
             return customInvariant(function (userLazyMessage) {
-                let furthestPosition = 0;
+                let furthestChildErrorPosition = 0;
                 let furthestChildErrors = [];
                 for (const childError of childErrors) {
-                    if (childError.position < furthestPosition) {
+                    if (childError.position < furthestChildErrorPosition) {
                         continue;
                     }
-                    if (childError.position > furthestPosition) {
-                        furthestPosition = childError.position;
+                    if (childError.position > furthestChildErrorPosition) {
+                        furthestChildErrorPosition = childError.position;
                         furthestChildErrors = [childError];
                         continue;
                     }
@@ -188,7 +197,7 @@ export class ParserContextImplementation {
                         }
                         return furthestChildError.stack?.split('\n').map(line => '  ' + line);
                     }).join('\n'),
-                ], parserContext._depth, furthestPosition, furthestChildErrors);
+                ], parserContext._depth, furthestChildErrorPosition, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition, furthestChildErrors);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'deepest') {
@@ -223,7 +232,7 @@ export class ParserContextImplementation {
                         }
                         return deepestChildError.stack?.split('\n').map(line => '  ' + line);
                     }).join('\n'),
-                ], deepestDepth, parserContext.position, deepestChildErrors);
+                ], deepestDepth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition, deepestChildErrors);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'all') {
@@ -242,7 +251,7 @@ export class ParserContextImplementation {
                         }
                         return childError.stack?.split('\n').map(line => '  ' + line);
                     }).join('\n'),
-                ], parserContext._depth, parserContext.position, childErrors);
+                ], parserContext._depth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition, childErrors);
             }, value, format, ...formatArguments);
         }
         return parserImplementationInvariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);