@futpib/parser 1.0.3 → 1.0.6

package/build/symbolicExpressionParser.test.js

@@ -0,0 +1,289 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import sExpression from 's-expression';
+import { runParser } from './parser.js';
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { symbolicExpressionParser, symbolicExpressionDocumentParser, } from './symbolicExpressionParser.js';
+// Convert s-expression package output to our discriminated union format
+function convertToDiscriminatedUnion(value) {
+    if (Array.isArray(value)) {
+        // Handle quote forms: ['quote', x], ['quasiquote', x], etc.
+        if (value.length === 2 && typeof value[0] === 'string') {
+            const [type, inner] = value;
+            if (type === 'quote') {
+                return { type: 'quote', value: convertToDiscriminatedUnion(inner) };
+            }
+            if (type === 'quasiquote') {
+                return { type: 'quasiquote', value: convertToDiscriminatedUnion(inner) };
+            }
+            if (type === 'unquote') {
+                return { type: 'unquote', value: convertToDiscriminatedUnion(inner) };
+            }
+            if (type === 'unquote-splicing') {
+                return { type: 'unquote-splicing', value: convertToDiscriminatedUnion(inner) };
+            }
+        }
+        return { type: 'list', value: value.map(convertToDiscriminatedUnion) };
+    }
+    if (value instanceof String) {
+        return { type: 'string', value: value.valueOf() };
+    }
+    if (typeof value === 'string') {
+        return { type: 'atom', value };
+    }
+    throw new Error(`Unknown value type: ${typeof value}`);
+}
+// Basic atom parsing
+test('atom - simple', async (t) => {
+    const result = await runParser(symbolicExpressionParser, 'a', stringParserInputCompanion);
+    t.deepEqual(result, { type: 'atom', value: 'a' });
+});
+test('atom - with numbers', async (t) => {
+    const result = await runParser(symbolicExpressionParser, 'abc123', stringParserInputCompanion);
+    t.deepEqual(result, { type: 'atom', value: 'abc123' });
+});
+// List parsing
+test('list - empty', async (t) => {
+    const result = await runParser(symbolicExpressionParser, '()', stringParserInputCompanion);
+    t.deepEqual(result, { type: 'list', value: [] });
+});
+test('list - single element', async (t) => {
+    const result = await runParser(symbolicExpressionParser, '(a)', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'list',
+        value: [{ type: 'atom', value: 'a' }],
+    });
+});
+test('list - multiple elements', async (t) => {
+    const result = await runParser(symbolicExpressionParser, '(a b c)', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'list',
+        value: [
+            { type: 'atom', value: 'a' },
+            { type: 'atom', value: 'b' },
+            { type: 'atom', value: 'c' },
+        ],
+    });
+});
+test('list - nested', async (t) => {
+    const result = await runParser(symbolicExpressionParser, '((a b c)(()()))', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'list',
+        value: [
+            {
+                type: 'list',
+                value: [
+                    { type: 'atom', value: 'a' },
+                    { type: 'atom', value: 'b' },
+                    { type: 'atom', value: 'c' },
+                ],
+            },
+            {
+                type: 'list',
+                value: [
+                    { type: 'list', value: [] },
+                    { type: 'list', value: [] },
+                ],
+            },
+        ],
+    });
+});
+// String parsing
+test('string - simple', async (t) => {
+    const result = await runParser(symbolicExpressionParser, '"hello"', stringParserInputCompanion);
+    t.deepEqual(result, { type: 'string', value: 'hello' });
+});
+test('string - with escape sequences', async (t) => {
+    const result = await runParser(symbolicExpressionParser, '"hello\\nworld"', stringParserInputCompanion);
+    t.deepEqual(result, { type: 'string', value: 'hello\nworld' });
+});
+test('string - in list', async (t) => {
+    const result = await runParser(symbolicExpressionParser, '(a "hello")', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'list',
+        value: [
+            { type: 'atom', value: 'a' },
+            { type: 'string', value: 'hello' },
+        ],
+    });
+});
+// Quote parsing
+test('quote - atom', async (t) => {
+    const result = await runParser(symbolicExpressionParser, "'a", stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'quote',
+        value: { type: 'atom', value: 'a' },
+    });
+});
+test('quote - empty list', async (t) => {
+    const result = await runParser(symbolicExpressionParser, "'()", stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'quote',
+        value: { type: 'list', value: [] },
+    });
+});
+test('quote - list', async (t) => {
+    const result = await runParser(symbolicExpressionParser, "'(a b c)", stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'quote',
+        value: {
+            type: 'list',
+            value: [
+                { type: 'atom', value: 'a' },
+                { type: 'atom', value: 'b' },
+                { type: 'atom', value: 'c' },
+            ],
+        },
+    });
+});
+test('quote - nested', async (t) => {
+    const result = await runParser(symbolicExpressionParser, "''a", stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'quote',
+        value: {
+            type: 'quote',
+            value: { type: 'atom', value: 'a' },
+        },
+    });
+});
+// Quasiquote parsing
+test('quasiquote - atom', async (t) => {
+    const result = await runParser(symbolicExpressionParser, '`a', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'quasiquote',
+        value: { type: 'atom', value: 'a' },
+    });
+});
+test('quasiquote - list', async (t) => {
+    const result = await runParser(symbolicExpressionParser, '`(a b c)', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'quasiquote',
+        value: {
+            type: 'list',
+            value: [
+                { type: 'atom', value: 'a' },
+                { type: 'atom', value: 'b' },
+                { type: 'atom', value: 'c' },
+            ],
+        },
+    });
+});
+// Unquote parsing
+test('unquote - atom', async (t) => {
+    const result = await runParser(symbolicExpressionParser, ',a', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'unquote',
+        value: { type: 'atom', value: 'a' },
+    });
+});
+test('unquote - list', async (t) => {
+    const result = await runParser(symbolicExpressionParser, ',(a b c)', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'unquote',
+        value: {
+            type: 'list',
+            value: [
+                { type: 'atom', value: 'a' },
+                { type: 'atom', value: 'b' },
+                { type: 'atom', value: 'c' },
+            ],
+        },
+    });
+});
+// Unquote-splicing parsing
+test('unquote-splicing - atom', async (t) => {
+    const result = await runParser(symbolicExpressionParser, ',@a', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'unquote-splicing',
+        value: { type: 'atom', value: 'a' },
+    });
+});
+test('unquote-splicing - list', async (t) => {
+    const result = await runParser(symbolicExpressionParser, ',@(a b c)', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'unquote-splicing',
+        value: {
+            type: 'list',
+            value: [
+                { type: 'atom', value: 'a' },
+                { type: 'atom', value: 'b' },
+                { type: 'atom', value: 'c' },
+            ],
+        },
+    });
+});
+// Complex expressions
+test('complex - quote inside list', async (t) => {
+    const result = await runParser(symbolicExpressionParser, "(a '(a b c))", stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'list',
+        value: [
+            { type: 'atom', value: 'a' },
+            {
+                type: 'quote',
+                value: {
+                    type: 'list',
+                    value: [
+                        { type: 'atom', value: 'a' },
+                        { type: 'atom', value: 'b' },
+                        { type: 'atom', value: 'c' },
+                    ],
+                },
+            },
+        ],
+    });
+});
+test('complex - multiple quotes in list', async (t) => {
+    const result = await runParser(symbolicExpressionParser, "((a 'b 'c))", stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'list',
+        value: [
+            {
+                type: 'list',
+                value: [
+                    { type: 'atom', value: 'a' },
+                    { type: 'quote', value: { type: 'atom', value: 'b' } },
+                    { type: 'quote', value: { type: 'atom', value: 'c' } },
+                ],
+            },
+        ],
+    });
+});
+// Document parser with whitespace
+test('document - with leading whitespace', async (t) => {
+    const result = await runParser(symbolicExpressionDocumentParser, '  a', stringParserInputCompanion);
+    t.deepEqual(result, { type: 'atom', value: 'a' });
+});
+test('document - with trailing whitespace', async (t) => {
+    const result = await runParser(symbolicExpressionDocumentParser, 'a  ', stringParserInputCompanion);
+    t.deepEqual(result, { type: 'atom', value: 'a' });
+});
+// Arbitrary symbolic expression generator for property-based testing
+const arbitraryAtomChar = fc.string({ minLength: 1, maxLength: 10 }).filter(s => s.length > 0 && !/[\s()"'`,;]/.test(s));
+const arbitraryStringContent = fc.string({ maxLength: 20 }).map(s => 
+// Escape special characters for string literals
+s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t'));
+const arbitrarySymbolicExpression = fc.letrec(tie => ({
+    atom: arbitraryAtomChar,
+    string: arbitraryStringContent.map(s => `"${s}"`),
+    list: fc.array(tie('expression'), { maxLength: 5 }).map(exprs => `(${exprs.join(' ')})`),
+    quote: tie('expression').map(e => `'${e}`),
+    quasiquote: tie('expression').map(e => `\`${e}`),
+    unquote: tie('expression').map(e => `,${e}`),
+    unquoteSplicing: tie('expression').map(e => `,@${e}`),
+    expression: fc.oneof({ weight: 5, arbitrary: tie('atom') }, { weight: 2, arbitrary: tie('string') }, { weight: 3, arbitrary: tie('list') }, { weight: 1, arbitrary: tie('quote') }, { weight: 1, arbitrary: tie('quasiquote') }, { weight: 1, arbitrary: tie('unquote') }, { weight: 1, arbitrary: tie('unquoteSplicing') }),
+})).expression;
+// Property-based test comparing with s-expression package
+testProp('matches s-expression package output', [arbitrarySymbolicExpression], async (t, input) => {
+    const reference = sExpression(input);
+    if (reference instanceof Error) {
+        // If s-expression fails, our parser should also fail
+        await t.throwsAsync(() => runParser(symbolicExpressionParser, input, stringParserInputCompanion));
+    }
+    else {
+        const expected = convertToDiscriminatedUnion(reference);
+        const actual = await runParser(symbolicExpressionParser, input, stringParserInputCompanion);
+        t.deepEqual(actual, expected);
+    }
+}, { seed });

package/build/terminatedArrayParser.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { getParserName, setParserName } from './parser.js';
 import { isParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
@@ -33,43 +85,59 @@ export const createTerminatedArrayParser = (elementParser, terminatorParser) =>
     const terminatedArrayParser = async (parserContext) => {
         const elements = [];
         while (true) {
-            const terminatorParserContext = parserContext.lookahead({
-                debugName: getParserName(terminatorParser, 'anonymousTerminator'),
-            });
+            const env_1 = { stack: [], error: void 0, hasError: false };
             try {
-                const terminatorValue = await terminatorParser(terminatorParserContext);
-                const elementParserContext = parserContext.lookahead({
-                    debugName: getParserName(elementParser, 'anonymousElement'),
-                });
+                const terminatorParserContext = __addDisposableResource(env_1, parserContext.lookahead({
+                    debugName: getParserName(terminatorParser, 'anonymousTerminator'),
+                }), false);
                 try {
-                    await elementParser(elementParserContext);
-                    parserImplementationInvariant(false, [
-                        'Both element and terminator parsers matched.',
-                        'Element parser: %s',
-                        'Terminator parser: %s',
-                    ], getParserName(elementParser, 'anonymousElement'), getParserName(terminatorParser, 'anonymousTerminator'));
+                    const terminatorValue = await terminatorParser(terminatorParserContext);
+                    {
+                        const env_2 = { stack: [], error: void 0, hasError: false };
+                        try {
+                            const elementParserContext = __addDisposableResource(env_2, parserContext.lookahead({
+                                debugName: getParserName(elementParser, 'anonymousElement'),
+                            }), false);
+                            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 (!(isParserParsingFailedError(error))) {
+                                    throw error;
+                                }
+                            }
+                        }
+                        catch (e_1) {
+                            env_2.error = e_1;
+                            env_2.hasError = true;
+                        }
+                        finally {
+                            __disposeResources(env_2);
+                        }
+                    }
+                    terminatorParserContext.unlookahead();
+                    return [elements, terminatorValue];
                 }
                 catch (error) {
                     if (!(isParserParsingFailedError(error))) {
                         throw error;
                     }
                 }
-                finally {
-                    elementParserContext.dispose();
-                }
-                terminatorParserContext.unlookahead();
-                return [elements, terminatorValue];
+                const element = await elementParser(parserContext);
+                elements.push(element);
             }
-            catch (error) {
-                if (!(isParserParsingFailedError(error))) {
-                    throw error;
-                }
+            catch (e_2) {
+                env_1.error = e_2;
+                env_1.hasError = true;
             }
             finally {
-                terminatorParserContext.dispose();
+                __disposeResources(env_1);
             }
-            const element = await elementParser(parserContext);
-            elements.push(element);
         }
     };
     setParserName(terminatedArrayParser, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);
@@ -79,24 +147,31 @@ export const createTerminatedArrayParserUnsafe = (elementParser, terminatorParse
     const terminatedArrayParserUnsafe = async (parserContext) => {
         const elements = [];
         while (true) {
-            const terminatorParserContext = parserContext.lookahead({
-                debugName: getParserName(terminatorParser, 'anonymousTerminator'),
-            });
+            const env_3 = { stack: [], error: void 0, hasError: false };
             try {
-                const terminatorValue = await terminatorParser(terminatorParserContext);
-                terminatorParserContext.unlookahead();
-                return [elements, terminatorValue];
-            }
-            catch (error) {
-                if (!(isParserParsingFailedError(error))) {
-                    throw error;
+                const terminatorParserContext = __addDisposableResource(env_3, parserContext.lookahead({
+                    debugName: getParserName(terminatorParser, 'anonymousTerminator'),
+                }), false);
+                try {
+                    const terminatorValue = await terminatorParser(terminatorParserContext);
+                    terminatorParserContext.unlookahead();
+                    return [elements, terminatorValue];
                 }
+                catch (error) {
+                    if (!(isParserParsingFailedError(error))) {
+                        throw error;
+                    }
+                }
+                const element = await elementParser(parserContext);
+                elements.push(element);
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
             }
             finally {
-                terminatorParserContext.dispose();
+                __disposeResources(env_3);
             }
-            const element = await elementParser(parserContext);
-            elements.push(element);
         }
     };
     setParserName(terminatedArrayParserUnsafe, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);

package/build/terminatedArrayParser.test.js

@@ -13,10 +13,12 @@ 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([
+    const elementParser = createUnionParser([
         createExactElementParser(1),
         createExactElementParser(2),
-    ]), createExactElementParser(0));
+    ]);
+    const terminatorParser = createExactElementParser(0);
+    const parser = createTerminatedArrayParser(elementParser, terminatorParser);
     const input = new Uint8Array([0]);
     const result = await runParser(parser, input, uint8ArrayParserInputCompanion);
     t.deepEqual(result, [[], 0]);

package/build/tupleParser.d.ts

@@ -1,15 +1,7 @@
-import { type Parser } from './parser.js';
-export declare function createTupleParser<A, B, Sequence>([parserA, parserB]: [Parser<A, Sequence>, Parser<B, Sequence>]): Parser<[A, B], Sequence>;
-export declare function createTupleParser<A, B, C, Sequence>([parserA, parserB, parserC]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>]): Parser<[A, B, C], Sequence>;
-export declare function createTupleParser<A, B, C, D, Sequence>([parserA, parserB, parserC, parserD]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>]): Parser<[A, B, C, D], Sequence>;
-export declare function createTupleParser<A, B, C, D, E, Sequence>([parserA, parserB, parserC, parserD, parserE]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>]): Parser<[A, B, C, D, E], Sequence>;
-export declare function createTupleParser<A, B, C, D, E, F, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>]): Parser<[A, B, C, D, E, F], Sequence>;
-export declare function createTupleParser<A, B, C, D, E, F, G, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>]): Parser<[A, B, C, D, E, F, G], Sequence>;
-export declare function createTupleParser<A, B, C, D, E, F, G, H, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH]: [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<[A, B, C, D, E, F, G, H], Sequence>;
-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>;
+import { type Parser, type ParserOutput, type ParserSequence } from './parser.js';
+type TupleParserOutput<Parsers extends readonly Parser<any, any, any>[]> = {
+    [K in keyof Parsers]: Parsers[K] extends Parser<any, any, any> ? ParserOutput<Parsers[K]> : never;
+};
+type InferSequenceFromParserArray<T extends readonly unknown[]> = ParserSequence<T[number]>;
+export declare function createTupleParser<const Parsers extends readonly Parser<any, any, any>[]>(parsers: Parsers): Parser<TupleParserOutput<Parsers>, InferSequenceFromParserArray<Parsers>, any>;
+export {};

package/build/tupleParser.js

@@ -1,5 +1,6 @@
 import { getParserName, setParserName } from './parser.js';
 export function createTupleParser(parsers) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const tupleParser = async (parserContext) => {
         const values = [];
         for (const parser of parsers) {

package/build/unionParser.d.ts

@@ -1,3 +1,5 @@
-import { type Parser } from './parser.js';
-import { type DeriveSequenceElement } from './sequence.js';
-export declare const createUnionParser: <Output, Sequence, Element = DeriveSequenceElement<Sequence>>(childParsers: Array<Parser<unknown, Sequence, Element>>) => Parser<Output, Sequence, Element>;
+import { type Parser, type ParserOutput, type ParserSequence } from './parser.js';
+type UnionParserOutput<Parsers extends readonly unknown[]> = ParserOutput<Parsers[number]>;
+type InferSequenceFromParserArray<T extends readonly unknown[]> = ParserSequence<T[number]>;
+export declare function createUnionParser<const Parsers extends readonly Parser<any, any, any>[]>(childParsers: Parsers): Parser<UnionParserOutput<Parsers>, InferSequenceFromParserArray<Parsers>>;
+export {};

package/build/unionParser.js

@@ -8,10 +8,12 @@ const bigintReplacer = (_key, value) => {
     }
     return value;
 };
-export const createUnionParser = (childParsers) => {
+export function createUnionParser(childParsers) {
     parserImplementationInvariant(childParsers.length > 0, 'Union parser must have at least one child parser.');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const unionParser = async (parserContext) => {
         let runningChildParserContexts = [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const createChildParserTask = (childParser) => {
             const childParserContext = parserContext.lookahead({
                 debugName: getParserName(childParser, 'anonymousUnionChild'),
@@ -21,6 +23,7 @@ export const createUnionParser = (childParsers) => {
                 childParserContext,
             };
             runningChildParserContexts.push(context);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const getChildParserPromise = (async () => childParser(childParserContext));
             const promise = getChildParserPromise();
             return {
@@ -28,8 +31,10 @@ export const createUnionParser = (childParsers) => {
                 context,
             };
         };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const childParserResults = allSettledStream(childParsers.map(createChildParserTask));
         const parserParsingFailedErrors = [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const successfulParserOutputs = [];
         const successfulTaskContexts = [];
         let didUnlookahead = false;
@@ -80,4 +85,4 @@ export const createUnionParser = (childParsers) => {
         ')',
     ].join('');
     return setParserName(unionParser, name);
-};
+}

package/build/unionParser.test-d.d.ts

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

package/build/unionParser.test-d.js

@@ -0,0 +1,72 @@
+import { expectAssignable } from 'tsd';
+import { createUnionParser } from './unionParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+// Test: basic union of string parsers - output inferred as string
+{
+    const parser = createUnionParser([
+        createExactElementParser('a'),
+        createExactElementParser('b'),
+    ]);
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: union preserves literal types when parsers have explicit literal output types
+{
+    const parserA = async () => 'a';
+    const parserB = async () => 'b';
+    const parser = createUnionParser([parserA, parserB]);
+    // Output should be 'a' | 'b', not string
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: union of parsers with different output types
+{
+    const stringParser = createFixedLengthSequenceParser(3);
+    const numberParser = () => 42;
+    const parser = createUnionParser([
+        stringParser,
+        numberParser,
+    ]);
+    // Output should be string | number
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: nested unions
+{
+    const inner = createUnionParser([
+        createExactElementParser('a'),
+        createExactElementParser('b'),
+    ]);
+    const parser = createUnionParser([
+        inner,
+        createExactElementParser('c'),
+    ]);
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: sequence type inferred from child parsers
+{
+    const parser = createUnionParser([
+        createExactSequenceParser('hello'),
+        createExactSequenceParser('world'),
+    ]);
+    // Parser should be for string sequences, output is string (widened from literals)
+    expectAssignable(null);
+}
+// Test: single parser in union
+{
+    const parser = createUnionParser([
+        createExactSequenceParser('only'),
+    ]);
+    // Output is string (widened from literal 'only')
+    expectAssignable(null);
+}
+// Test: union of object-producing parsers
+{
+    const parser1 = async () => ({ type: 'a', value: 1 });
+    const parser2 = async () => ({ type: 'b', name: 'test' });
+    const parser = createUnionParser([parser1, parser2]);
+    expectAssignable(null);
+}