@futpib/parser 1.0.0

package/build/arrayParser.js

@@ -0,0 +1,30 @@
+import { getParserName, setParserName } from "./parser.js";
+import { ParserParsingFailedError } from "./parserError.js";
+export const createArrayParser = (elementParser) => {
+    const arrayParser = async (parserContext) => {
+        const elements = [];
+        while (true) {
+            const elementParserContext = parserContext.lookahead();
+            const initialPosition = elementParserContext.position;
+            try {
+                const element = await elementParser(elementParserContext);
+                if (elementParserContext.position === initialPosition) {
+                    return elements;
+                }
+                elements.push(element);
+                elementParserContext.unlookahead();
+            }
+            catch (error) {
+                if (error instanceof ParserParsingFailedError) {
+                    return elements;
+                }
+                throw error;
+            }
+            finally {
+                elementParserContext.dispose();
+            }
+        }
+    };
+    setParserName(arrayParser, getParserName(elementParser, 'anonymousArrayChild') + '*');
+    return arrayParser;
+};

package/build/arrayParser.test.d.ts

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

package/build/arrayParser.test.js

@@ -0,0 +1,9 @@
+import test from 'ava';
+import { createArrayParser } from './arrayParser.js';
+import { runParser } from './parser.js';
+import { stringInputCompanion } from './inputCompanion.js';
+test('does not loop forever with a child parser that does not consume anything', async (t) => {
+    const parser = createArrayParser(async () => undefined);
+    const result = await runParser(parser, 'foo', stringInputCompanion);
+    t.deepEqual(result, []);
+});

package/build/bsonParser.d.ts

@@ -0,0 +1,3 @@
+import { type JsonObject } from 'type-fest';
+import { type Parser } from './parser.js';
+export declare const bsonDocumentParser: Parser<JsonObject, Uint8Array>;

package/build/bsonParser.js

@@ -0,0 +1,70 @@
+import { getParserName, setParserName } from './parser.js';
+import { invariantDefined } from './invariantDefined.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createSkipParser } from './skipParser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { createTerminatedArrayParser } from './terminatedArrayParser.js';
+import { createElementParser } from './elementParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+import { createUnionParser } from './unionParser.js';
+import { parserCreatorCompose } from './parserCreatorCompose.js';
+const createFixedLengthBufferParser = (length) => promiseCompose(createFixedLengthSequenceParser(length), sequence => Buffer.from(sequence));
+const buffer1Parser = createFixedLengthBufferParser(1);
+const buffer4Parser = createFixedLengthBufferParser(4);
+const buffer8Parser = createFixedLengthBufferParser(8);
+const elementParser = createElementParser();
+const nullByteParser = createExactElementParser(0);
+const cstringParser = promiseCompose(createTerminatedArrayParser(parserCreatorCompose(() => elementParser, (byte) => async (parserContext) => parserContext.invariant(byte, 'Expected non-null byte'))(), nullByteParser), ([sequence]) => Buffer.from(sequence).toString('utf8'));
+const doubleParser = promiseCompose(buffer8Parser, buffer => buffer.readDoubleLE(0));
+const int32Parser = promiseCompose(buffer4Parser, buffer => buffer.readInt32LE(0));
+const uint32Parser = promiseCompose(buffer4Parser, buffer => buffer.readUInt32LE(0));
+const createFixedLengthStringParser = (length) => promiseCompose(createFixedLengthBufferParser(length), buffer => buffer.toString('utf8'));
+const createFixedLengthNullTerminatedStringParser = (lengthWihoutNullTerminator) => promiseCompose(createTupleParser([
+    createFixedLengthStringParser(lengthWihoutNullTerminator),
+    nullByteParser,
+]), ([string]) => string);
+const bsonStringParser = async (parserContext) => {
+    const stringSize = await uint32Parser(parserContext);
+    return createFixedLengthNullTerminatedStringParser(stringSize - 1)(parserContext);
+};
+const bsonArrayParser = promiseCompose(createTupleParser([
+    createSkipParser(4),
+    createParserAccessorParser(() => bsonElementListParser),
+]), ([_, elements]) => elements.map(([_, value]) => value));
+const bsonBooleanParser = async (parserContext) => {
+    const booleanValue = invariantDefined(await parserContext.read(0), 'Unexpected end of input');
+    return booleanValue === 1;
+};
+const int8Parser = promiseCompose(buffer1Parser, buffer => buffer.readInt8(0));
+const createExactInt8Parser = (value) => parserCreatorCompose(() => int8Parser, actualValue => async (parserContext) => {
+    parserContext.invariant(actualValue === value, 'Expected %s, got %s', value, actualValue);
+    return actualValue;
+})();
+const createBsonElementParser = (elementType, valueParser) => setParserName(promiseCompose(createTupleParser([
+    createExactInt8Parser(elementType),
+    cstringParser,
+    valueParser,
+]), ([_, elementName, elementValue]) => [elementName, elementValue]), `bsonElementParser(${elementType}, ${getParserName(valueParser)})`);
+const bsonDoubleElementParser = createBsonElementParser(1, doubleParser);
+const bsonStringElementParser = createBsonElementParser(2, bsonStringParser);
+const bsonDocumentElementParser = createBsonElementParser(3, createParserAccessorParser(() => bsonDocumentParser));
+const bsonArrayElementParser = createBsonElementParser(4, bsonArrayParser);
+const bsonBooleanElementParser = createBsonElementParser(8, bsonBooleanParser);
+const bsonNullElementParser = createBsonElementParser(10, async () => null);
+const bsonInt32ElementParser = createBsonElementParser(16, int32Parser);
+const bsonElementParser = createUnionParser([
+    bsonDoubleElementParser,
+    bsonStringElementParser,
+    bsonDocumentElementParser,
+    bsonArrayElementParser,
+    bsonBooleanElementParser,
+    bsonNullElementParser,
+    bsonInt32ElementParser,
+]);
+const bsonElementListParser = promiseCompose(createTerminatedArrayParser(bsonElementParser, nullByteParser), ([elements]) => elements);
+export const bsonDocumentParser = promiseCompose(createTupleParser([
+    createSkipParser(4),
+    bsonElementListParser,
+]), ([_, elements]) => Object.fromEntries(elements));

package/build/bsonParser.test.d.ts

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

package/build/bsonParser.test.js

@@ -0,0 +1,24 @@
+import { testProp, fc } from '@fast-check/ava';
+import { BSON } from 'bson';
+import { bsonDocumentParser } from './bsonParser.js';
+import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
+import { runParser } from './parser.js';
+import { uint8ArrayInputCompanion } from './inputCompanion.js';
+testProp('bson', [
+    arbitrarilySlicedAsyncIterator(fc
+        .json()
+        .filter(jsonString => {
+        // BSON.serialize does not support non-object top-level values
+        const jsonValue = JSON.parse(jsonString);
+        return (jsonValue !== null
+            && typeof jsonValue === 'object'
+            && !Array.isArray(jsonValue));
+    })
+        .map(jsonString => BSON.serialize(JSON.parse(jsonString)))),
+], async (t, [bsonUint8Array, bsonUint8ArrayChunkIterator]) => {
+    const expected = BSON.deserialize(bsonUint8Array);
+    const actual = await runParser(bsonDocumentParser, bsonUint8ArrayChunkIterator, uint8ArrayInputCompanion);
+    t.deepEqual(actual, expected);
+}, {
+    verbose: true,
+});

package/build/createDisjunctionParser.d.ts

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

package/build/createDisjunctionParser.js

@@ -0,0 +1,47 @@
+import { ParserParsingFailedError } from './parserError.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { parserParsingInvariant } from './parserParsingInvariant.js';
+function getParserName(parser) {
+    return parser.name || 'anonymousDisjunctionChild';
+}
+export const createDisjunctionParser = (childParsers) => {
+    parserImplementationInvariant(childParsers.length > 0, 'Disjunction parser must have at least one child parser.');
+    const disjunctionParser = async (parserContext) => {
+        const parserParsingFailedErrors = [];
+        for (const childParser of childParsers) {
+            const childParserContext = parserContext.lookahead(getParserName(childParser));
+            const [childParserResult] = await Promise.allSettled([childParser(childParserContext)]);
+            if (childParserResult.status === 'fulfilled') {
+                const successfulParserOutput = childParserResult.value;
+                childParserContext.unlookahead();
+                childParserContext.dispose();
+                return successfulParserOutput;
+            }
+            else {
+                const error = childParserResult.reason;
+                if (error instanceof ParserParsingFailedError) {
+                    parserParsingFailedErrors.push(error);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        parserParsingInvariant(false, [
+            'No disjunction child parser succeeded.',
+            'Parsing errors, indented, separated by newlines:',
+            '%s',
+            'End of parsing errors.',
+        ], parserParsingFailedErrors
+            .flatMap(error => error.stack?.split('\n'))
+            .map(line => '  ' + line)
+            .join('\n'));
+    };
+    const name = [
+        '(',
+        ...childParsers.map(getParserName).join('|'),
+        ')',
+    ].join('');
+    Object.defineProperty(disjunctionParser, 'name', { value: name });
+    return disjunctionParser;
+};

package/build/createExactParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createExactParser: <InputChunk>(inputChunk: InputChunk) => Parser<InputChunk, InputChunk, unknown>;

package/build/createExactParser.js

@@ -0,0 +1,12 @@
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+export const createExactParser = (inputChunk) => {
+    parserImplementationInvariant(length > 0, 'Length must be positive.');
+    return async (parserContext) => {
+        const elements = [];
+        for (let i = 0; i < length; i++) {
+            const element = await parserContext.read(0);
+            elements.push(element);
+        }
+        return parserContext.from(elements);
+    };
+};

package/build/createSequentialUnionParser.d.ts

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

package/build/createSequentialUnionParser.js

@@ -0,0 +1,69 @@
+import { ParserParsingFailedError } from './parserError.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { parserParsingInvariant } from './parserParsingInvariant.js';
+function getParserName(parser) {
+    return parser.name || 'anonymousSequentialUnionChild';
+}
+export const createDisjunctionParser = (childParsers) => {
+    parserImplementationInvariant(childParsers.length > 0, 'SequentialUnion parser must have at least one child parser.');
+    const sequentialUnionParser = async (parserContext) => {
+        let runningChildParserContexts = [];
+        const childParserResults = (async function* () {
+            for (const childParser of childParsers) {
+                const childParserContext = parserContext.lookahead(getParserName(childParser));
+                runningChildParserContexts.push(childParserContext);
+                const [promiseSettledResult] = await Promise.allSettled([childParser(childParserContext)]);
+                yield {
+                    ...promiseSettledResult,
+                    context: childParserContext,
+                };
+            }
+        })();
+        const parserParsingFailedErrors = [];
+        const successfulParserOutputs = [];
+        const successfulParserContexts = [];
+        for await (const childParserResult of childParserResults) {
+            runningChildParserContexts = runningChildParserContexts.filter(runningChildParserContext => runningChildParserContext !== childParserResult.context);
+            if (childParserResult.status === 'fulfilled') {
+                successfulParserOutputs.push(childParserResult.value);
+                successfulParserContexts.push(childParserResult.context);
+            }
+            else {
+                const error = childParserResult.reason;
+                if (error instanceof ParserParsingFailedError) {
+                    parserParsingFailedErrors.push(error);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        parserImplementationInvariant(successfulParserOutputs.length <= 1, [
+            'Multiple sequentialUnion child parsers succeeded.',
+            'Successful parser outputs, indented, separated by newlines:',
+            '%s',
+            'End of successful parser outputs.',
+        ], successfulParserOutputs.map(output => '  ' + JSON.stringify(output)).join('\n'));
+        parserParsingInvariant(successfulParserOutputs.length === 1, [
+            'No sequentialUnion child parser succeeded.',
+            'Parsing errors, indented, separated by newlines:',
+            '%s',
+            'End of parsing errors.',
+        ], parserParsingFailedErrors
+            .flatMap(error => error.stack?.split('\n'))
+            .map(line => '  ' + line)
+            .join('\n'));
+        const [successfulParserContext] = successfulParserContexts;
+        successfulParserContext.unlookahead();
+        successfulParserContext.dispose();
+        const [successfulParserOutput] = successfulParserOutputs;
+        return successfulParserOutput;
+    };
+    const name = [
+        '(',
+        ...childParsers.map(getParserName).join('|'),
+        ')',
+    ].join('');
+    Object.defineProperty(sequentialUnionParser, 'name', { value: name });
+    return sequentialUnionParser;
+};

package/build/debugLogParser.d.ts

@@ -0,0 +1,2 @@
+import { Parser } from "./parser.js";
+export declare const createDebugLogParser: <Output, Sequence>(childParser: Parser<Output, Sequence>) => Parser<Output, Sequence>;

package/build/debugLogParser.js

@@ -0,0 +1,23 @@
+import { getParserName, setParserName } from "./parser.js";
+export const createDebugLogParser = (childParser) => {
+    let idCounter = 0;
+    const debugLogParser = async (parserContext) => {
+        const id = idCounter++;
+        const initialPosition = parserContext.position;
+        console.debug('%s %s: started (position: %s)', getParserName(childParser), id, initialPosition);
+        try {
+            const result = await childParser(parserContext);
+            console.debug('%s %s: finished (position: %s, consumed: %s): %o', getParserName(childParser), id, parserContext.position, parserContext.position - initialPosition, result);
+            return result;
+        }
+        catch (error) {
+            console.debug('%s %s: failed (position: %s, consumed: %s): %o', getParserName(childParser), id, parserContext.position, parserContext.position - initialPosition, error);
+            throw error;
+        }
+    };
+    return setParserName(debugLogParser, [
+        'debugLog(',
+        getParserName(childParser),
+        ')',
+    ].join(''));
+};

package/build/disjunctionParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createDisjunctionParser: <Output, Sequence>(childParsers: Array<Parser<any, Sequence, any>>) => Parser<Output, Sequence, unknown>;

package/build/disjunctionParser.js

@@ -0,0 +1,35 @@
+import { getParserName, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+export const createDisjunctionParser = (childParsers) => {
+    parserImplementationInvariant(childParsers.length > 0, 'Disjunction parser must have at least one child parser.');
+    const disjunctionParser = async (parserContext) => {
+        const parserParsingFailedErrors = [];
+        for (const childParser of childParsers) {
+            const childParserContext = parserContext.lookahead({
+                debugName: getParserName(childParser, 'anonymousDisjunctionChild'),
+            });
+            const [childParserResult] = await Promise.allSettled([childParser(childParserContext)]);
+            if (childParserResult.status === 'fulfilled') {
+                const successfulParserOutput = childParserResult.value;
+                childParserContext.unlookahead();
+                childParserContext.dispose();
+                return successfulParserOutput;
+            }
+            const error = childParserResult.reason;
+            if (error instanceof ParserParsingFailedError) {
+                parserParsingFailedErrors.push(error);
+            }
+            else {
+                throw error;
+            }
+        }
+        parserContext.invariantJoin(false, parserParsingFailedErrors, 'No disjunction child parser succeeded.');
+    };
+    const name = [
+        '(',
+        ...childParsers.map(childParser => getParserName(childParser, 'anonymousDiscjunctionChild')).join('|'),
+        ')',
+    ].join('');
+    return setParserName(disjunctionParser, name);
+};

package/build/elementParser.d.ts

@@ -0,0 +1,3 @@
+import { Parser } from "./parser.js";
+import { DeriveSequenceElement } from "./sequence.js";
+export declare const createElementParser: <Sequence, Element = DeriveSequenceElement<Sequence>>() => Parser<Element, Sequence, Element>;

package/build/elementParser.js

@@ -0,0 +1 @@
+export const createElementParser = () => parserContext => parserContext.read(0);

package/build/endOfInputParser.d.ts

@@ -0,0 +1,4 @@
+import { Parser } from "./parser.js";
+import { DeriveSequenceElement } from "./sequence.js";
+export declare const createEndOfInputParser: <Sequence, Element = DeriveSequenceElement<Sequence>>() => Parser<void, Sequence, Element>;
+export declare const endOfInputParser: Parser<void, any, any>;

package/build/endOfInputParser.js

@@ -0,0 +1,4 @@
+export const createEndOfInputParser = () => async (parserContext) => {
+    parserContext.invariant(await parserContext.peek(0) === undefined, 'Expected end of input.');
+};
+export const endOfInputParser = createEndOfInputParser();

package/build/exactElementParser.d.ts

@@ -0,0 +1,3 @@
+import { type Parser } from './parser.js';
+import { DeriveSequenceElement } from './sequence.js';
+export declare const createExactElementParser: <Sequence, Element = DeriveSequenceElement<Sequence>>(element: Element) => Parser<Element, Sequence, Element>;

package/build/exactElementParser.js

@@ -0,0 +1,6 @@
+export const createExactElementParser = (element) => async (parserContext) => {
+    const actualElement = await parserContext.peek(0);
+    parserContext.invariant(actualElement === element, 'Expected %s, got %s', element, actualElement);
+    parserContext.skip(1);
+    return element;
+};

package/build/exactSequenceParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createExactSequenceParser: <Sequence>(sequence: Sequence) => Parser<Sequence, Sequence, unknown>;

package/build/exactSequenceParser.js

@@ -0,0 +1,15 @@
+import { inspect } from 'util';
+import { setParserName } from './parser.js';
+export const createExactSequenceParser = (sequence) => {
+    const exactSequenceParser = async (parserContext) => {
+        const length = parserContext.length(sequence);
+        for (let index = 0; index < length; index++) {
+            const element = await parserContext.read(0);
+            const expectedElement = parserContext.at(sequence, index);
+            parserContext.invariant(element === expectedElement, 'Expected "%s", got "%s", at index %s', expectedElement, element, index);
+        }
+        return sequence;
+    };
+    setParserName(exactSequenceParser, inspect(sequence));
+    return exactSequenceParser;
+};

package/build/fixedLengthChunkParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createFixedLengthParser: <InputChunk>(length: number) => Parser<InputChunk, InputChunk, unknown>;

package/build/fixedLengthChunkParser.js

@@ -0,0 +1,12 @@
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+export const createFixedLengthParser = (length) => {
+    parserImplementationInvariant(length > 0, 'Length must be positive.');
+    return async (parserContext) => {
+        const elements = [];
+        for (let i = 0; i < length; i++) {
+            const element = await parserContext.read(0);
+            elements.push(element);
+        }
+        return parserContext.from(elements);
+    };
+};

package/build/fixedLengthParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createFixedLengthSequenceParser: <Sequence>(length: number) => Parser<Sequence, Sequence, unknown>;

package/build/fixedLengthParser.js

@@ -0,0 +1,12 @@
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+export const createFixedLengthSequenceParser = (length) => {
+    parserImplementationInvariant(length >= 0, 'Length must be non-negative got %s.', length);
+    return async (parserContext) => {
+        const elements = [];
+        for (let i = 0; i < length; i++) {
+            const element = await parserContext.read(0);
+            elements.push(element);
+        }
+        return parserContext.from(elements);
+    };
+};

package/build/fixedLengthSequenceParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createFixedLengthSequenceParser: <Sequence>(lengthInput: bigint | number) => Parser<Sequence, Sequence, unknown>;

package/build/fixedLengthSequenceParser.js

@@ -0,0 +1,16 @@
+import { setParserName } from './parser.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+export const createFixedLengthSequenceParser = (lengthInput) => {
+    const length = BigInt(lengthInput);
+    parserImplementationInvariant(length >= 0n, 'Length must be non-negative got %s.', length);
+    const fixedLengthSequenceParser = async (parserContext) => {
+        const elements = [];
+        for (let i = 0n; i < length; i++) {
+            const element = await parserContext.read(0);
+            elements.push(element);
+        }
+        return parserContext.from(elements);
+    };
+    setParserName(fixedLengthSequenceParser, `.{${length}}`);
+    return fixedLengthSequenceParser;
+};

package/build/index.d.ts

@@ -0,0 +1,18 @@
+export { Parser, runParser, setParserName, getParserName, } from './parser.js';
+export { ParserContext, } from './parserContext.js';
+export { createTupleParser, } from './tupleParser.js';
+export { createExactSequenceParser, } from './exactSequenceParser.js';
+export { createFixedLengthSequenceParser, } from './fixedLengthSequenceParser.js';
+export { createArrayParser, } from './arrayParser.js';
+export { createOptionalParser, } from './optionalParser.js';
+export { createUnionParser, } from './unionParser.js';
+export { createDisjunctionParser, } from './disjunctionParser.js';
+export { createParserAccessorParser, } from './parserAccessorParser.js';
+export { createElementParser, } from './elementParser.js';
+export { createTerminatedArrayParser, } from './terminatedArrayParser.js';
+export { createSliceBoundedParser, } from './sliceBoundedParser.js';
+export { createExactElementParser, } from './exactElementParser.js';
+export { createSkipParser, } from './skipParser.js';
+export { createEndOfInputParser, } from './endOfInputParser.js';
+export { createListParser, } from './listParser.js';
+export { createDebugLogParser, } from './debugLogParser.js';

package/build/index.js

@@ -0,0 +1,17 @@
+export { runParser, setParserName, getParserName, } from './parser.js';
+export { createTupleParser, } from './tupleParser.js';
+export { createExactSequenceParser, } from './exactSequenceParser.js';
+export { createFixedLengthSequenceParser, } from './fixedLengthSequenceParser.js';
+export { createArrayParser, } from './arrayParser.js';
+export { createOptionalParser, } from './optionalParser.js';
+export { createUnionParser, } from './unionParser.js';
+export { createDisjunctionParser, } from './disjunctionParser.js';
+export { createParserAccessorParser, } from './parserAccessorParser.js';
+export { createElementParser, } from './elementParser.js';
+export { createTerminatedArrayParser, } from './terminatedArrayParser.js';
+export { createSliceBoundedParser, } from './sliceBoundedParser.js';
+export { createExactElementParser, } from './exactElementParser.js';
+export { createSkipParser, } from './skipParser.js';
+export { createEndOfInputParser, } from './endOfInputParser.js';
+export { createListParser, } from './listParser.js';
+export { createDebugLogParser, } from './debugLogParser.js';

package/build/index.test.d.ts

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

package/build/index.test.js

@@ -0,0 +1,2 @@
+import test from 'ava';
+test.todo('TODO');

package/build/inputChunkBuffer.d.ts

@@ -0,0 +1,15 @@
+import { type InputCompanion } from './inputCompanion.js';
+export interface SequenceBuffer<Sequence, InputElement> {
+    push(sequence: Sequence): void;
+    peek(offset: number): InputElement | undefined;
+    skip(offset: number): void;
+}
+export declare class SequenceBufferImplementation<Sequence, InputElement> implements SequenceBuffer<Sequence, InputElement> {
+    private readonly _inputCompanion;
+    private readonly _sequences;
+    private _indexInFirstSequence;
+    constructor(_inputCompanion: InputCompanion<Sequence, InputElement>);
+    push(sequence: Sequence): void;
+    peek(offset: number): InputElement | undefined;
+    skip(offset: number): void;
+}

package/build/inputChunkBuffer.js

@@ -0,0 +1,40 @@
+import invariant from 'invariant';
+export class SequenceBufferImplementation {
+    _inputCompanion;
+    _sequences = [];
+    _indexInFirstSequence = 0;
+    constructor(_inputCompanion) {
+        this._inputCompanion = _inputCompanion;
+    }
+    push(sequence) {
+        this._sequences.push(sequence);
+        while (this._sequences.length > 0) {
+            const firstSequence = this._sequences[0];
+            const firstSequenceLength = this._inputCompanion.length(firstSequence);
+            if (firstSequenceLength === 0) {
+                this._sequences.shift();
+                continue;
+            }
+            if (this._indexInFirstSequence < firstSequenceLength) {
+                break;
+            }
+            this._sequences.shift();
+            this._indexInFirstSequence -= firstSequenceLength;
+        }
+    }
+    peek(offset) {
+        invariant(offset >= 0, 'Offset must be non-negative.');
+        let index = this._indexInFirstSequence + offset;
+        for (const sequence of this._sequences) {
+            const sequenceLength = this._inputCompanion.length(sequence);
+            if (index < sequenceLength) {
+                return this._inputCompanion.at(sequence, index);
+            }
+            index -= sequenceLength;
+        }
+        return undefined;
+    }
+    skip(offset) {
+        this._indexInFirstSequence += offset;
+    }
+}

package/build/inputChunkBuffer.test.d.ts

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

package/build/inputChunkBuffer.test.js

@@ -0,0 +1,34 @@
+import test from 'ava';
+import { SequenceBufferImplementation } from './sequenceBuffer.js';
+import { stringInputCompanion } from './inputCompanion.js';
+test('sequenceBuffer', t => {
+    const sequenceBuffer = new SequenceBufferImplementation(stringInputCompanion);
+    t.is(sequenceBuffer.peek(0), undefined);
+    sequenceBuffer.push('');
+    t.is(sequenceBuffer.peek(0), undefined);
+    sequenceBuffer.push('abc');
+    t.is(sequenceBuffer.peek(0), 'a');
+    t.is(sequenceBuffer.peek(1), 'b');
+    t.is(sequenceBuffer.peek(2), 'c');
+    t.is(sequenceBuffer.peek(3), undefined);
+    sequenceBuffer.push('def');
+    t.is(sequenceBuffer.peek(0), 'a');
+    t.is(sequenceBuffer.peek(3), 'd');
+    t.is(sequenceBuffer.peek(6), undefined);
+    sequenceBuffer.push('');
+    t.is(sequenceBuffer.peek(0), 'a');
+    t.is(sequenceBuffer.peek(3), 'd');
+    t.is(sequenceBuffer.peek(6), undefined);
+    sequenceBuffer.skip(1);
+    t.is(sequenceBuffer.peek(0), 'b');
+    t.is(sequenceBuffer.peek(3), 'e');
+    t.is(sequenceBuffer.peek(5), undefined);
+    sequenceBuffer.skip(3);
+    t.is(sequenceBuffer.peek(0), 'e');
+    t.is(sequenceBuffer.peek(2), undefined);
+    sequenceBuffer.push('gh');
+    t.is(sequenceBuffer.peek(0), 'e');
+    t.is(sequenceBuffer.peek(2), 'g');
+    t.is(sequenceBuffer.peek(3), 'h');
+    t.is(sequenceBuffer.peek(4), undefined);
+});

package/build/inputCompanion.d.ts

@@ -0,0 +1,18 @@
+export type InputCompanion<Sequence, Element> = {
+    is(value: unknown): value is Sequence;
+    from(elements: Element[]): Sequence;
+    length(sequence: Sequence): number;
+    at(sequence: Sequence, index: number): Element | undefined;
+};
+export declare const stringInputCompanion: {
+    is(value: unknown): value is string;
+    from(elements: string[]): string;
+    length(sequence: string): number;
+    at(sequence: string, index: number): string | undefined;
+};
+export declare const uint8ArrayInputCompanion: {
+    is(value: unknown): value is Uint8Array;
+    from(elements: number[]): Uint8Array;
+    length(sequence: Uint8Array): number;
+    at(sequence: Uint8Array, index: number): number | undefined;
+};