@futpib/parser 1.0.0 → 1.0.2

package/build/smaliParser.test.js

@@ -0,0 +1,115 @@
+import test from 'ava';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { getParserName, runParser } from './parser.js';
+import { fetchCid } from './fetchCid.js';
+import { smaliAnnotationParser, smaliCodeParameterParser, smaliFieldParser, smaliParser } from './smaliParser.js';
+import { hasExecutable } from './hasExecutable.js';
+import { baksmaliClass } from './backsmali.js';
+const hasBaksmaliPromise = hasExecutable('baksmali');
+function stringParserTest(parser, examples) {
+    const parserName = getParserName(parser);
+    for (const [input, expected] of examples) {
+        test(parserName + ' ' + JSON.stringify(input), async (t) => {
+            const actual = await runParser(parser, input, stringParserInputCompanion, {
+                errorJoinMode: 'all',
+            });
+            t.deepEqual(actual, expected);
+        });
+    }
+}
+stringParserTest(smaliCodeParameterParser, [
+    [
+        '    .param p1\n',
+        {
+            index: 1,
+            prefix: 'p',
+        },
+    ],
+    [
+        '    .param p1, "savedInstanceState"    # Landroid/os/Bundle;\n',
+        {
+            index: 1,
+            prefix: 'p',
+        },
+    ],
+]);
+stringParserTest(smaliFieldParser, [
+    [
+        '.field private barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;\n',
+        {
+            accessFlags: {
+                abstract: false,
+                annotation: false,
+                bridge: false,
+                constructor: false,
+                declaredSynchronized: false,
+                enum: false,
+                final: false,
+                interface: false,
+                native: false,
+                private: true,
+                protected: false,
+                public: false,
+                static: false,
+                strict: false,
+                synchronized: false,
+                synthetic: false,
+                transient: false,
+                varargs: false,
+                volatile: false,
+            },
+            field: {
+                class: 'FILLED_LATER',
+                name: 'barcodeScannerView',
+                type: 'Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;',
+            },
+        },
+    ],
+]);
+stringParserTest(smaliAnnotationParser, [
+    [
+        `    .annotation system Ldalvik/annotation/Signature;
+                value = {
+                    "<T:",
+                    "Landroid/view/View;",
+                    ">(I)TT;"
+                }
+            .end annotation
+`,
+        {
+            type: 'Ldalvik/annotation/Signature;',
+            value: [
+                '<T:',
+                'Landroid/view/View;',
+                '>(I)TT;',
+            ],
+        },
+    ],
+]);
+for (const [dexCid, smaliFilePath, shouldSnapshot] of [
+    ['bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', 'pl/czak/minimal/MainActivity', true],
+    ['bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', 'd/m', true],
+    // [ 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', 'com/journeyapps/barcodescanner/CaptureActivity', true ],
+    // [ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false ],
+]) {
+    test.serial('smali from dex ' + dexCid + ' ' + smaliFilePath, async (t) => {
+        const hasBaksmali = await hasBaksmaliPromise;
+        if (!hasBaksmali) {
+            t.pass('skipping test because baksmali is not available');
+            return;
+        }
+        const dexStream = await fetchCid(dexCid);
+        const smali = await baksmaliClass(dexStream, smaliFilePath);
+        const actual = await runParser(smaliParser, smali, stringParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        // console.dir(actual, { depth: null });
+        if (shouldSnapshot) {
+            t.snapshot(actual);
+        }
+        else {
+            //console.dir(actual, { depth: null });
+            t.pass();
+        }
+    });
+}

package/build/terminatedArrayParser.d.ts

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

package/build/terminatedArrayParser.js

@@ -1,20 +1,22 @@
-import { getParserName, setParserName } from "./parser.js";
-import { promiseCompose } from "./promiseCompose.js";
-import { createUnionParser } from "./unionParser.js";
+import { getParserName, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createUnionParser } from './unionParser.js';
 class Terminated {
     value;
     constructor(value) {
         this.value = value;
     }
 }
-export const createTerminatedArrayParser = (elementParser, terminatorParser) => {
+export const createTerminatedArrayParserNaive = (elementParser, terminatorParser) => {
     const wrappedTerminatorParser = promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue));
     setParserName(wrappedTerminatorParser, getParserName(terminatorParser, 'anonymousTerminator'));
     const elementOrTerminatorParser = createUnionParser([
         elementParser,
         promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue)),
     ]);
-    return async (parserContext) => {
+    const terminatedArrayParserNaive = async (parserContext) => {
         const elements = [];
         while (true) {
             const elementOrTerminator = await elementOrTerminatorParser(parserContext);
@@ -24,4 +26,79 @@ export const createTerminatedArrayParser = (elementParser, terminatorParser) =>
             elements.push(elementOrTerminator);
         }
     };
+    setParserName(terminatedArrayParserNaive, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);
+    return terminatedArrayParserNaive;
+};
+export const createTerminatedArrayParser = (elementParser, terminatorParser) => {
+    const terminatedArrayParser = async (parserContext) => {
+        const elements = [];
+        while (true) {
+            const terminatorParserContext = parserContext.lookahead({
+                debugName: getParserName(terminatorParser, 'anonymousTerminator'),
+            });
+            try {
+                const terminatorValue = await terminatorParser(terminatorParserContext);
+                const elementParserContext = parserContext.lookahead({
+                    debugName: getParserName(elementParser, 'anonymousElement'),
+                });
+                try {
+                    await elementParser(elementParserContext);
+                    parserImplementationInvariant(false, [
+                        'Both element and terminator parsers matched.',
+                        'Element parser: %s',
+                        'Terminator parser: %s',
+                    ], getParserName(elementParser, 'anonymousElement'), getParserName(terminatorParser, 'anonymousTerminator'));
+                }
+                catch (error) {
+                    if (!(error instanceof ParserParsingFailedError)) {
+                        throw error;
+                    }
+                }
+                finally {
+                    elementParserContext.dispose();
+                }
+                terminatorParserContext.unlookahead();
+                return [elements, terminatorValue];
+            }
+            catch (error) {
+                if (!(error instanceof ParserParsingFailedError)) {
+                    throw error;
+                }
+            }
+            finally {
+                terminatorParserContext.dispose();
+            }
+            const element = await elementParser(parserContext);
+            elements.push(element);
+        }
+    };
+    setParserName(terminatedArrayParser, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);
+    return terminatedArrayParser;
+};
+export const createTerminatedArrayParserUnsafe = (elementParser, terminatorParser) => {
+    const terminatedArrayParserUnsafe = async (parserContext) => {
+        const elements = [];
+        while (true) {
+            const terminatorParserContext = parserContext.lookahead({
+                debugName: getParserName(terminatorParser, 'anonymousTerminator'),
+            });
+            try {
+                const terminatorValue = await terminatorParser(terminatorParserContext);
+                terminatorParserContext.unlookahead();
+                return [elements, terminatorValue];
+            }
+            catch (error) {
+                if (!(error instanceof ParserParsingFailedError)) {
+                    throw error;
+                }
+            }
+            finally {
+                terminatorParserContext.dispose();
+            }
+            const element = await elementParser(parserContext);
+            elements.push(element);
+        }
+    };
+    setParserName(terminatedArrayParserUnsafe, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);
+    return terminatedArrayParserUnsafe;
 };

package/build/terminatedArrayParser.test.d.ts

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

package/build/terminatedArrayParser.test.js

@@ -0,0 +1,131 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createTerminatedArrayParser, createTerminatedArrayParserNaive, createTerminatedArrayParserUnsafe } from './terminatedArrayParser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { HighResolutionTotalTimer } from './highResolutionTimer.js';
+import { createElementParser } from './elementParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createUnionParser } from './unionParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+test('terminatedArrayParser of union parsers', async (t) => {
+    const parser = createTerminatedArrayParser(createUnionParser([
+        createExactElementParser(1),
+        createExactElementParser(2),
+    ]), createExactElementParser(0));
+    const input = new Uint8Array([0]);
+    const result = await runParser(parser, input, uint8ArrayParserInputCompanion);
+    t.deepEqual(result, [[], 0]);
+});
+testProp('terminatedArrayParser both terminator and element matching', [
+    fc.string(),
+], async (t, string) => {
+    const terminatedArrayParserNaive = createTerminatedArrayParserNaive(createExactSequenceParser(string), createExactSequenceParser(string));
+    const terminatedArrayParser = createTerminatedArrayParser(createExactSequenceParser(string), createExactSequenceParser(string));
+    const [naiveResult, result,] = await Promise.allSettled([
+        runParser(terminatedArrayParserNaive, string, stringParserInputCompanion),
+        runParser(terminatedArrayParser, string, stringParserInputCompanion),
+    ]);
+    t.is(naiveResult.status, 'rejected');
+    if (result.status === 'rejected'
+        && naiveResult.status === 'rejected') {
+        result.reason.message = 'REDACTED';
+        naiveResult.reason.message = 'REDACTED';
+    }
+    t.deepEqual(result, naiveResult);
+}, {
+    verbose: true,
+});
+const naiveTotalTimer = new HighResolutionTotalTimer();
+const optimizedTotalTimer = new HighResolutionTotalTimer();
+const unsafeTotalTimer = new HighResolutionTotalTimer();
+testProp.serial('terminatedArrayParser', [
+    fc
+        .integer({
+        min: 1,
+        max: 2 ** 8,
+    })
+        .chain(terminatorLength => (fc
+        .string({
+        minLength: terminatorLength,
+    })
+        .map(string => ({
+        string,
+        terminator: string.slice(0 - terminatorLength)
+    }))
+        .filter(({ string, terminator }) => string.split(terminator).length === 2)))
+], async (t, { string, terminator }) => {
+    const terminatedArrayParserNaive = createTerminatedArrayParserNaive(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([_, element]) => element), createExactSequenceParser(terminator));
+    const terminatedArrayParser = createTerminatedArrayParser(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([_, element]) => element), createExactSequenceParser(terminator));
+    const createTestWrapperParser = (innerParser) => async (parserContext) => {
+        const [characters, terminator] = await innerParser(parserContext);
+        return {
+            string: characters.join(''),
+            terminator,
+            nextPeek: await parserContext.peek(0),
+            position: parserContext.position,
+        };
+    };
+    const actualNaive = await naiveTotalTimer.measureAsync(() => runParser(createTestWrapperParser(terminatedArrayParserNaive), string, stringParserInputCompanion));
+    t.is(actualNaive.string.length + actualNaive.terminator.length, string.length);
+    const actual = await optimizedTotalTimer.measureAsync(() => runParser(createTestWrapperParser(terminatedArrayParser), string, stringParserInputCompanion));
+    t.deepEqual(actual, actualNaive);
+}, {
+    verbose: true,
+});
+test.serial('terminatedArrayParser performance', t => {
+    t.true(optimizedTotalTimer.time * 1n < naiveTotalTimer.time, `Naive: ${naiveTotalTimer.time / 1000000n}ms, Optimized: ${optimizedTotalTimer.time / 1000000n}ms`);
+});
+testProp.serial('terminatedArrayParserUnsafe', [
+    fc
+        .integer({
+        min: 1,
+        max: 2 ** 8,
+    })
+        .chain(terminatorLength => (fc
+        .string({
+        minLength: terminatorLength,
+    })
+        .map(string => ({
+        string,
+        terminator: string.slice(0 - terminatorLength)
+    }))
+        .filter(({ string, terminator }) => string.split(terminator).length === 2)))
+], async (t, { string, terminator }) => {
+    const terminatedArrayParserNaive = createTerminatedArrayParserNaive(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([_, element]) => element), createExactSequenceParser(terminator));
+    const terminatedArrayParserUnsafe = createTerminatedArrayParserUnsafe(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([_, element]) => element), createExactSequenceParser(terminator));
+    const createTestWrapperParser = (innerParser) => async (parserContext) => {
+        const [characters, terminator] = await innerParser(parserContext);
+        return {
+            string: characters.join(''),
+            terminator,
+            nextPeek: await parserContext.peek(0),
+            position: parserContext.position,
+        };
+    };
+    const actualNaive = await runParser(createTestWrapperParser(terminatedArrayParserNaive), string, stringParserInputCompanion);
+    t.is(actualNaive.string.length + actualNaive.terminator.length, string.length);
+    const actual = await unsafeTotalTimer.measureAsync(() => runParser(createTestWrapperParser(terminatedArrayParserUnsafe), string, stringParserInputCompanion));
+    t.deepEqual(actual, actualNaive);
+}, {
+    verbose: true,
+});
+test.serial('terminatedArrayParserUnsafe performance', t => {
+    t.true(unsafeTotalTimer.time * 1n < naiveTotalTimer.time, `Naive: ${naiveTotalTimer.time / 1000000n}ms, Unsafe: ${unsafeTotalTimer.time / 1000000n}ms`);
+});

package/build/toAsyncIterable.d.ts

@@ -0,0 +1 @@
+export declare function toAsyncIterable<T>(value: AsyncIterator<T>): AsyncIterable<T>;

package/build/toAsyncIterable.js

@@ -0,0 +1,7 @@
+export function toAsyncIterable(value) {
+    return {
+        [Symbol.asyncIterator]() {
+            return value;
+        },
+    };
+}

package/build/toAsyncIterator.d.ts

@@ -0,0 +1 @@
+export declare function toAsyncIterator<T>(value: AsyncIterator<T> | AsyncIterable<T> | Iterable<T> | T): AsyncIterator<T>;

package/build/toAsyncIterator.js

@@ -0,0 +1,33 @@
+import invariant from "invariant";
+function isAsyncIterable(value) {
+    return value && typeof value[Symbol.asyncIterator] === 'function';
+}
+function isIterable(value) {
+    return value && typeof value[Symbol.iterator] === 'function';
+}
+function isIterator(value) {
+    return value && typeof value.next === 'function';
+}
+function iteratorToAsyncIterator(iterator) {
+    return {
+        next: async () => iterator.next(),
+    };
+}
+export function toAsyncIterator(value) {
+    if (typeof value === 'string'
+        || value instanceof Uint8Array) {
+        return (async function* () {
+            yield value;
+        })();
+    }
+    if (isAsyncIterable(value)) {
+        return value[Symbol.asyncIterator]();
+    }
+    if (isIterable(value)) {
+        return iteratorToAsyncIterator(value[Symbol.iterator]());
+    }
+    if (isIterator(value)) {
+        return iteratorToAsyncIterator(value);
+    }
+    invariant(false, 'Value must be an async iterator, async iterable, iterable or iterator got %s.', value);
+}

package/build/tupleParser.d.ts

@@ -9,3 +9,7 @@ export declare function createTupleParser<A, B, C, D, E, F, G, H, Sequence>([par
 export declare function createTupleParser<A, B, C, D, E, F, G, H, I, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I], Sequence>;
 export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J], Sequence>;
 export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, N, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM, parserN]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>, Parser<N, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM, parserN, parserO]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>, Parser<N, Sequence>, Parser<O, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O], Sequence>;

package/build/tupleParser.js

@@ -8,10 +8,6 @@ export function createTupleParser(parsers) {
         }
         return values;
     };
-    setParserName(tupleParser, [
-        '[',
-        parsers.map(parser => getParserName(parser, 'anonymousTupleChild')).join(','),
-        ']',
-    ].join(''));
+    setParserName(tupleParser, parsers.map(parser => '(' + getParserName(parser, 'anonymousTupleChild') + ')').join(''));
     return tupleParser;
 }

package/build/uint8Array.d.ts

@@ -0,0 +1 @@
+export declare function uint8ArrayAsyncIterableToUint8Array(uint8ArrayAsyncIterable: AsyncIterable<Uint8Array> | Iterable<Uint8Array>): Promise<Uint8Array>;

package/build/uint8Array.js

@@ -0,0 +1,7 @@
+export async function uint8ArrayAsyncIterableToUint8Array(uint8ArrayAsyncIterable) {
+    const chunks = [];
+    for await (const chunk of uint8ArrayAsyncIterable) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+}

package/build/unionParser.d.ts

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

package/build/unionParser.js

@@ -2,30 +2,42 @@ import { allSettledStream } from './allSettledStream.js';
 import { getParserName, setParserName } from './parser.js';
 import { ParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+const bigintReplacer = (_key, value) => {
+    if (typeof value === 'bigint') {
+        return `${value}n`;
+    }
+    return value;
+};
 export const createUnionParser = (childParsers) => {
     parserImplementationInvariant(childParsers.length > 0, 'Union parser must have at least one child parser.');
     const unionParser = async (parserContext) => {
         let runningChildParserContexts = [];
-        const childParserResults = allSettledStream(childParsers.map(childParser => {
+        const createChildParserTask = (childParser) => {
             const childParserContext = parserContext.lookahead({
                 debugName: getParserName(childParser, 'anonymousUnionChild'),
             });
-            runningChildParserContexts.push(childParserContext);
-            const promise = childParser(childParserContext);
+            const context = {
+                childParser,
+                childParserContext,
+            };
+            runningChildParserContexts.push(context);
+            const getChildParserPromise = (async () => childParser(childParserContext));
+            const promise = getChildParserPromise();
             return {
                 promise,
-                context: childParserContext,
+                context,
             };
-        }));
+        };
+        const childParserResults = allSettledStream(childParsers.map(createChildParserTask));
         const parserParsingFailedErrors = [];
         const successfulParserOutputs = [];
-        const successfulParserContexts = [];
+        const successfulTaskContexts = [];
         let didUnlookahead = false;
         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);
+                successfulTaskContexts.push(childParserResult.context);
             }
             else {
                 const error = childParserResult.reason;
@@ -41,7 +53,7 @@ export const createUnionParser = (childParsers) => {
                 parserImplementationInvariant(!didUnlookahead, 'Union parser unlookaheaded multiple times.');
                 didUnlookahead = true;
                 const [runningChildParserContext] = runningChildParserContexts;
-                runningChildParserContext.unlookahead();
+                runningChildParserContext.childParserContext.unlookahead();
             }
         }
         parserImplementationInvariant(successfulParserOutputs.length <= 1, [
@@ -49,13 +61,16 @@ export const createUnionParser = (childParsers) => {
             'Successful parser outputs, indented, separated by newlines:',
             '%s',
             'End of successful parser outputs.',
-        ], () => successfulParserOutputs.map(output => '  ' + JSON.stringify(output)).join('\n'));
+            'Successful parser names, indented, separated by newlines:',
+            '%s',
+            'End of successful parser names.',
+        ], () => successfulParserOutputs.map(output => '  ' + JSON.stringify(output, bigintReplacer)).join('\n'), () => successfulTaskContexts.map(taskContext => '  ' + getParserName(taskContext.childParser, 'anonymousUnionChild')).join('\n'));
         parserContext.invariantJoin(successfulParserOutputs.length === 1, parserParsingFailedErrors, 'No union child parser succeeded.');
-        const [successfulParserContext] = successfulParserContexts;
+        const [successfulParserContext] = successfulTaskContexts;
         if (!didUnlookahead) {
-            successfulParserContext.unlookahead();
+            successfulParserContext.childParserContext.unlookahead();
         }
-        successfulParserContext.dispose();
+        successfulParserContext.childParserContext.dispose();
         const [successfulParserOutput] = successfulParserOutputs;
         return successfulParserOutput;
     };

package/build/unionParser.test.d.ts

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

package/build/unionParser.test.js

@@ -0,0 +1,60 @@
+import test from 'ava';
+import { createUnionParser } from './unionParser.js';
+import { runParser, setParserName } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createArrayParser } from './arrayParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { ParserError } from './parserError.js';
+test('union of union of union', async (t) => {
+    const parser = createUnionParser([
+        createExactElementParser('a'),
+        createUnionParser([
+            createExactElementParser('b'),
+            createUnionParser([
+                createExactElementParser('c'),
+                createExactElementParser('d'),
+            ]),
+            createExactElementParser('e'),
+        ]),
+        createExactElementParser('f'),
+        createUnionParser([
+            createExactElementParser('g'),
+            createExactElementParser('h'),
+        ]),
+    ]);
+    for (const character of 'abcdefgh') {
+        t.deepEqual(await runParser(parser, character, stringParserInputCompanion), character);
+    }
+});
+test('sync and async child parsers', async (t) => {
+    const parser = createArrayParser(createUnionParser([
+        async (parserContext) => {
+            parserContext.invariant(parserContext.position % 2 === 0, 'Expected an even position.');
+            return parserContext.read(0);
+        },
+        parserContext => {
+            parserContext.invariant(parserContext.position % 2 === 1, 'Expected an odd position.');
+            parserContext.skip(1);
+            return String.fromCodePoint('A'.codePointAt(0) + parserContext.position - 1);
+        },
+    ]));
+    const result = await runParser(parser, 'a?c?', stringParserInputCompanion, {
+        errorJoinMode: 'all',
+    });
+    t.deepEqual(result, 'aBcD'.split(''));
+});
+test('multiple parsers succeeded error', async (t) => {
+    const parser = createUnionParser([
+        setParserName(createExactSequenceParser('foo'), 'foo1'),
+        setParserName(createExactSequenceParser('foo'), 'foo2'),
+    ]);
+    const error = await t.throwsAsync(runParser(parser, 'foo', stringParserInputCompanion, {
+        errorJoinMode: 'all',
+    }), {
+        instanceOf: ParserError,
+    });
+    t.true(error.message.includes('foo'));
+    t.true(error.message.includes('foo1'));
+    t.true(error.message.includes('foo2'));
+});

package/build/unparser.d.ts

@@ -0,0 +1,8 @@
+import { DeriveSequenceElement } from "./sequence.js";
+import { UnparserContext, WriteEarlier, WriteLater } from "./unparserContext.js";
+import { UnparserOutputCompanion } from "./unparserOutputCompanion.js";
+type UnparserIterableValue<Sequence, Element> = Sequence | Element | WriteLater<Sequence, Element> | WriteEarlier<Sequence, Element>;
+export type UnparserResult<Sequence, Element> = AsyncIterable<UnparserIterableValue<Sequence, Element>>;
+export type Unparser<Input, Sequence, Element = DeriveSequenceElement<Sequence>> = (input: Input, unparserContext: UnparserContext<Sequence, Element>) => UnparserResult<Sequence, Element>;
+export declare function runUnparser<Input, Sequence, Element = DeriveSequenceElement<Sequence>>(unparser: Unparser<Input, Sequence, Element>, input: Input, unparserOutputCompanion: UnparserOutputCompanion<Sequence, Element>): AsyncIterable<Sequence>;
+export {};