@futpib/parser 1.0.4 → 1.0.6

package/build/disjunctionParser.js

@@ -1,29 +1,91 @@
+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';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 import { promiseSettled } from './promiseSettled.js';
-export const createDisjunctionParser = (childParsers) => {
+export function createDisjunctionParser(childParsers) {
     parserImplementationInvariant(childParsers.length > 0, 'Disjunction parser must have at least one child parser.');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const disjunctionParser = async (parserContext) => {
         const parserParsingFailedErrors = [];
         for (const childParser of childParsers) {
-            const childParserContext = parserContext.lookahead({
-                debugName: getParserName(childParser, 'anonymousDisjunctionChild'),
-            });
-            const childParserResult = await promiseSettled(childParser(childParserContext));
-            if (childParserResult.status === 'fulfilled') {
-                const successfulParserOutput = childParserResult.value;
-                childParserContext.unlookahead();
-                childParserContext.dispose();
-                return successfulParserOutput;
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const childParserContext = __addDisposableResource(env_1, parserContext.lookahead({
+                    debugName: getParserName(childParser, 'anonymousDisjunctionChild'),
+                }), false);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const childParserResult = await promiseSettled(childParser(childParserContext));
+                if (childParserResult.status === 'fulfilled') {
+                    const successfulParserOutput = childParserResult.value;
+                    childParserContext.unlookahead();
+                    return successfulParserOutput;
+                }
+                const error = childParserResult.reason;
+                if (isParserParsingFailedError(error)) {
+                    parserParsingFailedErrors.push(error);
+                }
+                else {
+                    throw error;
+                }
             }
-            childParserContext.dispose();
-            const error = childParserResult.reason;
-            if (isParserParsingFailedError(error)) {
-                parserParsingFailedErrors.push(error);
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
             }
-            else {
-                throw error;
+            finally {
+                __disposeResources(env_1);
             }
         }
         return parserContext.invariantJoin(false, parserParsingFailedErrors, 'No disjunction child parser succeeded.');
@@ -34,4 +96,4 @@ export const createDisjunctionParser = (childParsers) => {
         ')',
     ].join('');
     return setParserName(disjunctionParser, name);
-};
+}

package/build/disjunctionParser.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/build/disjunctionParser.test-d.js

@@ -0,0 +1,72 @@
+import { expectAssignable } from 'tsd';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+// Test: basic disjunction of string parsers - output inferred as string
+{
+    const parser = createDisjunctionParser([
+        createExactElementParser('a'),
+        createExactElementParser('b'),
+    ]);
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: disjunction preserves literal types when parsers have explicit literal output types
+{
+    const parserA = async () => 'a';
+    const parserB = async () => 'b';
+    const parser = createDisjunctionParser([parserA, parserB]);
+    // Output should be 'a' | 'b', not string
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: disjunction of parsers with different output types
+{
+    const stringParser = createFixedLengthSequenceParser(3);
+    const numberParser = () => 42;
+    const parser = createDisjunctionParser([
+        stringParser,
+        numberParser,
+    ]);
+    // Output should be string | number
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: nested disjunctions
+{
+    const inner = createDisjunctionParser([
+        createExactElementParser('a'),
+        createExactElementParser('b'),
+    ]);
+    const parser = createDisjunctionParser([
+        inner,
+        createExactElementParser('c'),
+    ]);
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: sequence type inferred from child parsers
+{
+    const parser = createDisjunctionParser([
+        createExactSequenceParser('hello'),
+        createExactSequenceParser('world'),
+    ]);
+    // Parser should be for string sequences, output is string (widened from literals)
+    expectAssignable(null);
+}
+// Test: single parser in disjunction
+{
+    const parser = createDisjunctionParser([
+        createExactSequenceParser('only'),
+    ]);
+    // Output is string (widened from literal 'only')
+    expectAssignable(null);
+}
+// Test: disjunction of object-producing parsers
+{
+    const parser1 = async () => ({ type: 'a', value: 1 });
+    const parser2 = async () => ({ type: 'b', name: 'test' });
+    const parser = createDisjunctionParser([parser1, parser2]);
+    expectAssignable(null);
+}

package/build/elementSwitchParser.d.ts

@@ -0,0 +1,4 @@
+import { Parser, ParserOutput, ParserSequence } from "./parser.js";
+type ElementSwitchOutput<ChildParser extends Parser<any, any, any>, DefaultParser extends Parser<any, any, any> | undefined> = ParserOutput<ChildParser> | (DefaultParser extends undefined ? never : ParserOutput<NonNullable<DefaultParser>>);
+export declare function createElementSwitchParser<Element, ChildParser extends Parser<any, any, Element>, DefaultParser extends Parser<any, any, Element> | undefined = undefined>(childParsers: Map<Element, ChildParser>, defaultParser?: DefaultParser): Parser<ElementSwitchOutput<ChildParser, DefaultParser>, ParserSequence<ChildParser>, Element>;
+export {};

package/build/{exactElementSwitchParser.js → elementSwitchParser.js}

@@ -1,7 +1,7 @@
 import invariant from "invariant";
 import { getParserName, setParserName } from "./parser.js";
 import { parserImplementationInvariant } from "./parserImplementationInvariant.js";
-export const createElementSwitchParser = (childParsers, defaultParser) => {
+export function createElementSwitchParser(childParsers, defaultParser) {
     parserImplementationInvariant(childParsers.size > 0, 'Element switch parser must have at least one child parser.');
     const elementSwitchParser = async (parserContext) => {
         const currentElement = await parserContext.peek(0);
@@ -9,8 +9,7 @@ export const createElementSwitchParser = (childParsers, defaultParser) => {
         invariant(currentElement !== undefined, 'Unexpected end of input.');
         const childParser = childParsers.get(currentElement) ?? defaultParser;
         parserContext.invariant(childParser, `No child parser found for element: ${String(currentElement)}`);
-        const childParserOutput = await childParser(parserContext);
-        return childParserOutput;
+        return childParser(parserContext);
     };
     const name = [
         'elementSwitch(',
@@ -19,4 +18,4 @@ export const createElementSwitchParser = (childParsers, defaultParser) => {
         ')',
     ].join('');
     return setParserName(elementSwitchParser, name);
-};
+}

package/build/elementSwitchParser.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/build/elementSwitchParser.test-d.js

@@ -0,0 +1,44 @@
+import { expectAssignable, expectType } from 'tsd';
+import { createElementSwitchParser } from './elementSwitchParser.js';
+// Test: basic element switch with inferred output type
+{
+    const parserA = async () => 'a';
+    const parserB = async () => 'b';
+    const parser = createElementSwitchParser(new Map([
+        ['x', parserA],
+        ['y', parserB],
+    ]));
+    // Output should be 'a' | 'b'
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: element switch with default parser
+{
+    const parserA = async () => 'a';
+    const defaultParser = async () => 'default';
+    const parser = createElementSwitchParser(new Map([
+        ['x', parserA],
+    ]), defaultParser);
+    // Output should be 'a' | 'default'
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: element switch with number keys (Uint8Array sequence)
+{
+    const parser1 = async () => ({ type: 'one' });
+    const parser2 = async () => ({ type: 'two' });
+    const parser = createElementSwitchParser(new Map([
+        [1, parser1],
+        [2, parser2],
+    ]));
+    expectAssignable(null);
+}
+// Test: element switch without default parser has no 'never' in output
+{
+    const parserA = async () => 'result';
+    const parser = createElementSwitchParser(new Map([
+        ['key', parserA],
+    ]));
+    // Output should just be string, not string | never
+    expectType(null);
+}

package/build/exactSequenceParser.d.ts

@@ -1,3 +1,5 @@
 import { type Parser } from './parser.js';
-export declare const createExactSequenceNaiveParser: <Sequence>(sequence: Sequence) => Parser<Sequence, Sequence, unknown>;
-export declare const createExactSequenceParser: <Sequence>(expectedSequence: Sequence) => Parser<Sequence, Sequence, unknown>;
+type DeriveBaseSequence<T> = T extends string ? string : T extends Uint8Array ? Uint8Array : T;
+export declare const createExactSequenceNaiveParser: <const Output>(sequence: Output) => Parser<Output, DeriveBaseSequence<Output>, unknown>;
+export declare const createExactSequenceParser: <const Output>(expectedSequence: Output) => Parser<Output, DeriveBaseSequence<Output>, unknown>;
+export {};

package/build/exactSequenceParser.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/build/exactSequenceParser.test-d.js

@@ -0,0 +1,36 @@
+import { expectType, expectAssignable } from 'tsd';
+import { createExactSequenceParser, createExactSequenceNaiveParser } from './exactSequenceParser.js';
+// Test: string literal output type is preserved, sequence type is string
+{
+    const parser = createExactSequenceParser('foo');
+    expectType(parser);
+}
+// Test: string literal with 'as const' also works
+{
+    const parser = createExactSequenceParser('bar');
+    expectType(parser);
+}
+// Test: plain string variable widens to string
+{
+    const value = 'baz';
+    const parser = createExactSequenceParser(value);
+    expectType(parser);
+}
+// Test: Uint8Array sequence type is preserved
+{
+    const bytes = new Uint8Array([1, 2, 3]);
+    const parser = createExactSequenceParser(bytes);
+    // Output is the specific Uint8Array instance type, Sequence is Uint8Array
+    expectAssignable(parser);
+}
+// Test: naive parser has same type behavior
+{
+    const parser = createExactSequenceNaiveParser('hello');
+    expectType(parser);
+}
+// Test: naive parser with Uint8Array
+{
+    const bytes = new Uint8Array([0xff]);
+    const parser = createExactSequenceNaiveParser(bytes);
+    expectAssignable(parser);
+}

package/build/fetchCid.js

@@ -1,8 +1,5 @@
 import fsPromises from 'node:fs/promises';
-import path from 'node:path';
-import pMemoize from 'p-memoize';
-import envPaths from 'env-paths';
-const paths = envPaths('parser.futpib.github.io');
+import { fetchCid as fetchCidFromIpfs } from '@futpib/fetch-cid';
 function readableWebStreamOnFinish(readableWebStream, onFinish) {
     const reader = readableWebStream.getReader();
     const stream = new ReadableStream({
@@ -29,65 +26,6 @@ function readableWebStreamOnFinish(readableWebStream, onFinish) {
     });
     return stream;
 }
-class FsCache {
-    get _basePath() {
-        return path.join(paths.cache, 'fetchCid');
-    }
-    _getKeyPath(key) {
-        return path.join(this._basePath, key.replaceAll('/', '_'));
-    }
-    async get(key) {
-        try {
-            const file = await fsPromises.open(this._getKeyPath(key), 'r');
-            const stream = file.readableWebStream();
-            const streamWithClose = readableWebStreamOnFinish(stream, () => {
-                file.close();
-            });
-            return [streamWithClose, undefined];
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                return undefined;
-            }
-            throw error;
-        }
-    }
-    async has(key) {
-        const streams = await this.get(key);
-        try {
-            return streams !== undefined;
-        }
-        finally {
-            for (const stream of streams ?? []) {
-                await stream?.cancel();
-            }
-        }
-    }
-    async set(key, [_, value]) {
-        await fsPromises.mkdir(this._basePath, {
-            recursive: true,
-        });
-        const file = await fsPromises.open(this._getKeyPath(key), 'w');
-        try {
-            for await (const chunk of value) {
-                await file.write(chunk);
-            }
-        }
-        finally {
-            await file.close();
-        }
-    }
-    async delete(key) {
-        await fsPromises.unlink(this._getKeyPath(key));
-    }
-}
-async function reallyFetchCid(cid) {
-    const response = await fetch('https://ipfs.io/ipfs/' + cid);
-    return response.body.tee();
-}
-const cachedReallyFetchCid = pMemoize(reallyFetchCid, {
-    cache: new FsCache(),
-});
 export async function fetchCid(cidOrPath) {
     if (cidOrPath.includes('/')) {
         const file = await fsPromises.open(cidOrPath, 'r');
@@ -97,7 +35,5 @@ export async function fetchCid(cidOrPath) {
         });
         return streamWithClose;
     }
-    const [readable, unused] = await cachedReallyFetchCid(cidOrPath);
-    await unused?.cancel();
-    return readable;
+    return fetchCidFromIpfs(cidOrPath);
 }

package/build/index.d.ts

@@ -1,4 +1,4 @@
-export { type Parser, runParser, runParserWithRemainingInput, setParserName, getParserName, cloneParser, type RunParserOptions, type RunParserWithRemainingInputResult, } from './parser.js';
+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';
@@ -7,6 +7,7 @@ export { parserCreatorCompose, parserCreatorComposeMem, } from './parserCreatorC
 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';
 export { createFixedLengthSequenceParser, } from './fixedLengthSequenceParser.js';
 export { createArrayParser, } from './arrayParser.js';
@@ -34,7 +35,7 @@ export { createSequenceTerminatedSequenceParser, } from './sequenceTerminatedSeq
 export { createQuantifierParser, } from './quantifierParser.js';
 export { createSkipToParser, } from './skipToParser.js';
 export { createDebugLogInputParser, } from './debugLogInputParser.js';
-export { createElementSwitchParser, } from './exactElementSwitchParser.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';

package/build/index.js

@@ -5,6 +5,7 @@ export { isParserError, isParserParsingFailedError, isParserParsingJoinError, no
 export { parserCreatorCompose, parserCreatorComposeMem, } from './parserCreatorCompose.js';
 export { promiseCompose, } from './promiseCompose.js';
 export { createTupleParser, } from './tupleParser.js';
+export { createObjectParser, } from './objectParser.js';
 export { createExactSequenceParser, } from './exactSequenceParser.js';
 export { createFixedLengthSequenceParser, } from './fixedLengthSequenceParser.js';
 export { createArrayParser, } from './arrayParser.js';
@@ -32,7 +33,7 @@ export { createSequenceTerminatedSequenceParser, } from './sequenceTerminatedSeq
 export { createQuantifierParser, } from './quantifierParser.js';
 export { createSkipToParser, } from './skipToParser.js';
 export { createDebugLogInputParser, } from './debugLogInputParser.js';
-export { createElementSwitchParser, } from './exactElementSwitchParser.js';
+export { createElementSwitchParser, } from './elementSwitchParser.js';
 export { createParserConsumedSequenceParser, } from './parserConsumedSequenceParser.js';
 export { runUnparser, } from './unparser.js';
 export { WriteLater, WriteEarlier, UnparserContextImplementation, } from './unparserContext.js';

package/build/index.test.js

@@ -1,2 +1,17 @@
 import test from 'ava';
-test.todo('TODO');
+import { runParser, createExactSequenceParser, createTupleParser, stringParserInputCompanion, } from './index.js';
+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/build/inputReader.d.ts

@@ -2,9 +2,13 @@ import { type ParserInputCompanion } from './parserInputCompanion.js';
 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>;
 };
@@ -13,6 +17,8 @@ export declare class InputReaderImplementation<Sequence, Element> implements Inp
     private readonly _inputAsyncIterator;
     private readonly _id;
     private _position;
+    private _furthestReadPosition;
+    private _furthestPeekedPosition;
     private _uncommitedSkipOffset;
     private _inputAsyncIteratorDone;
     private readonly _promiseMutex;
@@ -20,6 +26,10 @@ export declare class InputReaderImplementation<Sequence, Element> implements Inp
     constructor(_parserInputCompanion: ParserInputCompanion<Sequence, Element>, _inputAsyncIterator: AsyncIterator<Sequence>);
     get [Symbol.toStringTag](): string;
     get position(): number;
+    get furthestReadPosition(): number;
+    get furthestPeekedPosition(): number;
+    updateFurthestReadPosition(position: number): void;
+    updateFurthestPeekedPosition(position: number): void;
     peek(offset: number): Promise<Element | undefined>;
     peekSequence(start: number, end: number): Promise<Sequence | undefined>;
     skip(offset: number): void;

package/build/inputReader.js

@@ -8,6 +8,8 @@ export class InputReaderImplementation {
     _inputAsyncIterator;
     _id = inputReaderId++;
     _position = 0;
+    _furthestReadPosition = 0;
+    _furthestPeekedPosition = 0;
     _uncommitedSkipOffset = 0;
     _inputAsyncIteratorDone = false;
     _promiseMutex = new PromiseMutex();
@@ -27,8 +29,21 @@ export class InputReaderImplementation {
     get position() {
         return this._position;
     }
+    get furthestReadPosition() {
+        return this._furthestReadPosition;
+    }
+    get furthestPeekedPosition() {
+        return this._furthestPeekedPosition;
+    }
+    updateFurthestReadPosition(position) {
+        this._furthestReadPosition = Math.max(this._furthestReadPosition, position);
+    }
+    updateFurthestPeekedPosition(position) {
+        this._furthestPeekedPosition = Math.max(this._furthestPeekedPosition, position);
+    }
     async peek(offset) {
         parserImplementationInvariant(offset >= 0, 'offset >= 0');
+        this.updateFurthestPeekedPosition(this._position + offset);
         offset += this._uncommitedSkipOffset;
         const element = this._sequenceBuffer.peek(offset);
         if (element !== undefined) {
@@ -59,6 +74,9 @@ export class InputReaderImplementation {
         parserImplementationInvariant(end >= start, 'end (%s) >= start (%s)', start, end);
         parserImplementationInvariant(Number.isSafeInteger(start), 'start (%s) is not a safe integer', start);
         parserImplementationInvariant(Number.isSafeInteger(end), 'end (%s) is not a safe integer', end);
+        if (end > start) {
+            this.updateFurthestPeekedPosition(this._position + end - 1);
+        }
         start += this._uncommitedSkipOffset;
         end += this._uncommitedSkipOffset;
         const sequence = this._sequenceBuffer.peekSequence(start, end);
@@ -74,6 +92,7 @@ export class InputReaderImplementation {
     skip(offset) {
         parserImplementationInvariant(offset >= 0, 'offset >= 0');
         this._position += offset;
+        this.updateFurthestReadPosition(this._position);
         if (this._promiseMutex.isLocked) {
             this._uncommitedSkipOffset += offset;
         }
@@ -113,21 +132,38 @@ class InputReaderLookaheadImplementation {
     get position() {
         return this._initialInputReaderPosition + this._offset;
     }
+    get furthestReadPosition() {
+        return this._inputReader.furthestReadPosition;
+    }
+    get furthestPeekedPosition() {
+        return this._inputReader.furthestPeekedPosition;
+    }
+    updateFurthestReadPosition(position) {
+        this._inputReader.updateFurthestReadPosition(position);
+    }
+    updateFurthestPeekedPosition(position) {
+        this._inputReader.updateFurthestPeekedPosition(position);
+    }
     async peek(offset) {
         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);
     }
     async peekSequence(start, end) {
         const inputReaderMovedForward = this._inputReader.position - this._initialInputReaderPosition;
         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);
     }
     skip(offset) {
         parserImplementationInvariant(offset >= 0, 'offset >= 0');
         this._offset += offset;
+        this.updateFurthestReadPosition(this.position);
     }
     lookahead() {
         const lookahead = new InputReaderLookaheadImplementation(this._inputReader);