@futpib/parser 1.0.2 → 1.0.4

package/build/fetchCid.test.js

@@ -0,0 +1,16 @@
+import test from 'ava';
+import { fetchCid } from './fetchCid.js';
+const cid = 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda';
+test('fetchCid', async (t) => {
+    await Promise.all([
+        fetchCid(cid),
+        fetchCid(cid),
+        fetchCid(cid),
+    ]);
+    await Promise.all([
+        fetchCid(cid),
+        fetchCid(cid),
+        fetchCid(cid),
+    ]);
+    t.pass();
+});

package/build/fixedLengthSequenceParser.test.js

@@ -29,9 +29,9 @@ testProp.serial('fixedLengthSequenceParser', [
             position: parserContext.position,
         };
     };
-    const { output: actualNaive } = await naiveTotalTimer.measureAsync(() => runParserWithRemainingInput(createTestWrapperParser(fixedLengthSequenceParserNaive), sequence, stringParserInputCompanion));
+    const { output: actualNaive } = await naiveTotalTimer.measureAsync(async () => runParserWithRemainingInput(createTestWrapperParser(fixedLengthSequenceParserNaive), sequence, stringParserInputCompanion));
     t.true(actualNaive.result.length === Number(length));
-    const { output: actual } = await totalTimer.measureAsync(() => runParserWithRemainingInput(createTestWrapperParser(fixedLengthSequenceParser), sequence, stringParserInputCompanion));
+    const { output: actual } = await totalTimer.measureAsync(async () => runParserWithRemainingInput(createTestWrapperParser(fixedLengthSequenceParser), sequence, stringParserInputCompanion));
     t.deepEqual(actual, actualNaive);
 }, {
     verbose: true,

package/build/hasExecutable.js

@@ -1,8 +1,8 @@
 import { execa } from 'execa';
 export async function hasExecutable(executable) {
-    const hasExecutable = execa(executable).then(() => true, () => false);
+    const hasExecutable = execa(executable).catch(() => false).then(() => true);
     if (!hasExecutable) {
-        console.warn(`Executable %o not found`, executable);
+        console.warn('Executable %o not found', executable);
     }
     return hasExecutable;
 }

package/build/highResolutionTimer.js

@@ -1,5 +1,5 @@
-import invariant from 'invariant';
 import process from 'node:process';
+import invariant from 'invariant';
 class HighResolutionSubTimer {
     _parent;
     _start;

package/build/index.d.ts

@@ -1,5 +1,11 @@
-export { type Parser, runParser, setParserName, getParserName, } from './parser.js';
+export { type Parser, runParser, runParserWithRemainingInput, setParserName, getParserName, cloneParser, type RunParserOptions, type RunParserWithRemainingInputResult, } from './parser.js';
 export type { ParserContext, } from './parserContext.js';
+export { type ParserInputCompanion, StringParserInputCompanion, stringParserInputCompanion, Uint8ArrayParserInputCompanion, uint8ArrayParserInputCompanion, } from './parserInputCompanion.js';
+export { type UnparserOutputCompanion, StringUnparserOutputCompanion, stringUnparserOutputCompanion, Uint8ArrayUnparserOutputCompanion, uint8ArrayUnparserOutputCompanion, } from './unparserOutputCompanion.js';
+export { type ParserError, type ParserParsingFailedError, type ParserParsingJoinError, type ParserErrorModule, isParserError, isParserParsingFailedError, isParserParsingJoinError, normalParserErrorModule, noStackCaptureOverheadParserErrorModule, } from './parserError.js';
+export { parserCreatorCompose, parserCreatorComposeMem, } from './parserCreatorCompose.js';
+export { promiseCompose, } from './promiseCompose.js';
+export type { DeriveSequenceElement, } from './sequence.js';
 export { createTupleParser, } from './tupleParser.js';
 export { createExactSequenceParser, } from './exactSequenceParser.js';
 export { createFixedLengthSequenceParser, } from './fixedLengthSequenceParser.js';
@@ -16,6 +22,22 @@ export { createSkipParser, } from './skipParser.js';
 export { createEndOfInputParser, } from './endOfInputParser.js';
 export { createListParser, } from './listParser.js';
 export { createDebugLogParser, } from './debugLogParser.js';
-export { type Unparser, runUnparser, } from './unparser.js';
+export { createNonEmptyArrayParser, } from './nonEmptyArrayParser.js';
+export { createSeparatedArrayParser, } from './separatedArrayParser.js';
+export { createSeparatedNonEmptyArrayParser, } from './separatedNonEmptyArrayParser.js';
+export { createLookaheadParser, } from './lookaheadParser.js';
+export { createNegativeLookaheadParser, } from './negativeLookaheadParser.js';
+export { createElementTerminatedSequenceParser, } from './elementTerminatedSequenceParser.js';
+export { createElementTerminatedSequenceArrayParser, } from './elementTerminatedSequenceArrayParser.js';
+export { createElementTerminatedArrayParserUnsafe, } from './elementTerminatedArrayParser.js';
+export { createSequenceTerminatedSequenceParser, } from './sequenceTerminatedSequenceParser.js';
+export { createQuantifierParser, } from './quantifierParser.js';
+export { createSkipToParser, } from './skipToParser.js';
+export { createDebugLogInputParser, } from './debugLogInputParser.js';
+export { createElementSwitchParser, } from './exactElementSwitchParser.js';
+export { createParserConsumedSequenceParser, } from './parserConsumedSequenceParser.js';
+export { type Unparser, type UnparserResult, runUnparser, } from './unparser.js';
+export { type UnparserContext, WriteLater, WriteEarlier, UnparserContextImplementation, } from './unparserContext.js';
 export { createArrayUnparser, } from './arrayUnparser.js';
 export { createSequenceUnparser, } from './sequenceUnparser.js';
+export { createRegExpParser, } from './regexpParser.js';

package/build/index.js

@@ -1,4 +1,9 @@
-export { runParser, setParserName, getParserName, } from './parser.js';
+export { runParser, runParserWithRemainingInput, setParserName, getParserName, cloneParser, } from './parser.js';
+export { StringParserInputCompanion, stringParserInputCompanion, Uint8ArrayParserInputCompanion, uint8ArrayParserInputCompanion, } from './parserInputCompanion.js';
+export { StringUnparserOutputCompanion, stringUnparserOutputCompanion, Uint8ArrayUnparserOutputCompanion, uint8ArrayUnparserOutputCompanion, } from './unparserOutputCompanion.js';
+export { isParserError, isParserParsingFailedError, isParserParsingJoinError, normalParserErrorModule, noStackCaptureOverheadParserErrorModule, } from './parserError.js';
+export { parserCreatorCompose, parserCreatorComposeMem, } from './parserCreatorCompose.js';
+export { promiseCompose, } from './promiseCompose.js';
 export { createTupleParser, } from './tupleParser.js';
 export { createExactSequenceParser, } from './exactSequenceParser.js';
 export { createFixedLengthSequenceParser, } from './fixedLengthSequenceParser.js';
@@ -15,6 +20,22 @@ export { createSkipParser, } from './skipParser.js';
 export { createEndOfInputParser, } from './endOfInputParser.js';
 export { createListParser, } from './listParser.js';
 export { createDebugLogParser, } from './debugLogParser.js';
+export { createNonEmptyArrayParser, } from './nonEmptyArrayParser.js';
+export { createSeparatedArrayParser, } from './separatedArrayParser.js';
+export { createSeparatedNonEmptyArrayParser, } from './separatedNonEmptyArrayParser.js';
+export { createLookaheadParser, } from './lookaheadParser.js';
+export { createNegativeLookaheadParser, } from './negativeLookaheadParser.js';
+export { createElementTerminatedSequenceParser, } from './elementTerminatedSequenceParser.js';
+export { createElementTerminatedSequenceArrayParser, } from './elementTerminatedSequenceArrayParser.js';
+export { createElementTerminatedArrayParserUnsafe, } from './elementTerminatedArrayParser.js';
+export { createSequenceTerminatedSequenceParser, } from './sequenceTerminatedSequenceParser.js';
+export { createQuantifierParser, } from './quantifierParser.js';
+export { createSkipToParser, } from './skipToParser.js';
+export { createDebugLogInputParser, } from './debugLogInputParser.js';
+export { createElementSwitchParser, } from './exactElementSwitchParser.js';
+export { createParserConsumedSequenceParser, } from './parserConsumedSequenceParser.js';
 export { runUnparser, } from './unparser.js';
+export { WriteLater, WriteEarlier, UnparserContextImplementation, } from './unparserContext.js';
 export { createArrayUnparser, } from './arrayUnparser.js';
 export { createSequenceUnparser, } from './sequenceUnparser.js';
+export { createRegExpParser, } from './regexpParser.js';

package/build/inputReader.d.ts

@@ -1,5 +1,5 @@
 import { type ParserInputCompanion } from './parserInputCompanion.js';
-import { InputReaderState } from './inputReaderState.js';
+import { type InputReaderState } from './inputReaderState.js';
 export type InputReader<Sequence, Element> = {
     get position(): number;
     peek(offset: number): Promise<Element | undefined>;

package/build/inputReader.test.js

@@ -1,7 +1,6 @@
 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* () {
@@ -188,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');
@@ -216,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);
@@ -279,8 +291,8 @@ test('inputReader.lookahead skip position', async (t) => {
 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 unconsumedBufferedSequencesArray = [...unconsumedBufferedSequences];
+    const consumedBufferedSequencesArray = [...consumedBufferedSequences];
     const unbufferedSequencesArray = [];
     if (unbufferedSequences) {
         for await (const sequence of toAsyncIterable(unbufferedSequences)) {
@@ -295,39 +307,9 @@ async function inputReaderStateToArray({ unconsumedBufferedSequences, consumedBu
         ...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 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;
         })());
@@ -335,5 +317,11 @@ for (const [input, position, expected,] of [
         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/javaKeyStoreParser.test.js

@@ -3,14 +3,14 @@ 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 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.js

@@ -17,16 +17,16 @@ const whitespaceParser = createArrayParser(createUnionParser([
     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([

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

@@ -1,4 +1,4 @@
-import { Parser } from "./parser.js";
+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>;

package/build/leb128Parser.js

@@ -3,8 +3,8 @@ export const uleb128Parser = async (parserContext) => {
     let value = 0n;
     while (true) {
         const byte = await parserContext.read(0);
-        const byteValue = BigInt(byte & 0b01111111);
-        const byteNotLast = BigInt(byte & 0b10000000);
+        const byteValue = BigInt(byte & 0b0111_1111);
+        const byteNotLast = BigInt(byte & 0b1000_0000);
         value |= byteValue << leastSignificantValueBitIndex;
         if (byteNotLast) {
             leastSignificantValueBitIndex += 7n;
@@ -19,14 +19,14 @@ export const sleb128Parser = async (parserContext) => {
     let leastSignificantValueBitIndex = 0n;
     while (true) {
         const byte = await parserContext.read(0);
-        const byteValue = BigInt(byte & 0b01111111);
-        const byteNotLast = BigInt(byte & 0b10000000);
+        const byteValue = BigInt(byte & 0b0111_1111);
+        const byteNotLast = BigInt(byte & 0b1000_0000);
         value |= byteValue << leastSignificantValueBitIndex;
         leastSignificantValueBitIndex += 7n;
         if (byteNotLast) {
             continue;
         }
-        const mostSignificantInputBit = byte & 0b01000000;
+        const mostSignificantInputBit = byte & 0b0100_0000;
         if (mostSignificantInputBit) {
             value |= (~0n << leastSignificantValueBitIndex);
         }
@@ -49,8 +49,8 @@ export const uleb128UnsafeNumberParser = async (parserContext) => {
     let value = 0;
     while (true) {
         const byte = await parserContext.read(0);
-        const byteValue = byte & 0b01111111;
-        const byteNotLast = byte & 0b10000000;
+        const byteValue = byte & 0b0111_1111;
+        const byteNotLast = byte & 0b1000_0000;
         value |= byteValue << leastSignificantValueBitIndex;
         if (byteNotLast) {
             leastSignificantValueBitIndex += 7;
@@ -65,14 +65,14 @@ export const sleb128UnsafeNumberParser = async (parserContext) => {
     let leastSignificantValueBitIndex = 0;
     while (true) {
         const byte = await parserContext.read(0);
-        const byteValue = byte & 0b01111111;
-        const byteNotLast = byte & 0b10000000;
+        const byteValue = byte & 0b0111_1111;
+        const byteNotLast = byte & 0b1000_0000;
         value |= byteValue << leastSignificantValueBitIndex;
         leastSignificantValueBitIndex += 7;
         if (byteNotLast) {
             continue;
         }
-        const mostSignificantInputBit = byte & 0b01000000;
+        const mostSignificantInputBit = byte & 0b0100_0000;
         if (leastSignificantValueBitIndex < 32 && mostSignificantInputBit) {
             value |= (~0 << leastSignificantValueBitIndex);
         }

package/build/leb128Parser.test.js

@@ -4,7 +4,7 @@ import test from 'ava';
 import leb128 from 'leb128';
 import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { runParser } from './parser.js';
-import { uleb128Parser, sleb128Parser, uleb128NumberParser, sleb128NumberParser } from './leb128Parser.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],
@@ -29,13 +29,13 @@ test('sleb128, uleb128, uleb128p1', async (t) => {
     }
     for (const [input, expectedSleb128,] of [
         [new Uint8Array([2]), 2n],
-        [new Uint8Array([0x7e]), -2n],
+        [new Uint8Array([0x7E]), -2n],
         [new Uint8Array([127 + 0x80, 0]), 127n],
-        [new Uint8Array([1 + 0x80, 0x7f]), -127n],
+        [new Uint8Array([1 + 0x80, 0x7F]), -127n],
         [new Uint8Array([0 + 0x80, 1]), 128n],
-        [new Uint8Array([0 + 0x80, 0x7f]), -128n],
+        [new Uint8Array([0 + 0x80, 0x7F]), -128n],
         [new Uint8Array([1 + 0x80, 1]), 129n],
-        [new Uint8Array([0x7f + 0x80, 0x7e]), -129n],
+        [new Uint8Array([0x7F + 0x80, 0x7E]), -129n],
     ]) {
         const actualSleb128 = await runParser(sleb128Parser, input, uint8ArrayParserInputCompanion);
         t.is(actualSleb128, expectedSleb128, 'sleb128');
@@ -65,7 +65,7 @@ testProp.skip('uleb128NumberParser on large number', [
 ], async (t, natural) => {
     const uleb128 = leb128.unsigned.encode(natural);
     if (natural > (2 ** 32) - 1) {
-        await t.throwsAsync(() => runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion));
+        await t.throwsAsync(async () => runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion));
         return;
     }
     const actualUleb128 = await runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion);
@@ -79,7 +79,7 @@ testProp.skip('sleb128NumberParser on large number', [
 ], async (t, integer) => {
     const sleb128 = leb128.signed.encode(integer);
     if (integer > (2 ** 32) - 1 || integer < -(2 ** 32)) {
-        await t.throwsAsync(() => runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion));
+        await t.throwsAsync(async () => runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion));
         return;
     }
     const actualSleb128 = await runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion);

package/build/negativeLookaheadParser.js

@@ -1,5 +1,5 @@
 import { getParserName, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 export const createNegativeLookaheadParser = (childParser) => {
     const negativeLookaheadParser = async (parserContext) => {
         const childParserContext = parserContext.lookahead();
@@ -9,7 +9,7 @@ export const createNegativeLookaheadParser = (childParser) => {
             childParserSuccess = true;
         }
         catch (error) {
-            if (!(error instanceof ParserParsingFailedError)) {
+            if (!isParserParsingFailedError(error)) {
                 throw error;
             }
             childParserSuccess = false;

package/build/negativeLookaheadParser.test.js

@@ -5,24 +5,24 @@ import { createExactSequenceParser } from './exactSequenceParser.js';
 import { runParser } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { createTupleParser } from './tupleParser.js';
-import { ParserParsingFailedError } from './parserError.js';
 testProp('negativeLookaheadParser', [
     fc.tuple(fc.string({
         minLength: 1,
     }), fc.string({
         minLength: 1,
-    })).filter(([a, b]) => !a.startsWith(b))
+    })).filter(([a, b]) => !a.startsWith(b)),
 ], async (t, [stringA, stringB]) => {
     const result = await runParser(createTupleParser([
         createNegativeLookaheadParser(createExactSequenceParser(stringB)),
         createExactSequenceParser(stringA + stringB),
     ]), stringA + stringB, stringParserInputCompanion);
     t.deepEqual(result, [undefined, stringA + stringB]);
-    await t.throwsAsync(() => runParser(createTupleParser([
+    await t.throwsAsync(async () => runParser(createTupleParser([
         createNegativeLookaheadParser(createExactSequenceParser(stringA)),
         createExactSequenceParser(stringA + stringB),
     ]), stringA + stringB, stringParserInputCompanion), {
-        instanceOf: ParserParsingFailedError,
+        any: true,
+        name: 'ParserParsingInvariantError',
         message: /lookahead/,
     });
 }, {

package/build/noStackCaptureOverheadError.d.ts

@@ -0,0 +1,4 @@
+declare class NoStackCaptureOverheadErrorClass extends Error {
+}
+export declare const NoStackCaptureOverheadError: typeof NoStackCaptureOverheadErrorClass;
+export {};

package/build/noStackCaptureOverheadError.js

@@ -0,0 +1,9 @@
+class NoStackCaptureOverheadErrorClass extends Error {
+}
+function NoStackCaptureOverheadErrorConstructor(message) {
+    this.name = 'NoStackCaptureOverheadError';
+    this.message = message;
+    this.stack = 'This stack is intentionally left blank to avoid capture overhead.';
+}
+NoStackCaptureOverheadErrorConstructor.prototype = Object.create(Error.prototype);
+export const NoStackCaptureOverheadError = NoStackCaptureOverheadErrorConstructor;

package/build/noStackCaptureOverheadError.test.d.ts

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

package/build/noStackCaptureOverheadError.test.js

@@ -0,0 +1,15 @@
+import test from 'ava';
+import util from 'util';
+import { NoStackCaptureOverheadError } from './noStackCaptureOverheadError.js';
+test('NoStackCaptureOverheadError works', t => {
+    const error = new NoStackCaptureOverheadError('Test message');
+    t.is(error.name, 'NoStackCaptureOverheadError');
+    t.is(error.message, 'Test message');
+    t.true(error instanceof Error, 'error is instance of Error');
+    t.true(error instanceof NoStackCaptureOverheadError, 'error is instance of NoStackCaptureOverheadError');
+    t.false(new Error() instanceof NoStackCaptureOverheadError, 'regular Error is not instance of NoStackCaptureOverheadError');
+    if (typeof Error.isError === 'function') {
+        t.false(Error.isError(error), 'Error.isError does not identify error as Error');
+    }
+    t.false(util.types.isNativeError(error), 'util.types.isNativeError does not identify error as native Error');
+});

package/build/nonEmptyArrayParser.js

@@ -1,5 +1,5 @@
 import { getParserName, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 export const createNonEmptyArrayParser = (elementParser) => {
     const nonEmptyArrayParser = async (parserContext) => {
         const elements = [];
@@ -15,7 +15,7 @@ export const createNonEmptyArrayParser = (elementParser) => {
                 elementParserContext.unlookahead();
             }
             catch (error) {
-                if (error instanceof ParserParsingFailedError) {
+                if (isParserParsingFailedError(error)) {
                     break;
                 }
                 throw error;