@futpib/parser 1.0.1 → 1.0.3

package/build/parserError.js

@@ -1,61 +1,106 @@
-export class ParserError extends Error {
-    name = 'ParserError';
+import { NormalLazyMessageError, NoStackCaptureOverheadLazyMessageError } from './lazyMessageError.js';
+export function isParserError(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value instanceof Error
+        && 'position' in value
+        && (typeof value.position === 'number' || value.position === undefined)
+        && 'inputReaderSate' in value
+        && (value.inputReaderSate === undefined || typeof value.inputReaderSate === 'object'));
 }
-export class ParserImplementationError extends ParserError {
-    name = 'ParserImplementationError';
+export function isParserParsingFailedError(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value instanceof Error
+        && 'depth' in value
+        && typeof value.depth === 'number'
+        && 'position' in value
+        && typeof value.position === 'number');
 }
-export class ParserImplementationInvariantError extends ParserImplementationError {
-    name = 'ParserImplementationInvariantError';
+export function isParserParsingJoinError(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value instanceof Error
+        && 'childErrors' in value
+        && Array.isArray(value.childErrors)
+        && value.childErrors.every((childError) => isParserParsingFailedError(childError)));
 }
-export class ParserParsingFailedError extends ParserError {
-    depth;
-    position;
-    name = 'ParserParsingFailedError';
-    constructor(message, depth, position) {
-        super([
-            '(position: ',
-            position,
-            ') ',
-            message,
-        ].join(''));
-        this.depth = depth;
-        this.position = position;
+function createParserErrorModule(BaseLazyMessageError) {
+    class ParserError extends BaseLazyMessageError {
+        name = 'ParserError';
+        position = undefined;
+        inputReaderSate = undefined;
     }
-}
-export class ParserParsingJoinError extends ParserParsingFailedError {
-    name = 'ParserParsingJoinError';
-    childErrors = [];
-}
-export class ParserParsingJoinNoneError extends ParserParsingJoinError {
-    name = 'ParserParsingJoinNoneError';
-}
-export class ParserParsingJoinAllError extends ParserParsingJoinError {
-    childErrors;
-    name = 'ParserParsingJoinAllError';
-    constructor(message, depth, position, childErrors) {
-        super(message, depth, position);
-        this.childErrors = childErrors;
+    class ParserImplementationError extends ParserError {
+        name = 'ParserImplementationError';
     }
-}
-export class ParserParsingJoinDeepestError extends ParserParsingJoinError {
-    childErrors;
-    name = 'ParserParsingJoinDeepestError';
-    constructor(message, depth, position, childErrors) {
-        super(message, depth, position);
-        this.childErrors = childErrors;
+    class ParserImplementationInvariantError extends ParserImplementationError {
+        name = 'ParserImplementationInvariantError';
     }
-}
-export class ParserParsingJoinFurthestError extends ParserParsingJoinError {
-    childErrors;
-    name = 'ParserParsingJoinFurthestError';
-    constructor(message, depth, position, childErrors) {
-        super(message, depth, position);
-        this.childErrors = childErrors;
+    class ParserParsingFailedError extends ParserError {
+        depth;
+        position;
+        name = 'ParserParsingFailedError';
+        constructor(message, depth, position) {
+            super(message);
+            this.depth = depth;
+            this.position = position;
+        }
     }
+    class ParserParsingJoinError extends ParserParsingFailedError {
+        name = 'ParserParsingJoinError';
+        childErrors = [];
+    }
+    class ParserParsingJoinNoneError extends ParserParsingJoinError {
+        name = 'ParserParsingJoinNoneError';
+    }
+    class ParserParsingJoinAllError extends ParserParsingJoinError {
+        childErrors;
+        name = 'ParserParsingJoinAllError';
+        constructor(message, depth, position, childErrors) {
+            super(message, depth, position);
+            this.childErrors = childErrors;
+        }
+    }
+    class ParserParsingJoinDeepestError extends ParserParsingJoinError {
+        childErrors;
+        name = 'ParserParsingJoinDeepestError';
+        constructor(message, depth, position, childErrors) {
+            super(message, depth, position);
+            this.childErrors = childErrors;
+        }
+    }
+    class ParserParsingJoinFurthestError extends ParserParsingJoinError {
+        childErrors;
+        name = 'ParserParsingJoinFurthestError';
+        constructor(message, depth, position, childErrors) {
+            super(message, depth, position);
+            this.childErrors = childErrors;
+        }
+    }
+    class ParserParsingInvariantError extends ParserParsingFailedError {
+        name = 'ParserParsingInvariantError';
+    }
+    class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
+        name = 'ParserUnexpectedEndOfInputError';
+    }
+    class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
+        name = 'ParserUnexpectedRemainingInputError';
+    }
+    return {
+        ParserError,
+        ParserImplementationError,
+        ParserImplementationInvariantError,
+        ParserParsingFailedError,
+        ParserParsingJoinError,
+        ParserParsingJoinNoneError,
+        ParserParsingJoinAllError,
+        ParserParsingJoinDeepestError,
+        ParserParsingJoinFurthestError,
+        ParserParsingInvariantError,
+        ParserUnexpectedEndOfInputError,
+        ParserUnexpectedRemainingInputError,
+    };
 }
-export class ParserParsingInvariantError extends ParserParsingFailedError {
-    name = 'ParserParsingInvariantError';
-}
-export class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
-    name = 'ParserUnexpectedEndOfInputError';
-}
+export const normalParserErrorModule = createParserErrorModule(NormalLazyMessageError);
+export const noStackCaptureOverheadParserErrorModule = createParserErrorModule(NoStackCaptureOverheadLazyMessageError);

package/build/parserImplementationInvariant.d.ts

@@ -1,2 +1,2 @@
 import { type Falsy, type ValueOrAccessor } from './customInvariant.js';
-export declare function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
+export declare function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;

package/build/parserImplementationInvariant.js

@@ -1,5 +1,5 @@
-import { ParserImplementationInvariantError } from './parserError.js';
 import { customInvariant } from './customInvariant.js';
+import { normalParserErrorModule } from './parserError.js';
 export function parserImplementationInvariant(value, format, ...formatArguments) {
-    return customInvariant(ParserImplementationInvariantError, value, format, ...formatArguments);
+    return customInvariant(normalParserErrorModule.ParserImplementationInvariantError, value, format, ...formatArguments);
 }

package/build/parserInputCompanion.d.ts

@@ -1,20 +1,35 @@
 export type ParserInputCompanion<Sequence, Element> = {
     is(value: unknown): value is Sequence;
     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;
 };
 export declare class StringParserInputCompanion implements ParserInputCompanion<string, string> {
     is(value: unknown): value is string;
     from(elements: string[]): string;
+    concat(sequences: string[]): string;
     length(sequence: string): number;
     at(sequence: string, index: number): string | undefined;
+    subsequence(sequence: string, start: number, end: number): string;
+    indexOf(sequence: string, element: string, fromIndex?: number): number;
+    indexOfSubsequence(sequence: string, subsequence: string, fromIndex?: number): number;
+    equals(sequenceA: string, sequenceB: string): boolean;
 }
 export declare const stringParserInputCompanion: StringParserInputCompanion;
 export declare class Uint8ArrayParserInputCompanion implements ParserInputCompanion<Uint8Array, number> {
     is(value: unknown): value is Uint8Array;
     from(elements: number[]): Uint8Array;
+    concat(sequences: Uint8Array[]): Uint8Array;
     length(sequence: Uint8Array): number;
     at(sequence: Uint8Array, index: number): number | undefined;
+    subsequence(sequence: Uint8Array, start: number, end: number): Uint8Array;
+    indexOf(sequence: Uint8Array, element: number, fromIndex?: number): number;
+    indexOfSubsequence(sequence: Uint8Array, subsequence: Uint8Array, fromIndex?: number): number;
+    equals(sequenceA: Uint8Array, sequenceB: Uint8Array): boolean;
 }
 export declare const uint8ArrayParserInputCompanion: Uint8ArrayParserInputCompanion;

package/build/parserInputCompanion.js

@@ -5,12 +5,27 @@ export class StringParserInputCompanion {
     from(elements) {
         return elements.join('');
     }
+    concat(sequences) {
+        return sequences.join('');
+    }
     length(sequence) {
         return sequence.length;
     }
     at(sequence, index) {
         return sequence.at(index);
     }
+    subsequence(sequence, start, end) {
+        return sequence.slice(start, end);
+    }
+    indexOf(sequence, element, fromIndex) {
+        return sequence.indexOf(element, fromIndex);
+    }
+    indexOfSubsequence(sequence, subsequence, fromIndex) {
+        return sequence.indexOf(subsequence, fromIndex);
+    }
+    equals(sequenceA, sequenceB) {
+        return sequenceA === sequenceB;
+    }
 }
 export const stringParserInputCompanion = new StringParserInputCompanion();
 export class Uint8ArrayParserInputCompanion {
@@ -20,11 +35,34 @@ export class Uint8ArrayParserInputCompanion {
     from(elements) {
         return new Uint8Array(elements);
     }
+    concat(sequences) {
+        return new Uint8Array(Buffer.concat(sequences));
+    }
     length(sequence) {
         return sequence.length;
     }
     at(sequence, index) {
         return sequence.at(index);
     }
+    subsequence(sequence, start, end) {
+        return sequence.subarray(start, end);
+    }
+    indexOf(sequence, element, fromIndex) {
+        return sequence.indexOf(element, fromIndex);
+    }
+    indexOfSubsequence(sequence, subsequence, fromIndex) {
+        return Buffer.from(sequence).indexOf(Buffer.from(subsequence), fromIndex);
+    }
+    equals(sequenceA, sequenceB) {
+        if (sequenceA.length !== sequenceB.length) {
+            return false;
+        }
+        for (const [index, element] of sequenceA.entries()) {
+            if (element !== sequenceB[index]) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 export const uint8ArrayParserInputCompanion = new Uint8ArrayParserInputCompanion();

package/build/promiseCompose.d.ts

@@ -1 +1 @@
-export declare function promiseCompose<A, B, C>(f1: (a: A) => Promise<B>, f2: (b: B) => C | Promise<C>): (a: A) => Promise<C>;
+export declare function promiseCompose<A, B, C>(f1: (a: A) => B | Promise<B>, f2: (b: B) => C | Promise<C>): (a: A) => C | Promise<C>;

package/build/promiseCompose.js

@@ -1,3 +1,13 @@
 export function promiseCompose(f1, f2) {
-    return async (a) => f1(a).then(f2);
+    async function promiseComposed(a) {
+        const bOrBPromise = f1(a);
+        if (bOrBPromise instanceof Promise) {
+            return bOrBPromise.then(f2);
+        }
+        return f2(bOrBPromise);
+    }
+    Object.defineProperty(promiseComposed, 'name', {
+        value: `promiseCompose(${f1.name}, ${f2.name})`,
+    });
+    return promiseComposed;
 }

package/build/promiseSettled.d.ts

@@ -0,0 +1 @@
+export declare function promiseSettled<T>(promise: Promise<T>): Promise<PromiseSettledResult<T>>;

package/build/promiseSettled.js

@@ -0,0 +1,4 @@
+export async function promiseSettled(promise) {
+    const [promiseSettledResult] = await Promise.allSettled([promise]);
+    return promiseSettledResult;
+}

package/build/separatedArrayParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createSeparatedArrayParser: <ElementOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>, separatorParser: Parser<unknown, Sequence>) => Parser<ElementOutput[], Sequence>;

package/build/separatedArrayParser.js

@@ -0,0 +1,39 @@
+import { getParserName, setParserName } from './parser.js';
+import { isParserParsingFailedError } from './parserError.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+export const createSeparatedArrayParser = (elementParser, separatorParser) => {
+    const separatorThenElementParser = promiseCompose(createTupleParser([
+        separatorParser,
+        elementParser,
+    ]), ([, element]) => element);
+    const separatedArrayParser = async (parserContext) => {
+        let parser = elementParser;
+        const elements = [];
+        while (true) {
+            const elementParserContext = parserContext.lookahead();
+            const initialPosition = elementParserContext.position;
+            try {
+                const element = await parser(elementParserContext);
+                if (elementParserContext.position === initialPosition) {
+                    break;
+                }
+                elements.push(element);
+                elementParserContext.unlookahead();
+            }
+            catch (error) {
+                if (isParserParsingFailedError(error)) {
+                    break;
+                }
+                throw error;
+            }
+            finally {
+                elementParserContext.dispose();
+            }
+            parser = separatorThenElementParser;
+        }
+        return elements;
+    };
+    setParserName(separatedArrayParser, getParserName(elementParser, 'anonymousSeparatedArrayChild') + '*');
+    return separatedArrayParser;
+};

package/build/separatedArrayParser.test.d.ts

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

package/build/separatedArrayParser.test.js

@@ -0,0 +1,21 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedArrayParser } from './separatedArrayParser.js';
+import { runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+test('does not loop forever with a child parser that does not consume anything', async (t) => {
+    const parser = createSeparatedArrayParser(async () => undefined, () => undefined);
+    const { output } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
+    t.deepEqual(output, []);
+});
+testProp('separatedArray', [
+    fc.array(fc.constant('element')),
+], async (t, elements) => {
+    const separatedArrayParser = createSeparatedArrayParser(createExactSequenceParser('element'), createExactSequenceParser('separator'));
+    const actual = await runParser(separatedArrayParser, elements.join('separator'), stringParserInputCompanion);
+    const expected = elements;
+    t.deepEqual(actual, expected);
+}, {
+    verbose: true,
+});

package/build/separatedNonEmptyArrayParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createSeparatedNonEmptyArrayParser: <ElementOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>, separatorParser: Parser<unknown, Sequence>) => Parser<ElementOutput[], Sequence>;

package/build/separatedNonEmptyArrayParser.js

@@ -0,0 +1,40 @@
+import { getParserName, setParserName } from './parser.js';
+import { isParserParsingFailedError } from './parserError.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+export const createSeparatedNonEmptyArrayParser = (elementParser, separatorParser) => {
+    const separatorThenElementParser = promiseCompose(createTupleParser([
+        separatorParser,
+        elementParser,
+    ]), ([, element]) => element);
+    const separatedNonEmptyArrayParser = async (parserContext) => {
+        let parser = elementParser;
+        const elements = [];
+        while (true) {
+            const elementParserContext = parserContext.lookahead();
+            const initialPosition = elementParserContext.position;
+            try {
+                const element = await parser(elementParserContext);
+                if (elementParserContext.position === initialPosition) {
+                    break;
+                }
+                elements.push(element);
+                elementParserContext.unlookahead();
+            }
+            catch (error) {
+                if (isParserParsingFailedError(error)) {
+                    break;
+                }
+                throw error;
+            }
+            finally {
+                elementParserContext.dispose();
+            }
+            parser = separatorThenElementParser;
+        }
+        parserContext.invariant(elements.length > 0, 'Expected elementParser (%s) to match at least once', getParserName(elementParser, 'anonymousSeparatedNonEmptyArrayChild'));
+        return elements;
+    };
+    setParserName(separatedNonEmptyArrayParser, getParserName(elementParser, 'anonymousSeparatedNonEmptyArrayChild') + '+');
+    return separatedNonEmptyArrayParser;
+};

package/build/separatedNonEmptyArrayParser.test.d.ts

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

package/build/separatedNonEmptyArrayParser.test.js

@@ -0,0 +1,66 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
+import { runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { stringFromAsyncIterable } from './stringFromAsyncIterable.js';
+test('empty input throws error', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser(','));
+    await t.throwsAsync(async () => runParser(parser, '', stringParserInputCompanion), {
+        any: true,
+        message: /Expected .* to match at least once/,
+    });
+});
+test('single element without separator matches', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser(','));
+    const result = await runParser(parser, 'element', stringParserInputCompanion);
+    t.deepEqual(result, ['element']);
+});
+test('two elements with separator matches', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser(','));
+    const result = await runParser(parser, 'element,element', stringParserInputCompanion);
+    t.deepEqual(result, ['element', 'element']);
+});
+test('multiple elements with separator matches', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('a'), createExactSequenceParser(','));
+    const result = await runParser(parser, 'a,a,a,a', stringParserInputCompanion);
+    t.deepEqual(result, ['a', 'a', 'a', 'a']);
+});
+test('does not consume trailing separator', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser(','));
+    const { output, remainingInput } = await runParserWithRemainingInput(parser, 'element,element,', stringParserInputCompanion);
+    t.deepEqual(output, ['element', 'element']);
+    t.is(await stringFromAsyncIterable(remainingInput), ',');
+});
+test('does not loop forever with a child parser that does not consume anything', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(async () => undefined, () => undefined);
+    await t.throwsAsync(async () => runParser(parser, 'foo', stringParserInputCompanion), {
+        any: true,
+        message: /Expected .* to match at least once/,
+    });
+});
+test('partial match throws error', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser(','));
+    await t.throwsAsync(async () => runParser(parser, 'elem', stringParserInputCompanion), {
+        any: true,
+        message: /Expected .* to match at least once/,
+    });
+});
+testProp('separatedNonEmptyArray with at least one element', [
+    fc.array(fc.constant('element'), { minLength: 1 }),
+], async (t, elements) => {
+    const separatedNonEmptyArrayParser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser('separator'));
+    const actual = await runParser(separatedNonEmptyArrayParser, elements.join('separator'), stringParserInputCompanion);
+    const expected = elements;
+    t.deepEqual(actual, expected);
+}, {
+    verbose: true,
+});
+test('separatedNonEmptyArray throws on empty array', async (t) => {
+    const separatedNonEmptyArrayParser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser('separator'));
+    await t.throwsAsync(async () => runParser(separatedNonEmptyArrayParser, '', stringParserInputCompanion), {
+        any: true,
+        message: /Expected .* to match at least once/,
+    });
+});

package/build/sequenceBuffer.d.ts

@@ -1,15 +1,25 @@
 import { type ParserInputCompanion } from './parserInputCompanion.js';
+export type SequenceBufferState<Sequence> = {
+    consumedBufferedSequences: Sequence[];
+    unconsumedBufferedSequences: Sequence[];
+};
 export type SequenceBuffer<Sequence, Element> = {
     push(sequence: Sequence): void;
     peek(offset: number): Element | undefined;
+    peekSequence(start: number, end: number): Sequence | undefined;
     skip(offset: number): void;
+    toSequenceBufferState(): SequenceBufferState<Sequence>;
 };
 export declare class SequenceBufferImplementation<Sequence, Element> implements SequenceBuffer<Sequence, Element> {
     private readonly _parserInputCompanion;
     private readonly _sequences;
     private _indexInFirstSequence;
     constructor(_parserInputCompanion: ParserInputCompanion<Sequence, Element>);
+    get length(): number;
+    private _shift;
     push(sequence: Sequence): void;
     peek(offset: number): Element | undefined;
+    peekSequence(start: number, end: number): Sequence | undefined;
     skip(offset: number): void;
+    toSequenceBufferState(): SequenceBufferState<Sequence>;
 }

package/build/sequenceBuffer.js

@@ -6,8 +6,10 @@ export class SequenceBufferImplementation {
     constructor(_parserInputCompanion) {
         this._parserInputCompanion = _parserInputCompanion;
     }
-    push(sequence) {
-        this._sequences.push(sequence);
+    get length() {
+        return this._sequences.reduce((sequenceLength, sequence) => sequenceLength + this._parserInputCompanion.length(sequence), 0 - this._indexInFirstSequence);
+    }
+    _shift() {
         while (this._sequences.length > 0) {
             const firstSequence = this._sequences[0];
             const firstSequenceLength = this._parserInputCompanion.length(firstSequence);
@@ -22,6 +24,10 @@ export class SequenceBufferImplementation {
             this._indexInFirstSequence -= firstSequenceLength;
         }
     }
+    push(sequence) {
+        this._sequences.push(sequence);
+        this._shift();
+    }
     peek(offset) {
         invariant(offset >= 0, 'Offset must be non-negative.');
         let index = this._indexInFirstSequence + offset;
@@ -34,7 +40,53 @@ export class SequenceBufferImplementation {
         }
         return undefined;
     }
+    peekSequence(start, end) {
+        invariant(start >= 0, 'Start must be non-negative.');
+        invariant(end >= start, 'End must be greater than or equal to start.');
+        let startIndex = this._indexInFirstSequence + start;
+        let endIndex = this._indexInFirstSequence + end;
+        const sequences = [];
+        for (const sequence of this._sequences) {
+            const sequenceLength = this._parserInputCompanion.length(sequence);
+            if (startIndex < sequenceLength) {
+                const subsequence = this._parserInputCompanion.subsequence(sequence, Math.max(0, startIndex), Math.min(sequenceLength, endIndex));
+                sequences.push(subsequence);
+            }
+            startIndex -= sequenceLength;
+            endIndex -= sequenceLength;
+            if (endIndex <= 0) {
+                break;
+            }
+        }
+        return endIndex > 0 ? undefined : this._parserInputCompanion.concat(sequences);
+    }
     skip(offset) {
         this._indexInFirstSequence += offset;
+        this._shift();
+    }
+    toSequenceBufferState() {
+        if (this._sequences.length === 0) {
+            return {
+                consumedBufferedSequences: [],
+                unconsumedBufferedSequences: [],
+            };
+        }
+        if (this._indexInFirstSequence === 0) {
+            return {
+                consumedBufferedSequences: [],
+                unconsumedBufferedSequences: [...this._sequences],
+            };
+        }
+        const firstSequence = this._sequences[0];
+        const firstSequenceLength = this._parserInputCompanion.length(firstSequence);
+        const consumedFirstSequence = this._parserInputCompanion.subsequence(firstSequence, 0, this._indexInFirstSequence);
+        const unconsumedFirstSequence = this._parserInputCompanion.subsequence(firstSequence, this._indexInFirstSequence, firstSequenceLength);
+        const unconsumedFirstSequenceLength = this._parserInputCompanion.length(unconsumedFirstSequence);
+        return {
+            consumedBufferedSequences: [consumedFirstSequence],
+            unconsumedBufferedSequences: (unconsumedFirstSequenceLength === 0
+                ? this._sequences.slice(1)
+                : [unconsumedFirstSequence, ...this._sequences.slice(1)]),
+        };
     }
 }