@futpib/parser 1.0.4 → 1.0.6

package/build/zigParser.js

@@ -0,0 +1,1119 @@
+import { setParserName } from './parser.js';
+import { createUnionParser } from './unionParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createArrayParser } from './arrayParser.js';
+import { createOptionalParser } from './optionalParser.js';
+import { createRegExpParser } from './regexpParser.js';
+import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
+import { createObjectParser } from './objectParser.js';
+import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { unescapeZigString } from './stringEscapes.js';
+// Whitespace (spaces, tabs, newlines)
+const zigWhitespaceParser = promiseCompose(createRegExpParser(/\s+/), match => match[0]);
+// Line comment: // ...
+const zigLineCommentParser = promiseCompose(createRegExpParser(/\/\/[^\n]*/), match => match[0]);
+// Whitespace or comment
+const zigWhitespaceOrCommentParser = createUnionParser([
+    zigWhitespaceParser,
+    zigLineCommentParser,
+]);
+// Optional whitespace/comments (skippable)
+const zigSkippableParser = createArrayParser(zigWhitespaceOrCommentParser);
+setParserName(zigSkippableParser, 'zigSkippableParser');
+// Mandatory whitespace (at least one whitespace or comment)
+const zigMandatorySkipParser = createNonEmptyArrayParser(zigWhitespaceOrCommentParser);
+setParserName(zigMandatorySkipParser, 'zigMandatorySkipParser');
+// Keywords
+const zigKeywords = new Set([
+    'addrspace', 'align', 'allowzero', 'and', 'anyframe', 'anytype',
+    'asm', 'async', 'await', 'break', 'callconv', 'catch', 'comptime',
+    'const', 'continue', 'defer', 'else', 'enum', 'errdefer', 'error',
+    'export', 'extern', 'false', 'fn', 'for', 'if', 'inline',
+    'linksection', 'noalias', 'nosuspend', 'null', 'opaque', 'or',
+    'orelse', 'packed', 'pub', 'resume', 'return', 'struct',
+    'suspend', 'switch', 'test', 'threadlocal', 'true', 'try',
+    'undefined', 'union', 'unreachable', 'var', 'volatile', 'while',
+]);
+// Identifier: [a-zA-Z_][a-zA-Z0-9_]* (not a keyword) or @"string"
+const zigIdentifierParser = createDisjunctionParser([
+    promiseCompose(createRegExpParser(/@"(?:[^"\\]|\\.)*"/), match => match[0]),
+    promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*/), match => {
+        if (zigKeywords.has(match[0])) {
+            throw Object.assign(new Error(`Expected identifier, got keyword "${match[0]}"`), { depth: 0, position: 0, furthestReadPosition: 0, furthestPeekedPosition: 0 });
+        }
+        return match[0];
+    }),
+]);
+setParserName(zigIdentifierParser, 'zigIdentifierParser');
+// Keyword parser helper
+function zigKeyword(kw) {
+    return promiseCompose(createRegExpParser(new RegExp(kw + '(?![a-zA-Z0-9_])')), match => match[0]);
+}
+// Literals
+const zigIntegerLiteralParser = promiseCompose(createRegExpParser(/0x[0-9a-fA-F][0-9a-fA-F_]*|0o[0-7][0-7_]*|0b[01][01_]*|[0-9][0-9_]*/), match => ({
+    type: 'IntegerLiteral',
+    value: match[0],
+}));
+setParserName(zigIntegerLiteralParser, 'zigIntegerLiteralParser');
+const zigFloatLiteralParser = promiseCompose(createRegExpParser(/[0-9][0-9_]*\.[0-9][0-9_]*(?:[eE][+-]?[0-9][0-9_]*)?|[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*|0x[0-9a-fA-F][0-9a-fA-F_]*\.[0-9a-fA-F][0-9a-fA-F_]*(?:[pP][+-]?[0-9][0-9_]*)?|0x[0-9a-fA-F][0-9a-fA-F_]*[pP][+-]?[0-9][0-9_]*/), match => ({
+    type: 'FloatLiteral',
+    value: match[0],
+}));
+setParserName(zigFloatLiteralParser, 'zigFloatLiteralParser');
+const zigStringLiteralParser = promiseCompose(createRegExpParser(/"(?:[^"\\]|\\.)*"/), match => ({
+    type: 'StringLiteral',
+    value: unescapeZigString(match[0].slice(1, -1)),
+}));
+setParserName(zigStringLiteralParser, 'zigStringLiteralParser');
+const zigMultilineStringLiteralParser = promiseCompose(createRegExpParser(/(?:\\\\[^\n]*\n?)+/), match => ({
+    type: 'MultilineStringLiteral',
+    value: match[0],
+}));
+setParserName(zigMultilineStringLiteralParser, 'zigMultilineStringLiteralParser');
+const zigCharLiteralParser = promiseCompose(createRegExpParser(/'(?:[^'\\]|\\.)*'/), match => ({
+    type: 'CharLiteral',
+    value: unescapeZigString(match[0].slice(1, -1)),
+}));
+setParserName(zigCharLiteralParser, 'zigCharLiteralParser');
+const zigEnumLiteralParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.'),
+    zigIdentifierParser,
+]), ([, name]) => ({
+    type: 'EnumLiteral',
+    name,
+}));
+setParserName(zigEnumLiteralParser, 'zigEnumLiteralParser');
+// Forward references via accessor parsers
+const zigExpressionParser = createParserAccessorParser(() => zigExpressionParserImpl);
+const zigTypeExprParser = createParserAccessorParser(() => zigErrorUnionExprParser);
+const zigStatementParser = createParserAccessorParser(() => zigStatementParserImpl);
+const zigBlockExprParser = createParserAccessorParser(() => zigBlockExprParserImpl);
+const zigPrefixExprParser = createParserAccessorParser(() => zigPrefixExprParserImpl);
+const zigPrimaryExprParser = createParserAccessorParser(() => zigPrimaryExprParserImpl);
+// Builtin call: @import("std"), @intCast(x), etc.
+const zigBuiltinCallExprParser = promiseCompose(createTupleParser([
+    createRegExpParser(/@[a-zA-Z_][a-zA-Z0-9_]*/),
+    zigSkippableParser,
+    createExactSequenceParser('('),
+    zigSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        zigExpressionParser,
+        zigSkippableParser,
+    ]), ([expr]) => expr), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        zigSkippableParser,
+    ]), () => ','))),
+    zigSkippableParser,
+    createOptionalParser(createExactSequenceParser(',')),
+    zigSkippableParser,
+    createExactSequenceParser(')'),
+]), ([name, , , , args]) => ({
+    type: 'BuiltinCallExpr',
+    name: name[0].slice(1),
+    args: args ?? [],
+}));
+setParserName(zigBuiltinCallExprParser, 'zigBuiltinCallExprParser');
+// Error set: error{OutOfMemory, ...}
+const zigErrorSetExprParser = promiseCompose(createTupleParser([
+    zigKeyword('error'),
+    zigSkippableParser,
+    createExactSequenceParser('{'),
+    zigSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        zigIdentifierParser,
+        zigSkippableParser,
+    ]), ([name]) => name), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        zigSkippableParser,
+    ]), () => ','))),
+    createOptionalParser(createExactSequenceParser(',')),
+    zigSkippableParser,
+    createExactSequenceParser('}'),
+]), ([, , , , names]) => ({
+    type: 'ErrorSetExpr',
+    names: names ?? [],
+}));
+setParserName(zigErrorSetExprParser, 'zigErrorSetExprParser');
+// Grouped expression: (expr)
+const zigGroupedExprParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    zigSkippableParser,
+    zigExpressionParser,
+    zigSkippableParser,
+    createExactSequenceParser(')'),
+]), ([, , inner]) => ({
+    type: 'GroupedExpr',
+    inner,
+}));
+setParserName(zigGroupedExprParser, 'zigGroupedExprParser');
+// Capture: |name|
+const zigCaptureParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('|'),
+    zigSkippableParser,
+    zigIdentifierParser,
+    zigSkippableParser,
+    createExactSequenceParser('|'),
+    zigSkippableParser,
+]), ([, , name]) => name);
+setParserName(zigCaptureParser, 'zigCaptureParser');
+// If expression: if (cond) |capture| body else |capture| elseBody
+const zigIfExprParser = promiseCompose(createTupleParser([
+    zigKeyword('if'),
+    zigSkippableParser,
+    createExactSequenceParser('('),
+    zigSkippableParser,
+    zigExpressionParser,
+    zigSkippableParser,
+    createExactSequenceParser(')'),
+    zigSkippableParser,
+    createOptionalParser(zigCaptureParser),
+    zigExpressionParser,
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        zigKeyword('else'),
+        zigSkippableParser,
+        createOptionalParser(zigCaptureParser),
+        zigExpressionParser,
+    ]), ([, , capture, body]) => ({ capture, body }))),
+]), ([, , , , condition, , , , capture, body, , elsePart]) => ({
+    type: 'IfExpr',
+    condition,
+    ...(capture ? { capture } : {}),
+    body,
+    ...(elsePart?.capture ? { elseCapture: elsePart.capture } : {}),
+    ...(elsePart ? { elseBody: elsePart.body } : {}),
+}));
+setParserName(zigIfExprParser, 'zigIfExprParser');
+// Switch expression
+const zigSwitchProngParser = promiseCompose(createTupleParser([
+    createDisjunctionParser([
+        promiseCompose(zigKeyword('else'), () => ({ isElse: true, cases: [] })),
+        promiseCompose(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+            zigExpressionParser,
+            zigSkippableParser,
+        ]), ([expr]) => expr), promiseCompose(createTupleParser([
+            createExactSequenceParser(','),
+            zigSkippableParser,
+        ]), () => ',')), (cases) => ({ isElse: false, cases })),
+    ]),
+    zigSkippableParser,
+    createExactSequenceParser('=>'),
+    zigSkippableParser,
+    createOptionalParser(zigCaptureParser),
+    zigExpressionParser,
+]), ([casesInfo, , , , capture, body]) => ({
+    type: 'SwitchProng',
+    cases: casesInfo.cases,
+    isElse: casesInfo.isElse,
+    ...(capture ? { capture } : {}),
+    body,
+}));
+const zigSwitchExprParser = promiseCompose(createTupleParser([
+    zigKeyword('switch'),
+    zigSkippableParser,
+    createExactSequenceParser('('),
+    zigSkippableParser,
+    zigExpressionParser,
+    zigSkippableParser,
+    createExactSequenceParser(')'),
+    zigSkippableParser,
+    createExactSequenceParser('{'),
+    zigSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        zigSwitchProngParser,
+        zigSkippableParser,
+    ]), ([prong]) => prong), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        zigSkippableParser,
+    ]), () => ','))),
+    createOptionalParser(createExactSequenceParser(',')),
+    zigSkippableParser,
+    createExactSequenceParser('}'),
+]), ([, , , , operand, , , , , , prongs]) => ({
+    type: 'SwitchExpr',
+    operand,
+    prongs: prongs ?? [],
+}));
+setParserName(zigSwitchExprParser, 'zigSwitchExprParser');
+// Struct init: .{ .field = value, ... }
+const zigAnonStructInitParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.'),
+    zigSkippableParser,
+    createExactSequenceParser('{'),
+    zigSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('.'),
+        zigIdentifierParser,
+        zigSkippableParser,
+        createExactSequenceParser('='),
+        zigSkippableParser,
+        zigExpressionParser,
+        zigSkippableParser,
+    ]), ([, name, , , , value]) => ({ type: 'StructInitField', name, value })), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        zigSkippableParser,
+    ]), () => ','))),
+    createOptionalParser(createExactSequenceParser(',')),
+    zigSkippableParser,
+    createExactSequenceParser('}'),
+]), ([, , , , fields]) => ({
+    type: 'StructInitExpr',
+    fields: fields ?? [],
+}));
+setParserName(zigAnonStructInitParser, 'zigAnonStructInitParser');
+// Anonymous array init: .{ expr1, expr2, ... }
+const zigAnonArrayInitParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.'),
+    zigSkippableParser,
+    createExactSequenceParser('{'),
+    zigSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        zigExpressionParser,
+        zigSkippableParser,
+    ]), ([expr]) => expr), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        zigSkippableParser,
+    ]), () => ','))),
+    createOptionalParser(createExactSequenceParser(',')),
+    zigSkippableParser,
+    createExactSequenceParser('}'),
+]), ([, , , , elements]) => ({
+    type: 'ArrayInitExpr',
+    elements: elements ?? [],
+}));
+setParserName(zigAnonArrayInitParser, 'zigAnonArrayInitParser');
+// Block expression: [label:] { statements... }
+const zigBlockExprParserImpl = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([
+        zigIdentifierParser,
+        zigSkippableParser,
+        createExactSequenceParser(':'),
+        zigSkippableParser,
+    ]), ([label]) => label)),
+    createExactSequenceParser('{'),
+    zigSkippableParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        zigStatementParser,
+        zigSkippableParser,
+    ]), ([stmt]) => stmt)),
+    createExactSequenceParser('}'),
+]), ([label, , , statements]) => ({
+    type: 'BlockExpr',
+    ...(label ? { label } : {}),
+    statements,
+}));
+setParserName(zigBlockExprParserImpl, 'zigBlockExprParserImpl');
+// Try and comptime are handled as prefix operators below
+// Identifier expression
+const zigIdentifierExprParser = promiseCompose(zigIdentifierParser, name => ({
+    type: 'Identifier',
+    name,
+}));
+setParserName(zigIdentifierExprParser, 'zigIdentifierExprParser');
+// Forward references for items defined later
+const zigFnParamListParserRef = createParserAccessorParser(() => zigFnParamListParser);
+const zigContainerMemberParserRef = createParserAccessorParser(() => zigContainerMemberParser);
+// Function prototype type expression: fn(params) returnType
+const zigFnProtoTypeExprParser = promiseCompose(createTupleParser([
+    zigKeyword('fn'),
+    zigSkippableParser,
+    zigFnParamListParserRef,
+    zigSkippableParser,
+    zigTypeExprParser,
+]), ([, , params, , returnType]) => ({
+    type: 'FnProtoType',
+    params,
+    returnType,
+}));
+setParserName(zigFnProtoTypeExprParser, 'zigFnProtoTypeExprParser');
+// Container field: name: type [align(expr)] [= default],
+const zigContainerFieldParser = promiseCompose(createTupleParser([
+    zigIdentifierParser,
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser(':'), zigSkippableParser, zigExpressionParser, zigSkippableParser]), ([, , type_]) => type_)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('align'), zigSkippableParser, createExactSequenceParser('('), zigSkippableParser, zigExpressionParser, zigSkippableParser, createExactSequenceParser(')'), zigSkippableParser]), ([, , , , expr]) => expr)),
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser('='), zigSkippableParser, zigExpressionParser, zigSkippableParser]), ([, , init]) => init)),
+    createExactSequenceParser(','),
+]), ([name, , typeExpr, alignExpr, defaultValue]) => ({
+    type: 'ContainerField',
+    name,
+    ...(typeExpr !== undefined ? { typeExpr } : {}),
+    ...(alignExpr !== undefined ? { alignExpr } : {}),
+    ...(defaultValue !== undefined ? { defaultValue } : {}),
+}));
+setParserName(zigContainerFieldParser, 'zigContainerFieldParser');
+// Anonymous struct expression: struct { members... }
+const zigStructExprParser = promiseCompose(createTupleParser([
+    zigKeyword('struct'),
+    zigSkippableParser,
+    createExactSequenceParser('{'),
+    zigSkippableParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        createDisjunctionParser([
+            zigContainerMemberParserRef,
+            zigContainerFieldParser,
+        ]),
+        zigSkippableParser,
+    ]), ([member]) => member)),
+    createExactSequenceParser('}'),
+]), ([, , , , members]) => ({
+    type: 'StructExpr',
+    members,
+}));
+setParserName(zigStructExprParser, 'zigStructExprParser');
+// Primary expression impl
+const zigPrimaryExprParserImpl = createDisjunctionParser([
+    zigBuiltinCallExprParser,
+    zigStringLiteralParser,
+    zigMultilineStringLiteralParser,
+    zigCharLiteralParser,
+    zigFloatLiteralParser,
+    zigIntegerLiteralParser,
+    promiseCompose(zigKeyword('true'), () => ({ type: 'BoolLiteral', value: true })),
+    promiseCompose(zigKeyword('false'), () => ({ type: 'BoolLiteral', value: false })),
+    promiseCompose(zigKeyword('null'), () => ({ type: 'NullLiteral' })),
+    promiseCompose(zigKeyword('undefined'), () => ({ type: 'UndefinedLiteral' })),
+    promiseCompose(zigKeyword('unreachable'), () => ({ type: 'Identifier', name: 'unreachable' })),
+    promiseCompose(zigKeyword('anytype'), () => ({ type: 'Identifier', name: 'anytype' })),
+    zigErrorSetExprParser,
+    zigIfExprParser,
+    zigSwitchExprParser,
+    zigAnonStructInitParser,
+    zigAnonArrayInitParser,
+    zigFnProtoTypeExprParser,
+    zigStructExprParser,
+    promiseCompose(zigKeyword('type'), () => ({ type: 'Identifier', name: 'type' })),
+    zigBlockExprParser,
+    zigGroupedExprParser,
+    zigEnumLiteralParser,
+    zigIdentifierExprParser,
+]);
+setParserName(zigPrimaryExprParserImpl, 'zigPrimaryExprParserImpl');
+const zigFieldAccessSuffixParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('.'),
+    zigIdentifierParser,
+]), ([, member]) => ({ kind: 'field', member }));
+const zigDerefSuffixParser = promiseCompose(createExactSequenceParser('.*'), () => ({ kind: 'deref' }));
+const zigUnwrapSuffixParser = promiseCompose(createExactSequenceParser('.?'), () => ({ kind: 'unwrap' }));
+const zigCallSuffixParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    zigSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        zigExpressionParser,
+        zigSkippableParser,
+    ]), ([expr]) => expr), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        zigSkippableParser,
+    ]), () => ','))),
+    createOptionalParser(createExactSequenceParser(',')),
+    zigSkippableParser,
+    createExactSequenceParser(')'),
+]), ([, , args]) => ({ kind: 'call', args: args ?? [] }));
+const zigIndexSuffixParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('['),
+    zigSkippableParser,
+    zigExpressionParser,
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('..'),
+        zigSkippableParser,
+        createOptionalParser(promiseCompose(createTupleParser([
+            zigExpressionParser,
+            zigSkippableParser,
+        ]), ([expr]) => expr)),
+    ]), ([, , end]) => end)),
+    createExactSequenceParser(']'),
+]), ([, , start, , sliceEnd]) => {
+    if (sliceEnd !== undefined) {
+        return { kind: 'slice', start, end: sliceEnd || undefined };
+    }
+    return { kind: 'index', index: start };
+});
+// Typed struct init suffix: { .field = value, ... }
+const zigStructInitSuffixParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('{'),
+    zigSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('.'),
+        zigIdentifierParser,
+        zigSkippableParser,
+        createExactSequenceParser('='),
+        zigSkippableParser,
+        zigExpressionParser,
+        zigSkippableParser,
+    ]), ([, name, , , , value]) => ({ type: 'StructInitField', name, value })), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        zigSkippableParser,
+    ]), () => ','))),
+    createOptionalParser(createExactSequenceParser(',')),
+    zigSkippableParser,
+    createExactSequenceParser('}'),
+]), ([, , fields]) => ({ kind: 'structInit', fields: fields ?? [] }));
+// Typed array init suffix: { expr, expr, ... }
+const zigArrayInitSuffixParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('{'),
+    zigSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        zigExpressionParser,
+        zigSkippableParser,
+    ]), ([expr]) => expr), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        zigSkippableParser,
+    ]), () => ','))),
+    createOptionalParser(createExactSequenceParser(',')),
+    zigSkippableParser,
+    createExactSequenceParser('}'),
+]), ([, , elements]) => ({ kind: 'arrayInit', elements: elements ?? [] }));
+const zigSuffixOpParser = createDisjunctionParser([
+    zigDerefSuffixParser,
+    zigUnwrapSuffixParser,
+    zigFieldAccessSuffixParser,
+    zigCallSuffixParser,
+    zigIndexSuffixParser,
+]);
+// Postfix expression: primary with suffix operations
+const zigPostfixExprParser = promiseCompose(createTupleParser([
+    zigPrimaryExprParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        zigSkippableParser,
+        zigSuffixOpParser,
+    ]), ([, op]) => op)),
+]), ([primary, suffixes]) => {
+    let result = primary;
+    for (const suffix of suffixes) {
+        switch (suffix.kind) {
+            case 'field':
+                result = { type: 'FieldAccessExpr', operand: result, member: suffix.member };
+                break;
+            case 'call':
+                result = { type: 'CallExpr', callee: result, args: suffix.args };
+                break;
+            case 'index':
+                result = { type: 'IndexExpr', operand: result, index: suffix.index };
+                break;
+            case 'slice':
+                result = { type: 'SliceExpr', operand: result, start: suffix.start, ...(suffix.end ? { end: suffix.end } : {}), ...(suffix.sentinel ? { sentinel: suffix.sentinel } : {}) };
+                break;
+            case 'deref':
+                result = { type: 'FieldAccessExpr', operand: result, member: '*' };
+                break;
+            case 'unwrap':
+                result = { type: 'FieldAccessExpr', operand: result, member: '?' };
+                break;
+            case 'structInit':
+                result = { type: 'StructInitExpr', operand: result, fields: suffix.fields };
+                break;
+            case 'arrayInit':
+                result = { type: 'ArrayInitExpr', operand: result, elements: suffix.elements };
+                break;
+        }
+    }
+    return result;
+});
+setParserName(zigPostfixExprParser, 'zigPostfixExprParser');
+// Pointer/array/slice type prefix: [*]T, [*c]T, []T, [N]T
+const zigBracketTypePrefixParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('['),
+    zigSkippableParser,
+    createDisjunctionParser([
+        promiseCompose(createRegExpParser(/\*c(?![a-zA-Z0-9_])/), () => '*c'),
+        promiseCompose(createRegExpParser(/\*(?!=)/), () => '*'),
+        promiseCompose(createExactSequenceParser(''), () => ''),
+    ]),
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser(':'), zigSkippableParser, zigExpressionParser, zigSkippableParser]), ([, , sentinel]) => sentinel)),
+    createExactSequenceParser(']'),
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('const'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('volatile'), zigMandatorySkipParser]), () => true)),
+    zigPrefixExprParser,
+]), ([, , kind, , _sentinel, , , _isConst, _isVolatile, child]) => ({
+    type: 'PointerType',
+    size: kind === '' ? 'slice' : kind === '*' ? 'many' : 'one',
+    isConst: _isConst ?? false,
+    child,
+}));
+setParserName(zigBracketTypePrefixParser, 'zigBracketTypePrefixParser');
+// Array type prefix: [N]T or [N:sentinel]T
+const zigArrayTypePrefixParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('['),
+    zigSkippableParser,
+    zigExpressionParser,
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser(':'), zigSkippableParser, zigExpressionParser, zigSkippableParser]), ([, , sentinel]) => sentinel)),
+    createExactSequenceParser(']'),
+    zigSkippableParser,
+    zigPrefixExprParser,
+]), ([, , length, , sentinel, , , child]) => ({
+    type: 'ArrayType',
+    length,
+    ...(sentinel !== undefined ? { sentinel } : {}),
+    child,
+}));
+setParserName(zigArrayTypePrefixParser, 'zigArrayTypePrefixParser');
+// Optional type prefix: ?T
+const zigOptionalTypePrefixParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('?'),
+    zigSkippableParser,
+    zigPrefixExprParser,
+]), ([, , child]) => ({
+    type: 'OptionalType',
+    child,
+}));
+// Single pointer prefix: *T, *const T
+const zigSinglePointerPrefixParser = promiseCompose(createTupleParser([
+    createRegExpParser(/\*(?![*=])/),
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('const'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('volatile'), zigMandatorySkipParser]), () => true)),
+    zigPrefixExprParser,
+]), ([, , isConst, _isVolatile, child]) => ({
+    type: 'PointerType',
+    size: 'one',
+    isConst: isConst ?? false,
+    child,
+}));
+// Prefix unary operators
+const zigPrefixUnaryParser = createDisjunctionParser([
+    zigArrayTypePrefixParser,
+    zigBracketTypePrefixParser,
+    zigOptionalTypePrefixParser,
+    zigSinglePointerPrefixParser,
+    promiseCompose(createTupleParser([
+        zigKeyword('try'),
+        zigMandatorySkipParser,
+        zigPrefixExprParser,
+    ]), ([, , operand]) => ({ type: 'TryExpr', operand })),
+    promiseCompose(createTupleParser([
+        zigKeyword('comptime'),
+        zigMandatorySkipParser,
+        zigPrefixExprParser,
+    ]), ([, , operand]) => ({ type: 'ComptimeExpr', operand })),
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('!'),
+        zigSkippableParser,
+        zigPrefixExprParser,
+    ]), ([, , operand]) => ({ type: 'UnaryExpr', operator: '!', operand })),
+    promiseCompose(createTupleParser([
+        createRegExpParser(/-(?![-=>])/),
+        zigSkippableParser,
+        zigPrefixExprParser,
+    ]), ([, , operand]) => ({ type: 'UnaryExpr', operator: '-', operand })),
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('~'),
+        zigSkippableParser,
+        zigPrefixExprParser,
+    ]), ([, , operand]) => ({ type: 'UnaryExpr', operator: '~', operand })),
+    promiseCompose(createTupleParser([
+        createRegExpParser(/&(?![&=])/),
+        zigSkippableParser,
+        zigPrefixExprParser,
+    ]), ([, , operand]) => ({ type: 'UnaryExpr', operator: '&', operand })),
+]);
+const zigPrefixExprParserImpl = createDisjunctionParser([
+    zigPrefixUnaryParser,
+    zigPostfixExprParser,
+]);
+setParserName(zigPrefixExprParserImpl, 'zigPrefixExprParserImpl');
+// Helper to build left-associative binary expression parser
+function createBinaryExprParser(operandParser, operatorParsers) {
+    return promiseCompose(createTupleParser([
+        operandParser,
+        createArrayParser(promiseCompose(createTupleParser([
+            zigSkippableParser,
+            createDisjunctionParser(operatorParsers),
+            zigSkippableParser,
+            operandParser,
+        ]), ([, op, , right]) => ({ op, right }))),
+    ]), ([left, rest]) => {
+        let result = left;
+        for (const { op, right } of rest) {
+            result = { type: 'BinaryExpr', operator: op, left: result, right };
+        }
+        return result;
+    });
+}
+// Multiplication operators
+const zigMultiplyExprParser = createBinaryExprParser(zigPrefixExprParser, [
+    promiseCompose(createRegExpParser(/\*\*(?!=)/), match => match[0]),
+    promiseCompose(createRegExpParser(/\*(?![*=])/), match => match[0]),
+    promiseCompose(createRegExpParser(/\/(?!=)/), match => match[0]),
+    promiseCompose(createRegExpParser(/%(?!=)/), match => match[0]),
+]);
+setParserName(zigMultiplyExprParser, 'zigMultiplyExprParser');
+// Addition operators
+const zigAddExprParser = createBinaryExprParser(zigMultiplyExprParser, [
+    promiseCompose(createRegExpParser(/\+\+(?!=)/), match => match[0]),
+    promiseCompose(createRegExpParser(/\+(?![+=])/), match => match[0]),
+    promiseCompose(createRegExpParser(/-(?![-=])/), match => match[0]),
+]);
+setParserName(zigAddExprParser, 'zigAddExprParser');
+// Bit shift operators
+const zigShiftExprParser = createBinaryExprParser(zigAddExprParser, [
+    promiseCompose(createRegExpParser(/<<(?!=)/), match => match[0]),
+    promiseCompose(createRegExpParser(/>>(?!=)/), match => match[0]),
+]);
+setParserName(zigShiftExprParser, 'zigShiftExprParser');
+// Bitwise operators
+const zigBitwiseExprParser = createBinaryExprParser(zigShiftExprParser, [
+    promiseCompose(createRegExpParser(/&(?![&=])/), match => match[0]),
+    promiseCompose(createRegExpParser(/\|(?![|=])/), match => match[0]),
+    promiseCompose(createRegExpParser(/\^(?!=)/), match => match[0]),
+]);
+setParserName(zigBitwiseExprParser, 'zigBitwiseExprParser');
+// Comparison operators (non-associative)
+const zigCompareExprParser = promiseCompose(createTupleParser([
+    zigBitwiseExprParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        zigSkippableParser,
+        createDisjunctionParser([
+            promiseCompose(createExactSequenceParser('=='), () => '=='),
+            promiseCompose(createExactSequenceParser('!='), () => '!='),
+            promiseCompose(createRegExpParser(/<=(?!=)/), match => match[0]),
+            promiseCompose(createRegExpParser(/>=(?!=)/), match => match[0]),
+            promiseCompose(createRegExpParser(/<(?![<=])/), match => match[0]),
+            promiseCompose(createRegExpParser(/>(?![>=])/), match => match[0]),
+        ]),
+        zigSkippableParser,
+        zigBitwiseExprParser,
+    ]), ([, op, , right]) => ({ op, right }))),
+]), ([left, rest]) => {
+    if (!rest)
+        return left;
+    return { type: 'BinaryExpr', operator: rest.op, left, right: rest.right };
+});
+setParserName(zigCompareExprParser, 'zigCompareExprParser');
+// orelse operator
+const zigOrelseExprParser = createBinaryExprParser(zigCompareExprParser, [
+    zigKeyword('orelse'),
+]);
+setParserName(zigOrelseExprParser, 'zigOrelseExprParser');
+// catch operator
+const zigCatchExprParser = promiseCompose(createTupleParser([
+    zigOrelseExprParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        zigSkippableParser,
+        zigKeyword('catch'),
+        zigSkippableParser,
+        createOptionalParser(zigCaptureParser),
+        zigOrelseExprParser,
+    ]), ([, , , _capture, right]) => right)),
+]), ([left, rest]) => {
+    let result = left;
+    for (const right of rest) {
+        result = { type: 'BinaryExpr', operator: 'catch', left: result, right };
+    }
+    return result;
+});
+setParserName(zigCatchExprParser, 'zigCatchExprParser');
+// Boolean and
+const zigAndExprParser = createBinaryExprParser(zigCatchExprParser, [
+    zigKeyword('and'),
+]);
+setParserName(zigAndExprParser, 'zigAndExprParser');
+// Boolean or
+const zigOrExprParser = createBinaryExprParser(zigAndExprParser, [
+    zigKeyword('or'),
+]);
+setParserName(zigOrExprParser, 'zigOrExprParser');
+// Error union: Type!Type
+const zigErrorUnionExprParser = promiseCompose(createTupleParser([
+    zigOrExprParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        zigSkippableParser,
+        createRegExpParser(/!(?!=)/),
+        zigSkippableParser,
+        zigOrExprParser,
+    ]), ([, , , right]) => right)),
+]), ([left, right]) => {
+    if (!right)
+        return left;
+    return { type: 'ErrorUnionType', error: left, payload: right };
+});
+setParserName(zigErrorUnionExprParser, 'zigErrorUnionExprParser');
+const zigCurlySuffixExprParser = promiseCompose(createTupleParser([
+    zigErrorUnionExprParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        zigSkippableParser,
+        createDisjunctionParser([
+            zigStructInitSuffixParser,
+            zigArrayInitSuffixParser,
+        ]),
+    ]), ([, suffix]) => suffix)),
+]), ([expr, suffix]) => {
+    if (!suffix)
+        return expr;
+    if (suffix.kind === 'structInit') {
+        return { type: 'StructInitExpr', operand: expr, fields: suffix.fields };
+    }
+    return { type: 'ArrayInitExpr', operand: expr, elements: suffix.elements };
+});
+// Expression impl
+const zigExpressionParserImpl = zigCurlySuffixExprParser;
+setParserName(zigExpressionParserImpl, 'zigExpressionParserImpl');
+// Statements
+// Variable declaration statement: [pub] [extern] [comptime] [threadlocal] const/var name [: type] [align(expr)] [= init];
+const zigVarDeclStmtParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('pub'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('extern'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('comptime'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('threadlocal'), zigMandatorySkipParser]), () => true)),
+    createDisjunctionParser([
+        promiseCompose(zigKeyword('const'), () => true),
+        promiseCompose(zigKeyword('var'), () => false),
+    ]),
+    zigMandatorySkipParser,
+    zigIdentifierParser,
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser(':'), zigSkippableParser, zigExpressionParser, zigSkippableParser]), ([, , type_]) => type_)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('align'), zigSkippableParser, createExactSequenceParser('('), zigSkippableParser, zigExpressionParser, zigSkippableParser, createExactSequenceParser(')'), zigSkippableParser]), ([, , , , expr]) => expr)),
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser('='), zigSkippableParser, zigExpressionParser, zigSkippableParser]), ([, , init]) => init)),
+    createExactSequenceParser(';'),
+]), ([isPub, isExtern, isComptime, isThreadlocal, isConst, , name, , typeExpr, alignExpr, initExpr]) => ({
+    type: 'VarDecl',
+    isConst,
+    isPub: isPub ?? false,
+    isExtern: isExtern ?? false,
+    isComptime: isComptime ?? false,
+    isThreadlocal: isThreadlocal ?? false,
+    name,
+    ...(typeExpr !== undefined ? { typeExpr } : {}),
+    ...(alignExpr !== undefined ? { alignExpr } : {}),
+    ...(initExpr !== undefined ? { initExpr } : {}),
+}));
+setParserName(zigVarDeclStmtParser, 'zigVarDeclStmtParser');
+// Return statement: return [expr];
+const zigReturnStmtParser = promiseCompose(createTupleParser([
+    zigKeyword('return'),
+    createOptionalParser(promiseCompose(createTupleParser([zigMandatorySkipParser, zigExpressionParser]), ([, expr]) => expr)),
+    zigSkippableParser,
+    createExactSequenceParser(';'),
+]), ([, value]) => ({
+    type: 'ReturnStmt',
+    ...(value !== undefined ? { value } : {}),
+}));
+setParserName(zigReturnStmtParser, 'zigReturnStmtParser');
+// Break statement: break [:label] [value];
+const zigBreakStmtParser = promiseCompose(createTupleParser([
+    zigKeyword('break'),
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser(':'), zigIdentifierParser, zigSkippableParser]), ([, label]) => label)),
+    createOptionalParser(promiseCompose(createTupleParser([zigExpressionParser, zigSkippableParser]), ([expr]) => expr)),
+    createExactSequenceParser(';'),
+]), ([, , label, value]) => ({
+    type: 'BreakStmt',
+    ...(label ? { label } : {}),
+    ...(value !== undefined ? { value } : {}),
+}));
+setParserName(zigBreakStmtParser, 'zigBreakStmtParser');
+// Continue statement: continue [:label];
+const zigContinueStmtParser = promiseCompose(createTupleParser([
+    zigKeyword('continue'),
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser(':'), zigIdentifierParser, zigSkippableParser]), ([, label]) => label)),
+    createExactSequenceParser(';'),
+]), ([, , label]) => ({
+    type: 'ContinueStmt',
+    ...(label ? { label } : {}),
+}));
+setParserName(zigContinueStmtParser, 'zigContinueStmtParser');
+// Defer/errdefer statement
+const zigDeferStmtParser = promiseCompose(createTupleParser([
+    createDisjunctionParser([
+        promiseCompose(zigKeyword('errdefer'), () => true),
+        promiseCompose(zigKeyword('defer'), () => false),
+    ]),
+    zigMandatorySkipParser,
+    createOptionalParser(zigCaptureParser),
+    zigStatementParser,
+]), ([isErrdefer, , capture, body]) => ({
+    type: 'DeferStmt',
+    isErrdefer,
+    ...(capture ? { capture } : {}),
+    body,
+}));
+setParserName(zigDeferStmtParser, 'zigDeferStmtParser');
+// If statement (produces IfExpr with statement bodies)
+const zigIfStmtParser = promiseCompose(createTupleParser([
+    zigKeyword('if'),
+    zigSkippableParser,
+    createExactSequenceParser('('),
+    zigSkippableParser,
+    zigExpressionParser,
+    zigSkippableParser,
+    createExactSequenceParser(')'),
+    zigSkippableParser,
+    createOptionalParser(zigCaptureParser),
+    zigStatementParser,
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('else'), zigSkippableParser, createOptionalParser(zigCaptureParser), zigStatementParser]), ([, , capture, body]) => ({ capture, body }))),
+]), ([, , , , condition, , , , capture, body, , elsePart]) => ({
+    type: 'IfExpr',
+    condition,
+    ...(capture ? { capture } : {}),
+    body,
+    ...(elsePart?.capture ? { elseCapture: elsePart.capture } : {}),
+    ...(elsePart ? { elseBody: elsePart.body } : {}),
+}));
+setParserName(zigIfStmtParser, 'zigIfStmtParser');
+// While statement
+const zigWhileStmtParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([zigIdentifierParser, zigSkippableParser, createExactSequenceParser(':'), zigSkippableParser]), ([label]) => label)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('inline'), zigMandatorySkipParser]), () => true)),
+    zigKeyword('while'),
+    zigSkippableParser,
+    createExactSequenceParser('('),
+    zigSkippableParser,
+    zigExpressionParser,
+    zigSkippableParser,
+    createExactSequenceParser(')'),
+    zigSkippableParser,
+    createOptionalParser(zigCaptureParser),
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser(':'), zigSkippableParser, createExactSequenceParser('('), zigSkippableParser, zigExpressionParser, zigSkippableParser, createExactSequenceParser(')'), zigSkippableParser]), ([, , , , expr]) => expr)),
+    zigStatementParser,
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('else'), zigSkippableParser, zigStatementParser]), ([, , body]) => body)),
+]), ([label, isInline, , , , , condition, , , , capture, continuation, body, , elseBody]) => ({
+    type: 'WhileStmt',
+    condition,
+    ...(capture ? { capture } : {}),
+    ...(continuation !== undefined ? { continuation } : {}),
+    body,
+    ...(elseBody !== undefined ? { elseBody } : {}),
+    ...(label ? { label } : {}),
+    isInline: isInline ?? false,
+}));
+setParserName(zigWhileStmtParser, 'zigWhileStmtParser');
+// For statement
+const zigForStmtParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([zigIdentifierParser, zigSkippableParser, createExactSequenceParser(':'), zigSkippableParser]), ([label]) => label)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('inline'), zigMandatorySkipParser]), () => true)),
+    zigKeyword('for'),
+    zigSkippableParser,
+    createExactSequenceParser('('),
+    zigSkippableParser,
+    createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([zigExpressionParser, zigSkippableParser]), ([expr]) => expr), promiseCompose(createTupleParser([createExactSequenceParser(','), zigSkippableParser]), () => ',')),
+    createExactSequenceParser(')'),
+    zigSkippableParser,
+    createExactSequenceParser('|'),
+    zigSkippableParser,
+    createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        createOptionalParser(createExactSequenceParser('*')),
+        zigSkippableParser,
+        zigIdentifierParser,
+        zigSkippableParser,
+    ]), ([star, , name]) => (star ? '*' + name : name)), promiseCompose(createTupleParser([createExactSequenceParser(','), zigSkippableParser]), () => ',')),
+    createExactSequenceParser('|'),
+    zigSkippableParser,
+    zigStatementParser,
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('else'), zigSkippableParser, zigStatementParser]), ([, , body]) => body)),
+]), ([label, isInline, , , , , inputs, , , , , captures, , , body, , elseBody]) => ({
+    type: 'ForStmt',
+    inputs,
+    captures,
+    body,
+    ...(elseBody !== undefined ? { elseBody } : {}),
+    ...(label ? { label } : {}),
+    isInline: isInline ?? false,
+}));
+setParserName(zigForStmtParser, 'zigForStmtParser');
+// Block statement (produces BlockExpr)
+const zigBlockStmtParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([zigIdentifierParser, zigSkippableParser, createExactSequenceParser(':'), zigSkippableParser]), ([label]) => label)),
+    createExactSequenceParser('{'),
+    zigSkippableParser,
+    createArrayParser(promiseCompose(createTupleParser([zigStatementParser, zigSkippableParser]), ([stmt]) => stmt)),
+    createExactSequenceParser('}'),
+]), ([label, , , statements]) => ({
+    type: 'BlockExpr',
+    ...(label ? { label } : {}),
+    statements,
+}));
+setParserName(zigBlockStmtParser, 'zigBlockStmtParser');
+// Assignment statement: expr op= expr;
+const zigAssignStmtParser = promiseCompose(createTupleParser([
+    zigExpressionParser,
+    zigSkippableParser,
+    createDisjunctionParser([
+        promiseCompose(createExactSequenceParser('<<='), () => '<<='),
+        promiseCompose(createExactSequenceParser('>>='), () => '>>='),
+        promiseCompose(createExactSequenceParser('+='), () => '+='),
+        promiseCompose(createExactSequenceParser('-='), () => '-='),
+        promiseCompose(createExactSequenceParser('*='), () => '*='),
+        promiseCompose(createExactSequenceParser('/='), () => '/='),
+        promiseCompose(createExactSequenceParser('%='), () => '%='),
+        promiseCompose(createExactSequenceParser('&='), () => '&='),
+        promiseCompose(createExactSequenceParser('|='), () => '|='),
+        promiseCompose(createExactSequenceParser('^='), () => '^='),
+        promiseCompose(createExactSequenceParser('='), () => '='),
+    ]),
+    zigSkippableParser,
+    zigExpressionParser,
+    zigSkippableParser,
+    createExactSequenceParser(';'),
+]), ([target, , operator, , value]) => ({
+    type: 'AssignStmt',
+    target,
+    operator,
+    value,
+}));
+setParserName(zigAssignStmtParser, 'zigAssignStmtParser');
+// Expression statement: expr; (returns the expression directly without wrapping)
+const zigExprStmtParser = promiseCompose(createTupleParser([
+    zigExpressionParser,
+    zigSkippableParser,
+    createExactSequenceParser(';'),
+]), ([expression]) => expression);
+setParserName(zigExprStmtParser, 'zigExprStmtParser');
+// Statement impl
+const zigStatementParserImpl = createDisjunctionParser([
+    zigVarDeclStmtParser,
+    zigReturnStmtParser,
+    zigBreakStmtParser,
+    zigContinueStmtParser,
+    zigDeferStmtParser,
+    zigIfStmtParser,
+    zigWhileStmtParser,
+    zigForStmtParser,
+    zigBlockStmtParser,
+    zigAssignStmtParser,
+    zigExprStmtParser,
+]);
+setParserName(zigStatementParserImpl, 'zigStatementParserImpl');
+// Top-level declarations
+// Function parameter
+const zigFnParamParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('comptime'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('noalias'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigIdentifierParser, zigSkippableParser, createExactSequenceParser(':'), zigSkippableParser]), ([name]) => name)),
+    zigExpressionParser,
+]), ([isComptime, isNoalias, name, typeExpr]) => ({
+    type: 'FnParam',
+    ...(name ? { name } : {}),
+    isComptime: isComptime ?? false,
+    isNoalias: isNoalias ?? false,
+    typeExpr,
+}));
+setParserName(zigFnParamParser, 'zigFnParamParser');
+// Function parameter list
+const zigFnParamListParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    zigSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([zigFnParamParser, zigSkippableParser]), ([param]) => param), promiseCompose(createTupleParser([createExactSequenceParser(','), zigSkippableParser]), () => ','))),
+    createOptionalParser(createExactSequenceParser(',')),
+    zigSkippableParser,
+    createExactSequenceParser(')'),
+]), ([, , params]) => params ?? []);
+setParserName(zigFnParamListParser, 'zigFnParamListParser');
+// Function declaration
+const zigFnDeclParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('pub'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('extern'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('export'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('inline'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('comptime'), zigMandatorySkipParser]), () => true)),
+    zigKeyword('fn'),
+    zigMandatorySkipParser,
+    zigIdentifierParser,
+    zigSkippableParser,
+    zigFnParamListParser,
+    zigSkippableParser,
+    zigTypeExprParser,
+    zigSkippableParser,
+    createDisjunctionParser([
+        zigBlockExprParser,
+        promiseCompose(createExactSequenceParser(';'), () => undefined),
+    ]),
+]), ([isPub, isExtern, isExport, isInline, isComptime, , , name, , params, , returnType, , body]) => ({
+    type: 'FnDecl',
+    isPub: isPub ?? false,
+    isExtern: isExtern ?? false,
+    isExport: isExport ?? false,
+    isInline: isInline ?? false,
+    isComptime: isComptime ?? false,
+    name,
+    params,
+    returnType,
+    ...(body !== undefined ? { body } : {}),
+}));
+setParserName(zigFnDeclParser, 'zigFnDeclParser');
+// Top-level variable declaration
+const zigVarDeclParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('pub'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('extern'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('comptime'), zigMandatorySkipParser]), () => true)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('threadlocal'), zigMandatorySkipParser]), () => true)),
+    createDisjunctionParser([
+        promiseCompose(zigKeyword('const'), () => true),
+        promiseCompose(zigKeyword('var'), () => false),
+    ]),
+    zigMandatorySkipParser,
+    zigIdentifierParser,
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser(':'), zigSkippableParser, zigExpressionParser, zigSkippableParser]), ([, , type_]) => type_)),
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('align'), zigSkippableParser, createExactSequenceParser('('), zigSkippableParser, zigExpressionParser, zigSkippableParser, createExactSequenceParser(')'), zigSkippableParser]), ([, , , , expr]) => expr)),
+    createOptionalParser(promiseCompose(createTupleParser([createExactSequenceParser('='), zigSkippableParser, zigExpressionParser, zigSkippableParser]), ([, , init]) => init)),
+    createExactSequenceParser(';'),
+]), ([isPub, isExtern, isComptime, isThreadlocal, isConst, , name, , typeExpr, alignExpr, initExpr]) => ({
+    type: 'VarDecl',
+    isConst,
+    isPub: isPub ?? false,
+    isExtern: isExtern ?? false,
+    isComptime: isComptime ?? false,
+    isThreadlocal: isThreadlocal ?? false,
+    name,
+    ...(typeExpr !== undefined ? { typeExpr } : {}),
+    ...(alignExpr !== undefined ? { alignExpr } : {}),
+    ...(initExpr !== undefined ? { initExpr } : {}),
+}));
+setParserName(zigVarDeclParser, 'zigVarDeclParser');
+// Test declaration: test ["name"] { ... }
+const zigTestDeclParser = promiseCompose(createTupleParser([
+    zigKeyword('test'),
+    zigSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([zigStringLiteralParser, zigSkippableParser]), ([str]) => str.value)),
+    zigBlockExprParser,
+]), ([, , name, body]) => ({
+    type: 'TestDecl',
+    ...(name ? { name } : {}),
+    body,
+}));
+setParserName(zigTestDeclParser, 'zigTestDeclParser');
+// Usingnamespace declaration: [pub] usingnamespace expr;
+const zigUsingnamespaceDeclParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([zigKeyword('pub'), zigMandatorySkipParser]), () => true)),
+    zigKeyword('usingnamespace'),
+    zigMandatorySkipParser,
+    zigExpressionParser,
+    zigSkippableParser,
+    createExactSequenceParser(';'),
+]), ([isPub, , , expression]) => ({
+    type: 'UsingnamespaceDecl',
+    isPub: isPub ?? false,
+    expression,
+}));
+setParserName(zigUsingnamespaceDeclParser, 'zigUsingnamespaceDeclParser');
+// Container member (top-level declaration)
+const zigContainerMemberParser = createDisjunctionParser([
+    zigFnDeclParser,
+    zigVarDeclParser,
+    zigTestDeclParser,
+    zigUsingnamespaceDeclParser,
+]);
+setParserName(zigContainerMemberParser, 'zigContainerMemberParser');
+// Root: source file
+export const zigSourceFileParser = createObjectParser({
+    _ws1: zigSkippableParser,
+    type: 'Root',
+    members: createArrayParser(promiseCompose(createTupleParser([
+        zigContainerMemberParser,
+        zigSkippableParser,
+    ]), ([member]) => member)),
+    _ws2: zigSkippableParser,
+});
+setParserName(zigSourceFileParser, 'zigSourceFileParser');