@futpib/parser 1.0.3 → 1.0.6

package/build/javascript.d.ts

@@ -0,0 +1,35 @@
+import type * as estree from 'estree';
+import { type StripMeta } from './javascriptParser.js';
+export type JavaScriptProgram = StripMeta<estree.Program>;
+export type JavaScriptStatement = StripMeta<estree.Statement>;
+export type JavaScriptExpression = StripMeta<estree.Expression>;
+export type JavaScriptIdentifier = StripMeta<estree.Identifier>;
+export type JavaScriptLiteral = StripMeta<estree.Literal>;
+export type JavaScriptBlockStatement = StripMeta<estree.BlockStatement>;
+export type JavaScriptExpressionStatement = StripMeta<estree.ExpressionStatement>;
+export type JavaScriptVariableDeclaration = StripMeta<estree.VariableDeclaration>;
+export type JavaScriptVariableDeclarator = StripMeta<estree.VariableDeclarator>;
+export type JavaScriptIfStatement = StripMeta<estree.IfStatement>;
+export type JavaScriptWhileStatement = StripMeta<estree.WhileStatement>;
+export type JavaScriptForStatement = StripMeta<estree.ForStatement>;
+export type JavaScriptReturnStatement = StripMeta<estree.ReturnStatement>;
+export type JavaScriptThrowStatement = StripMeta<estree.ThrowStatement>;
+export type JavaScriptTryStatement = StripMeta<estree.TryStatement>;
+export type JavaScriptCatchClause = StripMeta<estree.CatchClause>;
+export type JavaScriptEmptyStatement = StripMeta<estree.EmptyStatement>;
+export type JavaScriptFunctionDeclaration = StripMeta<estree.FunctionDeclaration>;
+export type JavaScriptFunctionExpression = StripMeta<estree.FunctionExpression>;
+export type JavaScriptArrowFunctionExpression = StripMeta<estree.ArrowFunctionExpression>;
+export type JavaScriptBinaryExpression = StripMeta<estree.BinaryExpression>;
+export type JavaScriptLogicalExpression = StripMeta<estree.LogicalExpression>;
+export type JavaScriptUnaryExpression = StripMeta<estree.UnaryExpression>;
+export type JavaScriptUpdateExpression = StripMeta<estree.UpdateExpression>;
+export type JavaScriptAssignmentExpression = StripMeta<estree.AssignmentExpression>;
+export type JavaScriptConditionalExpression = StripMeta<estree.ConditionalExpression>;
+export type JavaScriptCallExpression = StripMeta<estree.SimpleCallExpression>;
+export type JavaScriptNewExpression = StripMeta<estree.NewExpression>;
+export type JavaScriptMemberExpression = StripMeta<estree.MemberExpression>;
+export type JavaScriptArrayExpression = StripMeta<estree.ArrayExpression>;
+export type JavaScriptObjectExpression = StripMeta<estree.ObjectExpression>;
+export type JavaScriptProperty = StripMeta<estree.Property>;
+export type JavaScriptThisExpression = StripMeta<estree.ThisExpression>;

package/build/javascript.js

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

package/build/javascriptParser.d.ts

@@ -0,0 +1,9 @@
+import type * as estree from 'estree';
+import { type Parser } from './parser.js';
+type PositionalFields = 'loc' | 'range' | 'start' | 'end' | 'leadingComments' | 'trailingComments' | 'comments' | 'innerComments';
+export type StripMeta<T> = T extends Array<infer U> ? Array<StripMeta<U>> : T extends object ? {
+    [K in Exclude<keyof T, PositionalFields>]: StripMeta<T[K]>;
+} : T;
+export type JavaScriptProgram = StripMeta<estree.Program>;
+export declare const javascriptProgramParser: Parser<JavaScriptProgram, string>;
+export {};

package/build/javascriptParser.js

@@ -0,0 +1,34 @@
+import * as acorn from 'acorn';
+import { promiseCompose } from './promiseCompose.js';
+import { createRegExpParser } from './regexpParser.js';
+function stripMeta(node) {
+    if (node === null || node === undefined) {
+        return node;
+    }
+    if (typeof node !== 'object') {
+        return node;
+    }
+    if (Array.isArray(node)) {
+        return node.map(element => stripMeta(element));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'loc'
+            || key === 'range'
+            || key === 'start'
+            || key === 'end'
+            || key === 'raw'
+            || key === 'leadingComments'
+            || key === 'trailingComments'
+            || key === 'comments'
+            || key === 'innerComments') {
+            continue;
+        }
+        result[key] = stripMeta(value);
+    }
+    return result;
+}
+export const javascriptProgramParser = promiseCompose(createRegExpParser(/[\s\S]*/), match => {
+    const ast = acorn.parse(match[0], { ecmaVersion: 'latest', sourceType: 'script' });
+    return stripMeta(ast);
+});

package/build/javascriptUnparser.d.ts

@@ -0,0 +1,3 @@
+import { type Unparser } from './unparser.js';
+import { type JavaScriptProgram } from './javascriptParser.js';
+export declare const javascriptProgramUnparser: Unparser<JavaScriptProgram, string>;

package/build/javascriptUnparser.js

@@ -0,0 +1,4 @@
+import { generate } from 'astring';
+export const javascriptProgramUnparser = async function* (program) {
+    yield generate(program);
+};

package/build/javascriptUnparser.test.d.ts

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

package/build/javascriptUnparser.test.js

@@ -0,0 +1,24 @@
+import { testProp } from '@fast-check/ava';
+import { arbitraryJavascriptProgram } from './arbitraryJavascript.js';
+import { javascriptProgramUnparser } from './javascriptUnparser.js';
+import { javascriptProgramParser } from './javascriptParser.js';
+import { runParser } from './parser.js';
+import { runUnparser } from './unparser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+async function collectString(asyncIterable) {
+    let result = '';
+    for await (const chunk of asyncIterable) {
+        result += chunk;
+    }
+    return result;
+}
+testProp('javascript roundtrip', [arbitraryJavascriptProgram], async (t, program) => {
+    const source = await collectString(runUnparser(javascriptProgramUnparser, program, stringUnparserOutputCompanion));
+    const reparsed = await runParser(javascriptProgramParser, source, stringParserInputCompanion);
+    t.deepEqual(reparsed, program);
+}, {
+    verbose: true,
+    seed,
+});

package/build/jsonParser.js

@@ -11,6 +11,7 @@ import { createParserAccessorParser } from './parserAccessorParser.js';
 import { createElementParser } from './elementParser.js';
 import { parserCreatorCompose } from './parserCreatorCompose.js';
 import { createSeparatedArrayParser } from './separatedArrayParser.js';
+import { createRegExpParser } from './regexpParser.js';
 const whitespaceParser = createArrayParser(createUnionParser([
     createExactSequenceParser(' '),
     createExactSequenceParser('\t'),
@@ -52,18 +53,7 @@ export const jsonStringParser = promiseCompose(createTupleParser([
     createExactSequenceParser('"'),
     promiseCompose(createTerminatedArrayParser(jsonStringCharacterParser, createExactSequenceParser('"')), ([characters]) => characters.join('')),
 ]), ([, string]) => string);
-export const jsonNumberParser = parserCreatorCompose(() => createArrayParser(parserCreatorCompose(() => elementParser, character => async (parserContext) => {
-    parserContext.invariant((character === '-'
-        || (character >= '0' && character <= '9')
-        || character === '.'
-        || character === 'e'
-        || character === 'E'
-        || character === '+'), 'Expected "-", "0" to "9", ".", "e", "E", "+", got "%s"', character);
-    return character;
-})()), characters => async (parserContext) => {
-    parserContext.invariant(characters.length > 0, 'Expected at least one character');
-    return Number(characters.join(''));
-})();
+export const jsonNumberParser = promiseCompose(createRegExpParser(/-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/), match => Number(match[0]));
 const jsonTrueParser = promiseCompose(createExactSequenceParser('true'), () => true);
 setParserName(jsonTrueParser, 'jsonTrueParser');
 const jsonFalseParser = promiseCompose(createExactSequenceParser('false'), () => false);

package/build/lazyMessageError.d.ts

@@ -14,6 +14,7 @@ export declare function createLazyMessageErrorClass(BaseError: typeof NoStackCap
         stack?: string;
         cause?: unknown;
     };
+    isError(error: unknown): error is Error;
     captureStackTrace(targetObject: object, constructorOpt?: Function): void;
     prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
     stackTraceLimit: number;
@@ -27,6 +28,7 @@ export declare const NormalLazyMessageError: {
         stack?: string;
         cause?: unknown;
     };
+    isError(error: unknown): error is Error;
     captureStackTrace(targetObject: object, constructorOpt?: Function): void;
     prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
     stackTraceLimit: number;
@@ -40,6 +42,7 @@ export declare const NoStackCaptureOverheadLazyMessageError: {
         stack?: string;
         cause?: unknown;
     };
+    isError(error: unknown): error is Error;
     captureStackTrace(targetObject: object, constructorOpt?: Function): void;
     prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
     stackTraceLimit: number;

package/build/lookaheadParser.js

@@ -1,12 +1,69 @@
+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';
 export const createLookaheadParser = (childParser) => {
     const lookaheadParser = async (parserContext) => {
-        const childParserContext = parserContext.lookahead();
+        const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            return await childParser(childParserContext);
+            const childParserContext = __addDisposableResource(env_1, parserContext.lookahead(), false);
+            return childParser(childParserContext);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
         }
         finally {
-            childParserContext.dispose();
+            __disposeResources(env_1);
         }
     };
     setParserName(lookaheadParser, `(?=${getParserName(childParser)})`);

package/build/negativeLookaheadParser.js

@@ -1,23 +1,82 @@
+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';
 export const createNegativeLookaheadParser = (childParser) => {
     const negativeLookaheadParser = async (parserContext) => {
-        const childParserContext = parserContext.lookahead();
-        let childParserSuccess;
+        const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            await childParser(childParserContext);
-            childParserSuccess = true;
-        }
-        catch (error) {
-            if (!isParserParsingFailedError(error)) {
-                throw error;
+            const childParserContext = __addDisposableResource(env_1, parserContext.lookahead(), false);
+            let childParserSuccess;
+            try {
+                await childParser(childParserContext);
+                childParserSuccess = true;
             }
-            childParserSuccess = false;
+            catch (error) {
+                if (!isParserParsingFailedError(error)) {
+                    throw error;
+                }
+                childParserSuccess = false;
+            }
+            parserContext.invariant(!childParserSuccess, 'Negative lookahead assertion failed for child parser %s.', getParserName(childParser));
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
         }
         finally {
-            childParserContext.dispose();
+            __disposeResources(env_1);
         }
-        parserContext.invariant(!childParserSuccess, 'Negative lookahead assertion failed for child parser %s.', getParserName(childParser));
     };
     setParserName(negativeLookaheadParser, `(?!${getParserName(childParser)})`);
     return negativeLookaheadParser;

package/build/nonEmptyArrayParser.js

@@ -1,27 +1,86 @@
+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';
 export const createNonEmptyArrayParser = (elementParser) => {
     const nonEmptyArrayParser = async (parserContext) => {
         const elements = [];
         while (true) {
-            const elementParserContext = parserContext.lookahead();
-            const initialPosition = elementParserContext.position;
+            const env_1 = { stack: [], error: void 0, hasError: false };
             try {
-                const element = await elementParser(elementParserContext);
-                if (elementParserContext.position === initialPosition) {
-                    break;
+                const elementParserContext = __addDisposableResource(env_1, parserContext.lookahead(), false);
+                const initialPosition = elementParserContext.position;
+                try {
+                    const element = await elementParser(elementParserContext);
+                    if (elementParserContext.position === initialPosition) {
+                        break;
+                    }
+                    elements.push(element);
+                    elementParserContext.unlookahead();
                 }
-                elements.push(element);
-                elementParserContext.unlookahead();
-            }
-            catch (error) {
-                if (isParserParsingFailedError(error)) {
-                    break;
+                catch (error) {
+                    if (isParserParsingFailedError(error)) {
+                        break;
+                    }
+                    throw error;
                 }
-                throw error;
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
             }
             finally {
-                elementParserContext.dispose();
+                __disposeResources(env_1);
             }
         }
         parserContext.invariant(elements.length > 0, 'Expected elementParser (%s) to match at least once', getParserName(elementParser, 'anonymousNonEmptyArrayChild'));

package/build/objectParser.d.ts

@@ -0,0 +1,12 @@
+import { type Parser, type ParserOutput, type ParserSequence } from './parser.js';
+type ExtractParsers<T> = T[keyof T] & Parser<any, any, any>;
+type InferSequenceFromParsers<T> = ParserSequence<ExtractParsers<T>>;
+type ExtractOutputOrLiteral<P> = P extends Parser<any, any, any> ? ParserOutput<P> : P;
+type OmitUnderscoreKeys<T> = {
+    [K in keyof T as K extends `_${string}` ? never : K]: T[K];
+};
+type ObjectParserOutput<Parsers extends Record<string, unknown>> = OmitUnderscoreKeys<{
+    [K in keyof Parsers]: ExtractOutputOrLiteral<Parsers[K]>;
+}>;
+export declare function createObjectParser<const Parsers extends Record<string, Parser<any, any, any> | unknown>>(parsers: Parsers): Parser<ObjectParserOutput<Parsers>, InferSequenceFromParsers<Parsers>>;
+export {};

package/build/objectParser.js

@@ -0,0 +1,31 @@
+import { getParserName, setParserName } from './parser.js';
+export function createObjectParser(parsers) {
+    const objectParser = async (parserContext) => {
+        const result = {};
+        for (const [key, parserOrLiteral] of Object.entries(parsers)) {
+            let value;
+            if (typeof parserOrLiteral === 'function') {
+                // It's a parser - execute it
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                value = await parserOrLiteral(parserContext);
+            }
+            else {
+                // It's a literal - use directly
+                value = parserOrLiteral;
+            }
+            if (!key.startsWith('_')) {
+                result[key] = value;
+            }
+        }
+        return result;
+    };
+    setParserName(objectParser, '{' + Object.keys(parsers).map(k => {
+        const v = parsers[k];
+        if (typeof v === 'function') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return k.startsWith('_') ? k : getParserName(v, k);
+        }
+        return `${k}: ${JSON.stringify(v)}`;
+    }).join(', ') + '}');
+    return objectParser;
+}

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

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

package/build/objectParser.test-d.js

@@ -0,0 +1,112 @@
+import { expectAssignable, expectNotAssignable, expectType } from 'tsd';
+import { createObjectParser } from './objectParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+// Test: parsers only - extracts output types
+{
+    const parser = createObjectParser({
+        first: createFixedLengthSequenceParser(3),
+        second: createFixedLengthSequenceParser(3),
+    });
+    // Output should be assignable to and from expected type
+    expectAssignable(null);
+    expectAssignable(null);
+}
+// Test: literal types are preserved
+{
+    const parser = createObjectParser({
+        type: 'block',
+        name: createFixedLengthSequenceParser(3),
+    });
+    // 'block' literal should be preserved
+    expectAssignable(null);
+    expectType(null);
+}
+// Test: underscore keys excluded from result type
+{
+    const parser = createObjectParser({
+        first: createFixedLengthSequenceParser(3),
+        _sep: createExactSequenceParser(':'),
+        second: createFixedLengthSequenceParser(3),
+    });
+    // Should have first and second but not _sep
+    expectAssignable(null);
+    // _sep should NOT be a key in Output
+    expectNotAssignable(null);
+}
+// Test: mixed literals and parsers with underscore keys
+{
+    const parser = createObjectParser({
+        type: 'assignment',
+        _open: createExactSequenceParser('('),
+        name: createFixedLengthSequenceParser(1),
+        _eq: createExactSequenceParser('='),
+        value: createFixedLengthSequenceParser(1),
+        _close: createExactSequenceParser(')'),
+    });
+    expectAssignable(null);
+    expectType(null);
+    // Underscore keys should not exist
+    expectNotAssignable(null);
+    expectNotAssignable(null);
+    expectNotAssignable(null);
+}
+// Test: number literal
+{
+    const parser = createObjectParser({
+        code: 42,
+        data: createFixedLengthSequenceParser(2),
+    });
+    expectAssignable(null);
+    expectType(null);
+}
+// Test: all underscore keys results in empty object
+{
+    const parser = createObjectParser({
+        _a: createExactSequenceParser('a'),
+        _b: createExactSequenceParser('b'),
+    });
+    // Should be assignable to empty object
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    expectAssignable(null);
+    // Should NOT have _a or _b
+    expectNotAssignable(null);
+    expectNotAssignable(null);
+}
+// Test: boolean literal
+{
+    const parser = createObjectParser({
+        enabled: true,
+        name: createFixedLengthSequenceParser(3),
+    });
+    expectAssignable(null);
+    expectType(null);
+}
+// Test: null literal
+{
+    const parser = createObjectParser({
+        value: null,
+        name: createFixedLengthSequenceParser(3),
+    });
+    expectAssignable(null);
+    expectType(null);
+}
+// Test: underscore-prefixed parsers still contribute to sequence type inference
+{
+    const parser = createObjectParser({
+        _prefix: createExactSequenceParser(Buffer.from([0x00])),
+        operation: 'nop',
+    });
+    // Parser should be assignable to Parser<{ operation: 'nop' }, Uint8Array>
+    expectAssignable(parser);
+}
+// Test: sequence type inferred from underscore parser when no other parsers present
+{
+    const parser = createObjectParser({
+        _marker: createExactSequenceParser('test'),
+        type: 'marker',
+        value: 42,
+    });
+    // Should infer string sequence from _marker parser
+    expectAssignable(parser);
+}

package/build/objectParser.test.d.ts

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