@futpib/parser 1.0.0 → 1.0.2

package/build/inputReader.test.js

@@ -1,9 +1,10 @@
 import test from 'ava';
 import { InputReaderImplementation } from './inputReader.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { ParserImplementationError } from './parserError.js';
+import { toAsyncIterable } from './toAsyncIterable.js';
 test('inputReader', async (t) => {
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield '';
         yield 'abc';
         yield 'def';
@@ -31,8 +32,41 @@ test('inputReader', async (t) => {
     inputReader.skip(1);
     t.is(await inputReader.peek(0), undefined);
 });
+test('inputReader peekSequence', async (t) => {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
+        yield '';
+        yield 'abc';
+        yield 'def';
+        yield '';
+        yield 'gh';
+    })());
+    t.is(await inputReader.peekSequence(0, 0), '');
+    t.is(await inputReader.peekSequence(0, 1), 'a');
+    inputReader.skip(0);
+    t.is(await inputReader.peekSequence(1, 2), 'b');
+    inputReader.skip(1);
+    t.is(await inputReader.peekSequence(1, 7), 'bcdefgh'.slice(1, 7));
+    t.is(await inputReader.peekSequence(1, 8), undefined);
+    inputReader.skip(6);
+    t.is(await inputReader.peekSequence(0, 0), '');
+    t.is(await inputReader.peekSequence(0, 1), 'h');
+    t.is(await inputReader.peekSequence(1, 2), undefined);
+    t.is(await inputReader.peekSequence(2, 2), undefined);
+    inputReader.skip(1);
+    t.is(await inputReader.peekSequence(0, 0), '');
+    t.is(await inputReader.peekSequence(0, 1), undefined);
+    t.is(await inputReader.peekSequence(1, 1), undefined);
+    inputReader.skip(0);
+    t.is(await inputReader.peekSequence(0, 0), '');
+    t.is(await inputReader.peekSequence(0, 1), undefined);
+    t.is(await inputReader.peekSequence(1, 1), undefined);
+    inputReader.skip(1);
+    t.is(await inputReader.peekSequence(0, 0), undefined);
+    t.is(await inputReader.peekSequence(0, 1), undefined);
+    t.is(await inputReader.peekSequence(1, 1), undefined);
+});
 test('inputReader.peek concurrent', async (t) => {
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })());
     const peeks = await Promise.all([
@@ -50,18 +84,88 @@ test('inputReader.peek concurrent', async (t) => {
     ]);
     t.deepEqual(peeks, ['a', 'a', 'a', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']);
 });
+test('inputReader.peekSequence concurrent', async (t) => {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
+        yield* 'abcdefgh';
+    })());
+    const peeks = await Promise.all([1, 2, 3].flatMap(length => [
+        inputReader.peekSequence(0, 0 + length),
+        inputReader.peekSequence(0, 0 + length),
+        inputReader.peekSequence(0, 0 + length),
+        inputReader.peekSequence(0, 0 + length),
+        inputReader.peekSequence(1, 1 + length),
+        inputReader.peekSequence(2, 2 + length),
+        inputReader.peekSequence(3, 3 + length),
+        inputReader.peekSequence(4, 4 + length),
+        inputReader.peekSequence(5, 5 + length),
+        inputReader.peekSequence(6, 6 + length),
+        inputReader.peekSequence(7, 7 + length),
+    ]));
+    t.deepEqual(peeks, [
+        'a',
+        'a',
+        'a',
+        'a',
+        'b',
+        'c',
+        'd',
+        'e',
+        'f',
+        'g',
+        'h',
+        'ab',
+        'ab',
+        'ab',
+        'ab',
+        'bc',
+        'cd',
+        'de',
+        'ef',
+        'fg',
+        'gh',
+        undefined,
+        'abc',
+        'abc',
+        'abc',
+        'abc',
+        'bcd',
+        'cde',
+        'def',
+        'efg',
+        'fgh',
+        undefined,
+        undefined,
+    ]);
+});
 test('inputReader skip while peeking', async (t) => {
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })());
     const peekPromise = inputReader.peek(0);
     inputReader.skip(1);
+    const peekAfterSkipPromise = inputReader.peek(0);
+    const peekSequenceAfterSkipPromise = inputReader.peekSequence(0, 5);
     t.is(await peekPromise, 'a');
     t.is(await inputReader.peek(0), 'b');
+    t.is(await peekAfterSkipPromise, 'b');
+    t.is(await peekSequenceAfterSkipPromise, 'bcdef');
+});
+test('inputReader skip while peeking sequence', async (t) => {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
+        yield* 'abcdefgh';
+    })());
+    const peekPromise = inputReader.peekSequence(1, 5);
+    inputReader.skip(1);
+    const peekAfterSkipPromise = inputReader.peek(0);
+    const peekSequenceAfterSkipPromise = inputReader.peekSequence(0, 4);
+    t.is(await peekPromise, 'bcde', 'peekPromise');
+    t.is(await inputReader.peekSequence(0, 4), 'bcde', 'inputReader.peekSequence(0, 4)');
+    t.is(await peekAfterSkipPromise, 'b', 'peekAfterSkipPromise');
+    t.is(await peekSequenceAfterSkipPromise, 'bcde', 'peekSequenceAfterSkipPromise');
 });
 test('inputReader.lookahead', async (t) => {
     let read = 0;
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         for (const character of 'abcdefgh') {
             read++;
             yield character;
@@ -129,7 +233,7 @@ test('inputReader.lookahead', async (t) => {
 });
 test('inputReader.lookahead concurrent', async (t) => {
     let read = 0;
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         for (const character of 'abcdefgh') {
             read++;
             yield character;
@@ -154,7 +258,7 @@ test('inputReader.lookahead concurrent', async (t) => {
 });
 test('inputReader.lookahead skip position', async (t) => {
     let read = 0;
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         for (const character of 'abcdefgh') {
             read++;
             yield character;
@@ -172,3 +276,64 @@ test('inputReader.lookahead skip position', async (t) => {
     t.is(await lookahead.peek(0), 'c');
     t.is(await lookahead1.peek(0), 'd');
 });
+const END_OF_CONSUMED_SEQUENCES = Symbol('END_OF_CONSUMED_SEQUENCES');
+const END_OF_BUFFERED_SEQUENCES = Symbol('END_OF_BUFFERED_SEQUENCES');
+async function inputReaderStateToArray({ unconsumedBufferedSequences, consumedBufferedSequences, unbufferedSequences, }) {
+    const unconsumedBufferedSequencesArray = unconsumedBufferedSequences.slice();
+    const consumedBufferedSequencesArray = consumedBufferedSequences.slice();
+    const unbufferedSequencesArray = [];
+    if (unbufferedSequences) {
+        for await (const sequence of toAsyncIterable(unbufferedSequences)) {
+            unbufferedSequencesArray.push(sequence);
+        }
+    }
+    return [
+        ...consumedBufferedSequencesArray,
+        END_OF_CONSUMED_SEQUENCES,
+        ...unconsumedBufferedSequencesArray,
+        END_OF_BUFFERED_SEQUENCES,
+        ...unbufferedSequencesArray,
+    ];
+}
+for (const [input, position, expected,] of [
+    [
+        ['', 'abc', 'def', '', 'gh'],
+        0,
+        [END_OF_CONSUMED_SEQUENCES, 'abc', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh'],
+    ],
+    [
+        ['', 'abc', 'def', '', 'gh'],
+        1,
+        ['a', END_OF_CONSUMED_SEQUENCES, 'bc', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh'],
+    ],
+    [
+        ['', 'abc', 'def', '', 'gh'],
+        2,
+        ['ab', END_OF_CONSUMED_SEQUENCES, 'c', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh'],
+    ],
+    [
+        ['', 'abc', 'def', '', 'gh'],
+        3,
+        [END_OF_CONSUMED_SEQUENCES, 'def', END_OF_BUFFERED_SEQUENCES, '', 'gh'],
+    ],
+    [
+        ['', 'abc', 'def', '', 'gh'],
+        4,
+        ['d', END_OF_CONSUMED_SEQUENCES, 'ef', END_OF_BUFFERED_SEQUENCES, '', 'gh'],
+    ],
+    [
+        ['', 'abc', 'def', '', 'gh'],
+        8,
+        [END_OF_CONSUMED_SEQUENCES, END_OF_BUFFERED_SEQUENCES],
+    ],
+]) {
+    test('inputReader.toInputReaderState ' + JSON.stringify({ input, position }), async (t) => {
+        const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
+            yield* input;
+        })());
+        inputReader.skip(position);
+        await inputReader.peek(0);
+        const actual = await inputReaderStateToArray(inputReader.toInputReaderState());
+        t.deepEqual(actual, expected);
+    });
+}

package/build/inputReaderState.d.ts

@@ -0,0 +1,10 @@
+export type InputReaderState<Sequence> = {
+    position: number;
+    consumedBufferedSequences: Sequence[];
+    unconsumedBufferedSequences: Sequence[];
+    unbufferedSequences: undefined | AsyncIterator<Sequence>;
+};
+export declare const inputReaderStateCompanion: {
+    isDone<Sequence>({ unconsumedBufferedSequences, unbufferedSequences, }: InputReaderState<Sequence>): boolean;
+    toRemainingInputAsyncIterator<Sequence>({ unconsumedBufferedSequences, unbufferedSequences, }: InputReaderState<Sequence>): AsyncIterable<Sequence>;
+};

package/build/inputReaderState.js

@@ -0,0 +1,16 @@
+export const inputReaderStateCompanion = {
+    isDone({ unconsumedBufferedSequences, unbufferedSequences, }) {
+        return (unconsumedBufferedSequences.length === 0
+            && unbufferedSequences === undefined);
+    },
+    async *toRemainingInputAsyncIterator({ unconsumedBufferedSequences, unbufferedSequences, }) {
+        yield* unconsumedBufferedSequences;
+        if (unbufferedSequences !== undefined) {
+            yield* {
+                [Symbol.asyncIterator]() {
+                    return unbufferedSequences;
+                },
+            };
+        }
+    },
+};

package/build/inspect.d.ts

@@ -0,0 +1 @@
+export declare const inspect: (value: unknown) => string;

package/build/inspect.js

@@ -0,0 +1,7 @@
+import { inspect as nodeInspect } from 'node:util';
+export const inspect = (value) => {
+    if (value instanceof Uint8Array) {
+        value = Buffer.from(value);
+    }
+    return nodeInspect(value);
+};

package/build/javaKeyStoreParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const javaKeyStoreParser: Parser<unknown, Uint8Array>;

package/build/javaKeyStoreParser.js

@@ -0,0 +1,67 @@
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { setParserName } from './parser.js';
+import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createQuantifierParser } from './quantifierParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createUnionParser } from './unionParser.js';
+// https://github.com/openjdk/jdk/blob/c517ffba7d9388e75b5d7bba77e565e71c0a7d76/src/java.base/share/classes/com/sun/crypto/provider/JceKeyStore.java#L512-L553
+const uint64BEParser = promiseCompose(createFixedLengthSequenceParser(8), array => Buffer.from(array).readBigUInt64BE());
+setParserName(uint64BEParser, 'uint64BEParser');
+const uint32BEParser = promiseCompose(createFixedLengthSequenceParser(4), array => Buffer.from(array).readUInt32BE());
+setParserName(uint32BEParser, 'uint32BEParser');
+const uint16BEParser = promiseCompose(createFixedLengthSequenceParser(2), array => Buffer.from(array).readUInt16BE());
+setParserName(uint16BEParser, 'uint16BEParser');
+const createUint32BECountPrefixedParser = (elementParser) => parserCreatorCompose(() => uint32BEParser, count => createQuantifierParser(elementParser, count))();
+const javaModifiedUTF8StringParser = promiseCompose(parserCreatorCompose(() => uint16BEParser, length => createFixedLengthSequenceParser(length))(), uint8Array => Buffer.from(uint8Array).toString('utf8'));
+const uint32LengthPrefixedUint8ArrayParser = parserCreatorCompose(() => uint32BEParser, length => createFixedLengthSequenceParser(length))();
+const javaKeyStoreImplementationParser = promiseCompose(createUnionParser([
+    createExactSequenceParser(Buffer.from('feedfeed', 'hex')),
+    createExactSequenceParser(Buffer.from('cececece', 'hex')),
+]), uint8Array => uint8Array[0] === 0xFE ? 'JKS' : 'JCEKS');
+const javaKeyStorePrivateKeyEntryPrivateKeyParser = uint32LengthPrefixedUint8ArrayParser;
+const javaKeyStorePrivateKeyEntryCertificateParser = promiseCompose(createTupleParser([
+    javaModifiedUTF8StringParser,
+    uint32LengthPrefixedUint8ArrayParser,
+]), ([type, certificate]) => ({ type, certificate }));
+const javaKeyStorePrivateKeyEntryCertificateChainParser = createUint32BECountPrefixedParser(javaKeyStorePrivateKeyEntryCertificateParser);
+const javaKeyStorePrivateKeyEntryParser = promiseCompose(createTupleParser([
+    createExactSequenceParser(Buffer.from('00000001', 'hex')),
+    javaModifiedUTF8StringParser,
+    uint64BEParser,
+    javaKeyStorePrivateKeyEntryPrivateKeyParser,
+    javaKeyStorePrivateKeyEntryCertificateChainParser,
+]), ([_tag, alias, creationDate, privateKey, certificateChain,]) => ({
+    type: 'privateKey',
+    alias,
+    creationDate: new Date(Number(creationDate)),
+    privateKey,
+    certificateChain,
+}));
+const javaKeyStoreTrustedCertEntryParser = createTupleParser([
+    createExactSequenceParser(Buffer.from('00000002', 'hex')),
+    async (parserContext) => parserContext.invariant(false, 'Not implemented'),
+]);
+const javaKeyStoreSecretKeyEntryParser = createTupleParser([
+    createExactSequenceParser(Buffer.from('00000003', 'hex')),
+    async (parserContext) => parserContext.invariant(false, 'Not implemented'),
+]);
+const javaKeyStoreEntryParser = createUnionParser([
+    javaKeyStorePrivateKeyEntryParser,
+    javaKeyStoreTrustedCertEntryParser,
+    javaKeyStoreSecretKeyEntryParser,
+]);
+const javaKeyStoreEntriesParser = createUint32BECountPrefixedParser(javaKeyStoreEntryParser);
+const javaKeyStoreParser_ = createTupleParser([
+    javaKeyStoreImplementationParser,
+    uint32BEParser,
+    javaKeyStoreEntriesParser,
+    createFixedLengthSequenceParser(20),
+]);
+export const javaKeyStoreParser = promiseCompose(javaKeyStoreParser_, ([implementation, version, entries, hash,]) => ({
+    implementation,
+    version,
+    entries,
+    hash,
+}));

package/build/javaKeyStoreParser.test.d.ts

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

package/build/javaKeyStoreParser.test.js

@@ -0,0 +1,16 @@
+import test from 'ava';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { javaKeyStoreParser } from './javaKeyStoreParser.js';
+import { fetchCid } from './fetchCid.js';
+for (const javaKeyStoreCid of [
+    'bafkreig6k53b6p7bdvfjxc5mcb4qv3mffqls5ymqerxkqd6ih2xy5cs3n4',
+]) {
+    test('javaKeyStore ' + javaKeyStoreCid, async (t) => {
+        const javaKeyStoreStream = await fetchCid(javaKeyStoreCid);
+        const actual = await runParser(javaKeyStoreParser, javaKeyStoreStream, uint8ArrayParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        t.snapshot(actual);
+    });
+}

package/build/jsonParser.d.ts

@@ -1,3 +1,5 @@
 import { type JsonValue } from 'type-fest';
 import { type Parser } from './parser.js';
+export declare const jsonStringParser: Parser<string, string>;
+export declare const jsonNumberParser: Parser<number, string>;
 export declare const jsonValueParser: Parser<JsonValue, string>;

package/build/jsonParser.js

@@ -10,6 +10,7 @@ import { createArrayParser } from './arrayParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
 import { createElementParser } from './elementParser.js';
 import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { createSeparatedArrayParser } from './separatedArrayParser.js';
 const whitespaceParser = createArrayParser(createUnionParser([
     createExactSequenceParser(' '),
     createExactSequenceParser('\t'),
@@ -47,11 +48,11 @@ const jsonStringCharacterParser = createDisjunctionParser([
         return character;
     })(),
 ]);
-const jsonStringParser = promiseCompose(createTupleParser([
+export const jsonStringParser = promiseCompose(createTupleParser([
     createExactSequenceParser('"'),
     promiseCompose(createTerminatedArrayParser(jsonStringCharacterParser, createExactSequenceParser('"')), ([characters]) => characters.join('')),
 ]), ([, string]) => string);
-const jsonNumberParser = parserCreatorCompose(() => createArrayParser(parserCreatorCompose(() => elementParser, (character) => async (parserContext) => {
+export const jsonNumberParser = parserCreatorCompose(() => createArrayParser(parserCreatorCompose(() => elementParser, character => async (parserContext) => {
     parserContext.invariant((character === '-'
         || (character >= '0' && character <= '9')
         || character === '.'
@@ -59,7 +60,7 @@ const jsonNumberParser = parserCreatorCompose(() => createArrayParser(parserCrea
         || character === 'E'
         || character === '+'), 'Expected "-", "0" to "9", ".", "e", "E", "+", got "%s"', character);
     return character;
-})()), (characters) => async (parserContext) => {
+})()), characters => async (parserContext) => {
     parserContext.invariant(characters.length > 0, 'Expected at least one character');
     return Number(characters.join(''));
 })();
@@ -67,6 +68,7 @@ const jsonTrueParser = promiseCompose(createExactSequenceParser('true'), () => t
 setParserName(jsonTrueParser, 'jsonTrueParser');
 const jsonFalseParser = promiseCompose(createExactSequenceParser('false'), () => false);
 setParserName(jsonFalseParser, 'jsonFalseParser');
+// eslint-disable-next-line @typescript-eslint/ban-types
 const jsonNullParser = promiseCompose(createExactSequenceParser('null'), () => null);
 setParserName(jsonNullParser, 'jsonNullParser');
 const jsonPrimitiveParser = createUnionParser([
@@ -112,18 +114,14 @@ const jsonObjectParser = promiseCompose(createTupleParser([
 const jsonArrayParser = promiseCompose(createTupleParser([
     createExactSequenceParser('['),
     whitespaceParser,
-    promiseCompose(createTerminatedArrayParser(createDisjunctionParser([
-        promiseCompose(createTupleParser([
-            createParserAccessorParser(() => jsonValueParser),
-            whitespaceParser,
-            createExactSequenceParser(','),
-            whitespaceParser,
-        ]), ([value]) => value),
-        promiseCompose(createTupleParser([
-            createParserAccessorParser(() => jsonValueParser),
-            whitespaceParser,
-        ]), ([value]) => value),
-    ]), createExactSequenceParser(']')), ([values]) => values),
+    createSeparatedArrayParser(createParserAccessorParser(() => jsonValueParser), createTupleParser([
+        whitespaceParser,
+        createExactSequenceParser(','),
+        whitespaceParser,
+    ])),
+    whitespaceParser,
+    createExactSequenceParser(']'),
+    whitespaceParser,
 ]), ([_bracket, _whitespace, values]) => values);
 export const jsonValueParser = createUnionParser([
     jsonObjectParser,

package/build/jsonParser.test.js

@@ -2,12 +2,12 @@ import { testProp, fc } from '@fast-check/ava';
 import { jsonValueParser } from './jsonParser.js';
 import { runParser } from './parser.js';
 import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 testProp('json', [
     arbitrarilySlicedAsyncIterator(fc.tuple(fc.json(), fc.nat())
         .map(([jsonString, indent]) => JSON.stringify(JSON.parse(jsonString), null, indent))),
 ], async (t, [jsonString, jsonStringChunkIterator]) => {
-    const actual = await runParser(jsonValueParser, jsonStringChunkIterator, stringInputCompanion, {
+    const actual = await runParser(jsonValueParser, jsonStringChunkIterator, stringParserInputCompanion, {
         errorJoinMode: 'none',
     });
     const expected = JSON.parse(jsonString);

package/build/leb128Parser.d.ts

@@ -0,0 +1,7 @@
+import { Parser } from "./parser.js";
+export declare const uleb128Parser: Parser<bigint, Uint8Array>;
+export declare const sleb128Parser: Parser<bigint, Uint8Array>;
+export declare const uleb128NumberParser: Parser<number, Uint8Array>;
+export declare const sleb128NumberParser: Parser<number, Uint8Array>;
+export declare const uleb128UnsafeNumberParser: Parser<number, Uint8Array>;
+export declare const sleb128UnsafeNumberParser: Parser<number, Uint8Array>;

package/build/leb128Parser.js

@@ -0,0 +1,82 @@
+export const uleb128Parser = async (parserContext) => {
+    let leastSignificantValueBitIndex = 0n;
+    let value = 0n;
+    while (true) {
+        const byte = await parserContext.read(0);
+        const byteValue = BigInt(byte & 0b01111111);
+        const byteNotLast = BigInt(byte & 0b10000000);
+        value |= byteValue << leastSignificantValueBitIndex;
+        if (byteNotLast) {
+            leastSignificantValueBitIndex += 7n;
+            continue;
+        }
+        break;
+    }
+    return value;
+};
+export const sleb128Parser = async (parserContext) => {
+    let value = 0n;
+    let leastSignificantValueBitIndex = 0n;
+    while (true) {
+        const byte = await parserContext.read(0);
+        const byteValue = BigInt(byte & 0b01111111);
+        const byteNotLast = BigInt(byte & 0b10000000);
+        value |= byteValue << leastSignificantValueBitIndex;
+        leastSignificantValueBitIndex += 7n;
+        if (byteNotLast) {
+            continue;
+        }
+        const mostSignificantInputBit = byte & 0b01000000;
+        if (mostSignificantInputBit) {
+            value |= (~0n << leastSignificantValueBitIndex);
+        }
+        break;
+    }
+    return value;
+};
+export const uleb128NumberParser = async (parserContext) => {
+    const value = await uleb128Parser(parserContext);
+    parserContext.invariant(Number(value) <= Number.MAX_SAFE_INTEGER, 'Value is too large to be represented as a number: %s', value);
+    return Number(value);
+};
+export const sleb128NumberParser = async (parserContext) => {
+    const value = await sleb128Parser(parserContext);
+    parserContext.invariant(Number(value) >= Number.MIN_SAFE_INTEGER && Number(value) <= Number.MAX_SAFE_INTEGER, 'Value is too large to be represented as a number: %s', value);
+    return Number(value);
+};
+export const uleb128UnsafeNumberParser = async (parserContext) => {
+    let leastSignificantValueBitIndex = 0;
+    let value = 0;
+    while (true) {
+        const byte = await parserContext.read(0);
+        const byteValue = byte & 0b01111111;
+        const byteNotLast = byte & 0b10000000;
+        value |= byteValue << leastSignificantValueBitIndex;
+        if (byteNotLast) {
+            leastSignificantValueBitIndex += 7;
+            continue;
+        }
+        break;
+    }
+    return value;
+};
+export const sleb128UnsafeNumberParser = async (parserContext) => {
+    let value = 0;
+    let leastSignificantValueBitIndex = 0;
+    while (true) {
+        const byte = await parserContext.read(0);
+        const byteValue = byte & 0b01111111;
+        const byteNotLast = byte & 0b10000000;
+        value |= byteValue << leastSignificantValueBitIndex;
+        leastSignificantValueBitIndex += 7;
+        if (byteNotLast) {
+            continue;
+        }
+        const mostSignificantInputBit = byte & 0b01000000;
+        if (leastSignificantValueBitIndex < 32 && mostSignificantInputBit) {
+            value |= (~0 << leastSignificantValueBitIndex);
+        }
+        break;
+    }
+    return value;
+};

package/build/leb128Parser.test.d.ts

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

package/build/leb128Parser.test.js

@@ -0,0 +1,107 @@
+import { testProp, fc } from '@fast-check/ava';
+import test from 'ava';
+// @ts-expect-error
+import leb128 from 'leb128';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { uleb128Parser, sleb128Parser, uleb128NumberParser, sleb128NumberParser } from './leb128Parser.js';
+test('sleb128, uleb128, uleb128p1', async (t) => {
+    for (const [input, expectedSleb128, expectedUleb128,] of [
+        [Buffer.from('00', 'hex'), 0n, 0n],
+        [Buffer.from('01', 'hex'), 1n, 1n],
+        [Buffer.from('7f', 'hex'), -1n, 127n],
+        [Buffer.from('807f', 'hex'), -128n, 16256n],
+    ]) {
+        const actualSleb128 = await runParser(sleb128Parser, input, uint8ArrayParserInputCompanion);
+        const actualUleb128 = await runParser(uleb128Parser, input, uint8ArrayParserInputCompanion);
+        t.is(actualSleb128, expectedSleb128, 'sleb128');
+        t.is(actualUleb128, expectedUleb128, 'uleb128');
+    }
+    for (const [input, expectedUleb128,] of [
+        [new Uint8Array([2]), 2n],
+        [new Uint8Array([127]), 127n],
+        [new Uint8Array([0 + 0x80, 1]), 128n],
+        [new Uint8Array([1 + 0x80, 1]), 129n],
+        [new Uint8Array([57 + 0x80, 100]), 12857n],
+    ]) {
+        const actualUleb128 = await runParser(uleb128Parser, input, uint8ArrayParserInputCompanion);
+        t.is(actualUleb128, expectedUleb128, 'uleb128');
+    }
+    for (const [input, expectedSleb128,] of [
+        [new Uint8Array([2]), 2n],
+        [new Uint8Array([0x7e]), -2n],
+        [new Uint8Array([127 + 0x80, 0]), 127n],
+        [new Uint8Array([1 + 0x80, 0x7f]), -127n],
+        [new Uint8Array([0 + 0x80, 1]), 128n],
+        [new Uint8Array([0 + 0x80, 0x7f]), -128n],
+        [new Uint8Array([1 + 0x80, 1]), 129n],
+        [new Uint8Array([0x7f + 0x80, 0x7e]), -129n],
+    ]) {
+        const actualSleb128 = await runParser(sleb128Parser, input, uint8ArrayParserInputCompanion);
+        t.is(actualSleb128, expectedSleb128, 'sleb128');
+    }
+});
+testProp('uleb128NumberParser on small number', [
+    fc.nat(),
+], async (t, natural) => {
+    const uleb128 = leb128.unsigned.encode(natural);
+    const actualUleb128 = await runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion);
+    t.is(actualUleb128, natural, 'uleb128');
+}, {
+    verbose: true,
+});
+testProp('sleb128NumberParser on small number', [
+    fc.integer(),
+], async (t, integer) => {
+    const sleb128 = leb128.signed.encode(integer);
+    const actualSleb128 = await runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion);
+    t.is(actualSleb128, integer, 'sleb128');
+}, {
+    verbose: true,
+});
+// TODO?
+testProp.skip('uleb128NumberParser on large number', [
+    fc.maxSafeNat(),
+], async (t, natural) => {
+    const uleb128 = leb128.unsigned.encode(natural);
+    if (natural > (2 ** 32) - 1) {
+        await t.throwsAsync(() => runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion));
+        return;
+    }
+    const actualUleb128 = await runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion);
+    t.is(actualUleb128, natural, 'uleb128');
+}, {
+    verbose: true,
+});
+// TODO?
+testProp.skip('sleb128NumberParser on large number', [
+    fc.maxSafeInteger(),
+], async (t, integer) => {
+    const sleb128 = leb128.signed.encode(integer);
+    if (integer > (2 ** 32) - 1 || integer < -(2 ** 32)) {
+        await t.throwsAsync(() => runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion));
+        return;
+    }
+    const actualSleb128 = await runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion);
+    t.is(actualSleb128, integer, 'sleb128');
+}, {
+    verbose: true,
+});
+testProp('uleb128Parser on bigint', [
+    fc.bigInt({ min: 0n }),
+], async (t, bigInt) => {
+    const uleb128 = leb128.unsigned.encode(bigInt);
+    const actualUleb128 = await runParser(uleb128Parser, uleb128, uint8ArrayParserInputCompanion);
+    t.is(actualUleb128, bigInt, 'uleb128');
+}, {
+    verbose: true,
+});
+testProp('sleb128Parser on bigint', [
+    fc.bigInt(),
+], async (t, bigInt) => {
+    const sleb128 = leb128.signed.encode(bigInt);
+    const actualSleb128 = await runParser(sleb128Parser, sleb128, uint8ArrayParserInputCompanion);
+    t.is(actualSleb128, bigInt, 'sleb128');
+}, {
+    verbose: true,
+});

package/build/listParser.d.ts

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