@futpib/parser 1.0.1 → 1.0.3

package/build/inputReader.test.js

@@ -1,7 +1,7 @@
 import test from 'ava';
 import { InputReaderImplementation } from './inputReader.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
-import { ParserImplementationError } from './parserError.js';
+import { toAsyncIterable } from './toAsyncIterable.js';
 test('inputReader', async (t) => {
     const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield '';
@@ -31,6 +31,39 @@ 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(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
@@ -50,14 +83,84 @@ 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(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;
@@ -84,10 +187,15 @@ test('inputReader.lookahead', async (t) => {
     t.is(read, 2);
     inputReader.skip(1);
     await t.throwsAsync(async () => lookahead0a.peek(0), {
-        instanceOf: ParserImplementationError,
+        any: true,
+        name: 'ParserImplementationInvariantError',
+    });
+    await t.throwsAsync(async () => lookahead0b.peek(0), {
+        any: true,
+    });
+    await t.throwsAsync(async () => lookahead0c.peek(0), {
+        any: true,
     });
-    await t.throwsAsync(async () => lookahead0b.peek(0));
-    await t.throwsAsync(async () => lookahead0c.peek(0));
     const lookahead1a = inputReader.lookahead();
     const lookahead1b = inputReader.lookahead();
     t.is(await lookahead1a.peek(0), 'b');
@@ -112,11 +220,19 @@ test('inputReader.lookahead', async (t) => {
     inputReader.skip(1);
     t.is(await inputReader.peek(0), 'c');
     t.is(inputReader.position, 2);
-    await t.throwsAsync(async () => lookahead0a.peek(0));
-    await t.throwsAsync(async () => lookahead0b.peek(0));
-    await t.throwsAsync(async () => lookahead0c.peek(0));
+    await t.throwsAsync(async () => lookahead0a.peek(0), {
+        any: true,
+    });
+    await t.throwsAsync(async () => lookahead0b.peek(0), {
+        any: true,
+    });
+    await t.throwsAsync(async () => lookahead0c.peek(0), {
+        any: true,
+    });
     t.is(await lookahead1a.peek(0), 'c');
-    await t.throwsAsync(async () => lookahead1b.peek(0));
+    await t.throwsAsync(async () => lookahead1b.peek(0), {
+        any: true,
+    });
     t.is(await lookahead2a.peek(0), 'd');
     t.is(await lookahead2b.peek(0), 'c');
     t.is(lookahead0a.position, 0);
@@ -172,3 +288,40 @@ 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];
+    const consumedBufferedSequencesArray = [...consumedBufferedSequences];
+    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,
+    ];
+}
+const inputReaderStateMacro = test.macro({
+    title: (providedTitle, input, position) => providedTitle ?? `inputReader.toInputReaderState ${JSON.stringify({ input, position })}`,
+    async exec(t, input, position, expected) {
+        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);
+    },
+});
+test(inputReaderStateMacro, ['', 'abc', 'def', '', 'gh'], 0, [END_OF_CONSUMED_SEQUENCES, 'abc', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh']);
+test(inputReaderStateMacro, ['', 'abc', 'def', '', 'gh'], 1, ['a', END_OF_CONSUMED_SEQUENCES, 'bc', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh']);
+test(inputReaderStateMacro, ['', 'abc', 'def', '', 'gh'], 2, ['ab', END_OF_CONSUMED_SEQUENCES, 'c', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh']);
+test(inputReaderStateMacro, ['', 'abc', 'def', '', 'gh'], 3, [END_OF_CONSUMED_SEQUENCES, 'def', END_OF_BUFFERED_SEQUENCES, '', 'gh']);
+test(inputReaderStateMacro, ['', 'abc', 'def', '', 'gh'], 4, ['d', END_OF_CONSUMED_SEQUENCES, 'ef', END_OF_BUFFERED_SEQUENCES, '', 'gh']);
+test(inputReaderStateMacro, ['', 'abc', 'def', '', 'gh'], 8, [END_OF_CONSUMED_SEQUENCES, END_OF_BUFFERED_SEQUENCES]);

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.test.js

@@ -2,15 +2,15 @@ import test from 'ava';
 import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { runParser } from './parser.js';
 import { javaKeyStoreParser } from './javaKeyStoreParser.js';
-for (const javaKeyStoreCid of [
-    'bafkreig6k53b6p7bdvfjxc5mcb4qv3mffqls5ymqerxkqd6ih2xy5cs3n4',
-]) {
-    test('javaKeyStore ' + javaKeyStoreCid, async (t) => {
-        const javaKeyStoreResponse = await fetch('https://ipfs.io/ipfs/' + javaKeyStoreCid);
-        const javaKeyStoreStream = javaKeyStoreResponse.body;
+import { fetchCid } from './fetchCid.js';
+const javaKeyStoreMacro = test.macro({
+    title: (providedTitle, javaKeyStoreCid) => providedTitle ?? `javaKeyStore ${javaKeyStoreCid}`,
+    async exec(t, javaKeyStoreCid) {
+        const javaKeyStoreStream = await fetchCid(javaKeyStoreCid);
         const actual = await runParser(javaKeyStoreParser, javaKeyStoreStream, uint8ArrayParserInputCompanion, {
             errorJoinMode: 'all',
         });
         t.snapshot(actual);
-    });
-}
+    },
+});
+test(javaKeyStoreMacro, 'bafkreig6k53b6p7bdvfjxc5mcb4qv3mffqls5ymqerxkqd6ih2xy5cs3n4');

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,22 +10,23 @@ 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'),
     createExactSequenceParser('\r'),
     createExactSequenceParser('\n'),
 ]));
-const jsonQuoteEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\"'), () => '"');
+const jsonQuoteEscapeSequenceParser = promiseCompose(createExactSequenceParser(String.raw `\"`), () => '"');
 const jsonBackslashEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\\\'), () => '\\');
-const jsonSlashEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\/'), () => '/');
-const jsonBackspaceEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\b'), () => '\b');
-const jsonFormFeedEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\f'), () => '\f');
-const jsonNewLineEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\n'), () => '\n');
-const jsonCarriageReturnEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\r'), () => '\r');
-const jsonTabEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\t'), () => '\t');
+const jsonSlashEscapeSequenceParser = promiseCompose(createExactSequenceParser(String.raw `\/`), () => '/');
+const jsonBackspaceEscapeSequenceParser = promiseCompose(createExactSequenceParser(String.raw `\b`), () => '\b');
+const jsonFormFeedEscapeSequenceParser = promiseCompose(createExactSequenceParser(String.raw `\f`), () => '\f');
+const jsonNewLineEscapeSequenceParser = promiseCompose(createExactSequenceParser(String.raw `\n`), () => '\n');
+const jsonCarriageReturnEscapeSequenceParser = promiseCompose(createExactSequenceParser(String.raw `\r`), () => '\r');
+const jsonTabEscapeSequenceParser = promiseCompose(createExactSequenceParser(String.raw `\t`), () => '\t');
 const jsonUnicodeEscapeSequenceParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('\\u'),
+    createExactSequenceParser(String.raw `\u`),
     createFixedLengthSequenceParser(4),
 ]), ([, hexCode]) => String.fromCharCode(Number.parseInt(hexCode, 16)));
 const jsonStringEscapeSequenceParser = createUnionParser([
@@ -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 === '.'
@@ -113,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/lazyMessageError.d.ts

@@ -0,0 +1,48 @@
+import { NoStackCaptureOverheadError } from "./noStackCaptureOverheadError.js";
+type ValueOrAccessor<T> = T | (() => T);
+export type LazyMessage = ValueOrAccessor<string | string[]> | [ValueOrAccessor<string | string[]>, ...Array<ValueOrAccessor<unknown>>];
+export declare function formatLazyMessage(lazyMessage: LazyMessage): string;
+export interface LazyMessageError extends Error {
+    computeMessage(): void;
+}
+export declare function createLazyMessageErrorClass(BaseError: typeof NoStackCaptureOverheadError | typeof Error): {
+    new (lazyMessage: LazyMessage): {
+        name: string;
+        _lazyMessage: undefined | LazyMessage;
+        computeMessage(): void;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const NormalLazyMessageError: {
+    new (lazyMessage: LazyMessage): {
+        name: string;
+        _lazyMessage: undefined | LazyMessage;
+        computeMessage(): void;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const NoStackCaptureOverheadLazyMessageError: {
+    new (lazyMessage: LazyMessage): {
+        name: string;
+        _lazyMessage: undefined | LazyMessage;
+        computeMessage(): void;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare function isLazyMessageError(value: unknown): value is LazyMessageError;
+export {};

package/build/lazyMessageError.js

@@ -0,0 +1,53 @@
+import { NoStackCaptureOverheadError } from "./noStackCaptureOverheadError.js";
+function formatLazyMessageFormat(format) {
+    if (typeof format === 'function') {
+        format = format();
+    }
+    if (Array.isArray(format)) {
+        return format.join('\n');
+    }
+    return format;
+}
+function formatLazyMessageSubstitutions(format, formatArguments) {
+    return format.replaceAll('%s', () => {
+        const argumentOrAccessor = formatArguments.shift();
+        return typeof argumentOrAccessor === 'function' ? argumentOrAccessor() : argumentOrAccessor;
+    });
+}
+export function formatLazyMessage(lazyMessage) {
+    if (Array.isArray(lazyMessage)) {
+        const [format, ...formatArguments] = lazyMessage;
+        const formattedFormat = formatLazyMessageFormat(format);
+        return formatLazyMessageSubstitutions(formattedFormat, formatArguments);
+    }
+    else {
+        return formatLazyMessageFormat(lazyMessage);
+    }
+}
+export function createLazyMessageErrorClass(BaseError) {
+    return class LazyMessageError extends BaseError {
+        name = 'LazyMessageError';
+        _lazyMessage;
+        constructor(lazyMessage) {
+            super('LAZY_MESSAGE');
+            this._lazyMessage = lazyMessage;
+        }
+        computeMessage() {
+            if (this._lazyMessage === undefined) {
+                return;
+            }
+            this.message = formatLazyMessage(this._lazyMessage);
+            this.stack = this.stack?.replace('LAZY_MESSAGE', this.message);
+            delete this._lazyMessage;
+        }
+    };
+}
+export const NormalLazyMessageError = createLazyMessageErrorClass(Error);
+export const NoStackCaptureOverheadLazyMessageError = createLazyMessageErrorClass(NoStackCaptureOverheadError);
+export function isLazyMessageError(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value instanceof Error
+        && '_lazyMessage' in value
+        && typeof value.computeMessage === 'function');
+}

package/build/lazyMessageError.test.d.ts

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

package/build/lazyMessageError.test.js

@@ -0,0 +1,15 @@
+import test from 'ava';
+import { NormalLazyMessageError } from './lazyMessageError.js';
+test('LazyMessageError works', t => {
+    const error = new NormalLazyMessageError([
+        () => [
+            'Line 1: %s',
+            'Line 2: %s and %s.',
+        ],
+        42,
+        () => 'foo',
+        true,
+    ]);
+    error.computeMessage();
+    t.is(error.message, 'Line 1: 42\nLine 2: foo and true.');
+});

package/build/leb128Parser.d.ts

@@ -0,0 +1,7 @@
+import { type 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 & 0b0111_1111);
+        const byteNotLast = BigInt(byte & 0b1000_0000);
+        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 & 0b0111_1111);
+        const byteNotLast = BigInt(byte & 0b1000_0000);
+        value |= byteValue << leastSignificantValueBitIndex;
+        leastSignificantValueBitIndex += 7n;
+        if (byteNotLast) {
+            continue;
+        }
+        const mostSignificantInputBit = byte & 0b0100_0000;
+        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 & 0b0111_1111;
+        const byteNotLast = byte & 0b1000_0000;
+        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 & 0b0111_1111;
+        const byteNotLast = byte & 0b1000_0000;
+        value |= byteValue << leastSignificantValueBitIndex;
+        leastSignificantValueBitIndex += 7;
+        if (byteNotLast) {
+            continue;
+        }
+        const mostSignificantInputBit = byte & 0b0100_0000;
+        if (leastSignificantValueBitIndex < 32 && mostSignificantInputBit) {
+            value |= (~0 << leastSignificantValueBitIndex);
+        }
+        break;
+    }
+    return value;
+};

package/build/leb128Parser.test.d.ts

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