Commit 39023329229279b6eb0ddfd4879d15ad9644375e | zig

author	Isaac Freund <mail@isaacfreund.com> 2026-06-15 11:28:11+02:00
committer	Isaac Freund <mail@isaacfreund.com> 2026-07-08 11:48:57+02:00
log	39023329229279b6eb0ddfd4879d15ad9644375e
tree	4da2d06ee95150b4c3510e03afc5d1bb5f76933d
parent	5c2510ba58d2c5b0b3082244ab9b9320662d1d65
signature	Commit is signed but in an unrecognized format.

grammar: rework whitespace handling

The grammar needs to be fixed to match Parse.zig's "operator has
whitespace on one side but not the other" error, which is implemented
in Parse.zig using a constant lookbehind of 1.

However, standard PEG does not support lookbehind, which means our
approach to handling whitespace needs to be reworked.

Moving the `skip` non-terminal to be processed before each "token"
in the grammar rather than afterwards makes it possible to cleanly
match the Parse.zig operator whitespace handling, which will be
implemented in the next commit.

This commit is purely a refactor, no functional changes are intended.

2 files changed, 350 insertions(+), 316 deletions(-)

doc
- langref
  - grammar.peg
lib
- std
  - zig
    parser_generated_oracle.zig

doc/langref/grammar.peg+124-124

...	@@ -1,4 +1,4 @@	...	@@ -1,4 +1,4 @@
1	Root <- skip ContainerMembers eof	1	Root <- ContainerMembers skip eof
2		2
3	# * Top level *	3	# * Top level *
4	ContainerMembers <- container_doc_comment? ContainerDeclaration* (ContainerField COMMA)* (ContainerField / ContainerDeclaration*)	4	ContainerMembers <- container_doc_comment? ContainerDeclaration* (ContainerField COMMA)* (ContainerField / ContainerDeclaration*)
...	@@ -430,8 +430,8 @@ string_char	...	@@ -430,8 +430,8 @@ string_char
430	<- '\\"'	430	<- '\\"'
431	/ !["] non_control_utf8	431	/ !["] non_control_utf8
432		432
433	container_doc_comment <- ('//!' non_control_utf8* newline skip)+	433	container_doc_comment <- (skip '//!' non_control_utf8* newline)+
434	doc_comment <- ('///' non_control_utf8* newline skip)+	434	doc_comment <- (skip '///' non_control_utf8* newline)+
435	line_comment	435	line_comment
436	<- '//' ![!/] non_control_utf8* newline	436	<- '//' ![!/] non_control_utf8* newline
437	/ '////' non_control_utf8* newline	437	/ '////' non_control_utf8* newline
...	@@ -439,137 +439,137 @@ line_string <- '\\\\' non_control_utf8* newline	...	@@ -439,137 +439,137 @@ line_string <- '\\\\' non_control_utf8* newline
439	newline <- "\n" / "\r\n" / eof	439	newline <- "\n" / "\r\n" / eof
440	skip <- ([ \n\t\r] / line_comment)*	440	skip <- ([ \n\t\r] / line_comment)*
441		441
442	CHAR_LITERAL <- ['] char_char* ['] skip	442	CHAR_LITERAL <- skip ['] char_char* [']
443		443
444	digit <- [_0-9A-DF-OQ-Za-df-oq-z]	444	digit <- [_0-9A-DF-OQ-Za-df-oq-z]
445	digit_int <- digit / [eEpP]	445	digit_int <- digit / [eEpP]
446	digit_float <- digit / [eEpP] [-+]?	446	digit_float <- digit / [eEpP] [-+]?
447	NUMBERLITERAL	447	NUMBERLITERAL
448	<- [0-9] digit_int* '.' digit_float+ skip	448	<- skip [0-9] digit_int* '.' digit_float+
449	/ [0-9] digit_float* skip	449	/ skip [0-9] digit_float*
450		450
451		451
452	STRINGLITERALSINGLE <- ["] string_char* ["] skip	452	STRINGLITERALSINGLE <- skip ["] string_char* ["]
453	STRINGLITERAL	453	STRINGLITERAL
454	<- STRINGLITERALSINGLE	454	<- STRINGLITERALSINGLE
455	/ (line_string skip)+	455	/ (skip line_string)+
456	IDENTIFIER	456	IDENTIFIER
457	<- !keyword [A-Za-z_] [A-Za-z0-9_]* skip	457	<- skip !keyword [A-Za-z_] [A-Za-z0-9_]*
458	/ '@' STRINGLITERALSINGLE	458	/ skip '@' STRINGLITERALSINGLE
459	BUILTINIDENTIFIER <- '@'[A-Za-z_][A-Za-z0-9_]* skip	459	BUILTINIDENTIFIER <- skip '@'[A-Za-z_][A-Za-z0-9_]*
460		460
461		461
462	AMPERSAND <- '&' ![=] skip	462	AMPERSAND <- skip '&' ![=]
463	AMPERSANDEQUAL <- '&=' skip	463	AMPERSANDEQUAL <- skip '&='
464	ASTERISK <- '*' ![%=\|] skip	464	ASTERISK <- skip '*' ![%=\|]
465	ASTERISKEQUAL <- '*=' skip	465	ASTERISKEQUAL <- skip '*='
466	ASTERISKPERCENT <- '*%' ![=] skip	466	ASTERISKPERCENT <- skip '*%' ![=]
467	ASTERISKPERCENTEQUAL <- '*%=' skip	467	ASTERISKPERCENTEQUAL <- skip '*%='
468	ASTERISKPIPE <- '*\|' ![=] skip	468	ASTERISKPIPE <- skip '*\|' ![=]
469	ASTERISKPIPEEQUAL <- '*\|=' skip	469	ASTERISKPIPEEQUAL <- skip '*\|='
470	CARET <- '^' ![=] skip	470	CARET <- skip '^' ![=]
471	CARETEQUAL <- '^=' skip	471	CARETEQUAL <- skip '^='
472	COLON <- ':' skip	472	COLON <- skip ':'
473	COMMA <- ',' skip	473	COMMA <- skip ','
474	DOT <- '.' ![*.?] skip	474	DOT <- skip '.' ![*.?]
475	DOT2 <- '..' ![.] skip	475	DOT2 <- skip '..' ![.]
476	DOT3 <- '...' skip	476	DOT3 <- skip '...'
477	DOTASTERISK <- '.*' skip	477	DOTASTERISK <- skip '.*'
478	DOTQUESTIONMARK <- '.?' skip	478	DOTQUESTIONMARK <- skip '.?'
479	EQUAL <- '=' ![>=] skip	479	EQUAL <- skip '=' ![>=]
480	EQUALEQUAL <- '==' skip	480	EQUALEQUAL <- skip '=='
481	EQUALRARROW <- '=>' skip	481	EQUALRARROW <- skip '=>'
482	EXCLAMATIONMARK <- '!' ![=] skip	482	EXCLAMATIONMARK <- skip '!' ![=]
483	EXCLAMATIONMARKEQUAL <- '!=' skip	483	EXCLAMATIONMARKEQUAL <- skip '!='
484	LARROW <- '<' ![<=] skip	484	LARROW <- skip '<' ![<=]
485	LARROW2 <- '<<' ![=\|] skip	485	LARROW2 <- skip '<<' ![=\|]
486	LARROW2EQUAL <- '<<=' skip	486	LARROW2EQUAL <- skip '<<='
487	LARROW2PIPE <- '<<\|' ![=] skip	487	LARROW2PIPE <- skip '<<\|' ![=]
488	LARROW2PIPEEQUAL <- '<<\|=' skip	488	LARROW2PIPEEQUAL <- skip '<<\|='
489	LARROWEQUAL <- '<=' skip	489	LARROWEQUAL <- skip '<='
490	LBRACE <- '{' skip	490	LBRACE <- skip '{'
491	LBRACKET <- '[' skip	491	LBRACKET <- skip '['
492	LPAREN <- '(' skip	492	LPAREN <- skip '('
493	MINUS <- '-' ![%=>\|] skip	493	MINUS <- skip '-' ![%=>\|]
494	MINUSEQUAL <- '-=' skip	494	MINUSEQUAL <- skip '-='
495	MINUSPERCENT <- '-%' ![=] skip	495	MINUSPERCENT <- skip '-%' ![=]
496	MINUSPERCENTEQUAL <- '-%=' skip	496	MINUSPERCENTEQUAL <- skip '-%='
497	MINUSPIPE <- '-\|' ![=] skip	497	MINUSPIPE <- skip '-\|' ![=]
498	MINUSPIPEEQUAL <- '-\|=' skip	498	MINUSPIPEEQUAL <- skip '-\|='
499	MINUSRARROW <- '->' skip	499	MINUSRARROW <- skip '->'
500	PERCENT <- '%' ![=] skip	500	PERCENT <- skip '%' ![=]
501	PERCENTEQUAL <- '%=' skip	501	PERCENTEQUAL <- skip '%='
502	PIPE <- '\|' ![\|=] skip	502	PIPE <- skip '\|' ![\|=]
503	PIPE2 <- '\|\|' skip	503	PIPE2 <- skip '\|\|'
504	PIPEEQUAL <- '\|=' skip	504	PIPEEQUAL <- skip '\|='
505	PLUS <- '+' ![%+=\|] skip	505	PLUS <- skip '+' ![%+=\|]
506	PLUS2 <- '++' skip	506	PLUS2 <- skip '++'
507	PLUSEQUAL <- '+=' skip	507	PLUSEQUAL <- skip '+='
508	PLUSPERCENT <- '+%' ![=] skip	508	PLUSPERCENT <- skip '+%' ![=]
509	PLUSPERCENTEQUAL <- '+%=' skip	509	PLUSPERCENTEQUAL <- skip '+%='
510	PLUSPIPE <- '+\|' ![=] skip	510	PLUSPIPE <- skip '+\|' ![=]
511	PLUSPIPEEQUAL <- '+\|=' skip	511	PLUSPIPEEQUAL <- skip '+\|='
512	LETTERC <- 'c' skip	512	LETTERC <- skip 'c'
513	QUESTIONMARK <- '?' skip	513	QUESTIONMARK <- skip '?'
514	RARROW <- '>' ![>=] skip	514	RARROW <- skip '>' ![>=]
515	RARROW2 <- '>>' ![=] skip	515	RARROW2 <- skip '>>' ![=]
516	RARROW2EQUAL <- '>>=' skip	516	RARROW2EQUAL <- skip '>>='
517	RARROWEQUAL <- '>=' skip	517	RARROWEQUAL <- skip '>='
518	RBRACE <- '}' skip	518	RBRACE <- skip '}'
519	RBRACKET <- ']' skip	519	RBRACKET <- skip ']'
520	RPAREN <- ')' skip	520	RPAREN <- skip ')'
521	SEMICOLON <- ';' skip	521	SEMICOLON <- skip ';'
522	SLASH <- '/' ![=] skip	522	SLASH <- skip '/' ![=]
523	SLASHEQUAL <- '/=' skip	523	SLASHEQUAL <- skip '/='
524	TILDE <- '~' skip	524	TILDE <- skip '~'
525		525
526	end_of_word <- ![a-zA-Z0-9_] skip	526	end_of_word <- ![a-zA-Z0-9_]
527	KEYWORD_addrspace <- 'addrspace' end_of_word	527	KEYWORD_addrspace <- skip 'addrspace' end_of_word
528	KEYWORD_align <- 'align' end_of_word	528	KEYWORD_align <- skip 'align' end_of_word
529	KEYWORD_allowzero <- 'allowzero' end_of_word	529	KEYWORD_allowzero <- skip 'allowzero' end_of_word
530	KEYWORD_and <- 'and' end_of_word	530	KEYWORD_and <- skip 'and' end_of_word
531	KEYWORD_anyframe <- 'anyframe' end_of_word	531	KEYWORD_anyframe <- skip 'anyframe' end_of_word
532	KEYWORD_anytype <- 'anytype' end_of_word	532	KEYWORD_anytype <- skip 'anytype' end_of_word
533	KEYWORD_asm <- 'asm' end_of_word	533	KEYWORD_asm <- skip 'asm' end_of_word
534	KEYWORD_break <- 'break' end_of_word	534	KEYWORD_break <- skip 'break' end_of_word
535	KEYWORD_callconv <- 'callconv' end_of_word	535	KEYWORD_callconv <- skip 'callconv' end_of_word
536	KEYWORD_catch <- 'catch' end_of_word	536	KEYWORD_catch <- skip 'catch' end_of_word
537	KEYWORD_comptime <- 'comptime' end_of_word	537	KEYWORD_comptime <- skip 'comptime' end_of_word
538	KEYWORD_const <- 'const' end_of_word	538	KEYWORD_const <- skip 'const' end_of_word
539	KEYWORD_continue <- 'continue' end_of_word	539	KEYWORD_continue <- skip 'continue' end_of_word
540	KEYWORD_defer <- 'defer' end_of_word	540	KEYWORD_defer <- skip 'defer' end_of_word
541	KEYWORD_else <- 'else' end_of_word	541	KEYWORD_else <- skip 'else' end_of_word
542	KEYWORD_enum <- 'enum' end_of_word	542	KEYWORD_enum <- skip 'enum' end_of_word
543	KEYWORD_errdefer <- 'errdefer' end_of_word	543	KEYWORD_errdefer <- skip 'errdefer' end_of_word
544	KEYWORD_error <- 'error' end_of_word	544	KEYWORD_error <- skip 'error' end_of_word
545	KEYWORD_export <- 'export' end_of_word	545	KEYWORD_export <- skip 'export' end_of_word
546	KEYWORD_extern <- 'extern' end_of_word	546	KEYWORD_extern <- skip 'extern' end_of_word
547	KEYWORD_fn <- 'fn' end_of_word	547	KEYWORD_fn <- skip 'fn' end_of_word
548	KEYWORD_for <- 'for' end_of_word	548	KEYWORD_for <- skip 'for' end_of_word
549	KEYWORD_if <- 'if' end_of_word	549	KEYWORD_if <- skip 'if' end_of_word
550	KEYWORD_inline <- 'inline' end_of_word	550	KEYWORD_inline <- skip 'inline' end_of_word
551	KEYWORD_noalias <- 'noalias' end_of_word	551	KEYWORD_noalias <- skip 'noalias' end_of_word
552	KEYWORD_nosuspend <- 'nosuspend' end_of_word	552	KEYWORD_nosuspend <- skip 'nosuspend' end_of_word
553	KEYWORD_noinline <- 'noinline' end_of_word	553	KEYWORD_noinline <- skip 'noinline' end_of_word
554	KEYWORD_opaque <- 'opaque' end_of_word	554	KEYWORD_opaque <- skip 'opaque' end_of_word
555	KEYWORD_or <- 'or' end_of_word	555	KEYWORD_or <- skip 'or' end_of_word
556	KEYWORD_orelse <- 'orelse' end_of_word	556	KEYWORD_orelse <- skip 'orelse' end_of_word
557	KEYWORD_packed <- 'packed' end_of_word	557	KEYWORD_packed <- skip 'packed' end_of_word
558	KEYWORD_pub <- 'pub' end_of_word	558	KEYWORD_pub <- skip 'pub' end_of_word
559	KEYWORD_resume <- 'resume' end_of_word	559	KEYWORD_resume <- skip 'resume' end_of_word
560	KEYWORD_return <- 'return' end_of_word	560	KEYWORD_return <- skip 'return' end_of_word
561	KEYWORD_linksection <- 'linksection' end_of_word	561	KEYWORD_linksection <- skip 'linksection' end_of_word
562	KEYWORD_struct <- 'struct' end_of_word	562	KEYWORD_struct <- skip 'struct' end_of_word
563	KEYWORD_suspend <- 'suspend' end_of_word	563	KEYWORD_suspend <- skip 'suspend' end_of_word
564	KEYWORD_switch <- 'switch' end_of_word	564	KEYWORD_switch <- skip 'switch' end_of_word
565	KEYWORD_test <- 'test' end_of_word	565	KEYWORD_test <- skip 'test' end_of_word
566	KEYWORD_threadlocal <- 'threadlocal' end_of_word	566	KEYWORD_threadlocal <- skip 'threadlocal' end_of_word
567	KEYWORD_try <- 'try' end_of_word	567	KEYWORD_try <- skip 'try' end_of_word
568	KEYWORD_union <- 'union' end_of_word	568	KEYWORD_union <- skip 'union' end_of_word
569	KEYWORD_unreachable <- 'unreachable' end_of_word	569	KEYWORD_unreachable <- skip 'unreachable' end_of_word
570	KEYWORD_var <- 'var' end_of_word	570	KEYWORD_var <- skip 'var' end_of_word
571	KEYWORD_volatile <- 'volatile' end_of_word	571	KEYWORD_volatile <- skip 'volatile' end_of_word
572	KEYWORD_while <- 'while' end_of_word	572	KEYWORD_while <- skip 'while' end_of_word
573		573
574	keyword <- KEYWORD_addrspace / KEYWORD_align / KEYWORD_allowzero / KEYWORD_and	574	keyword <- KEYWORD_addrspace / KEYWORD_align / KEYWORD_allowzero / KEYWORD_and
575	/ KEYWORD_anyframe / KEYWORD_anytype / KEYWORD_asm	575	/ KEYWORD_anyframe / KEYWORD_anytype / KEYWORD_asm

lib/std/zig/parser_generated_oracle.zig+226-192

...	@@ -16,7 +16,7 @@ const Parser = struct {	...	@@ -16,7 +16,7 @@ const Parser = struct {
16	pub fn parseRoot(p: *Parser) bool {	16	pub fn parseRoot(p: *Parser) bool {
17	return blk_0: {	17	return blk_0: {
18	const pos_0 = p.i;	18	const pos_0 = p.i;
19	if (p.parseskip() and p.parseContainerMembers() and p.parseeof()) break :blk_0 true;	19	if (p.parseContainerMembers() and p.parseskip() and p.parseeof()) break :blk_0 true;
20	p.i = pos_0;	20	p.i = pos_0;
21	break :blk_0 false;	21	break :blk_0 false;
22	};	22	};
...	@@ -612,6 +612,40 @@ const Parser = struct {	...	@@ -612,6 +612,40 @@ const Parser = struct {
612	break :blk_0 false;	612	break :blk_0 false;
613	};	613	};
614	}	614	}
		615	pub fn parseBinOp(p: *Parser) bool {
		616	return blk_0: {
		617	const pos_0 = p.i;
		618	if (p.parseExpr() and blk_1: {
		619	while (blk_3: {
		620	const pos_3 = p.i;
		621	if (blk_4: {
		622	var match_4 = false;
		623	while (p.parsewhite()) {
		624	match_4 = true;
		625	}
		626	break :blk_4 match_4;
		627	} and blk_4: {
		628	if (std.mem.startsWith(u8, p.source[p.i..], "or")) {
		629	p.i += 2;
		630	break :blk_4 true;
		631	}
		632	break :blk_4 false;
		633	} and blk_4: {
		634	var match_4 = false;
		635	while (p.parsewhite()) {
		636	match_4 = true;
		637	}
		638	break :blk_4 match_4;
		639	} and p.parseBoolAndExpr()) break :blk_3 true;
		640	p.i = pos_3;
		641	break :blk_3 false;
		642	}) {}
		643	break :blk_1 true;
		644	}) break :blk_0 true;
		645	p.i = pos_0;
		646	break :blk_0 false;
		647	};
		648	}
615	pub fn parsePrefixExpr(p: *Parser) bool {	649	pub fn parsePrefixExpr(p: *Parser) bool {
616	return blk_0: {	650	return blk_0: {
617	const pos_0 = p.i;	651	const pos_0 = p.i;
...	@@ -2185,7 +2219,7 @@ const Parser = struct {	...	@@ -2185,7 +2219,7 @@ const Parser = struct {
2185	var match_1 = false;	2219	var match_1 = false;
2186	while (blk_3: {	2220	while (blk_3: {
2187	const pos_3 = p.i;	2221	const pos_3 = p.i;
2188	if (blk_4: {	2222	if (p.parseskip() and blk_4: {
2189	if (std.mem.startsWith(u8, p.source[p.i..], "//!")) {	2223	if (std.mem.startsWith(u8, p.source[p.i..], "//!")) {
2190	p.i += 3;	2224	p.i += 3;
2191	break :blk_4 true;	2225	break :blk_4 true;
...	@@ -2194,7 +2228,7 @@ const Parser = struct {	...	@@ -2194,7 +2228,7 @@ const Parser = struct {
2194	} and blk_4: {	2228	} and blk_4: {
2195	while (p.parsenon_control_utf8()) {}	2229	while (p.parsenon_control_utf8()) {}
2196	break :blk_4 true;	2230	break :blk_4 true;
2197	} and p.parsenewline() and p.parseskip()) break :blk_3 true;	2231	} and p.parsenewline()) break :blk_3 true;
2198	p.i = pos_3;	2232	p.i = pos_3;
2199	break :blk_3 false;	2233	break :blk_3 false;
2200	}) {	2234	}) {
...	@@ -2213,7 +2247,7 @@ const Parser = struct {	...	@@ -2213,7 +2247,7 @@ const Parser = struct {
2213	var match_1 = false;	2247	var match_1 = false;
2214	while (blk_3: {	2248	while (blk_3: {
2215	const pos_3 = p.i;	2249	const pos_3 = p.i;
2216	if (blk_4: {	2250	if (p.parseskip() and blk_4: {
2217	if (std.mem.startsWith(u8, p.source[p.i..], "///")) {	2251	if (std.mem.startsWith(u8, p.source[p.i..], "///")) {
2218	p.i += 3;	2252	p.i += 3;
2219	break :blk_4 true;	2253	break :blk_4 true;
...	@@ -2222,7 +2256,7 @@ const Parser = struct {	...	@@ -2222,7 +2256,7 @@ const Parser = struct {
2222	} and blk_4: {	2256	} and blk_4: {
2223	while (p.parsenon_control_utf8()) {}	2257	while (p.parsenon_control_utf8()) {}
2224	break :blk_4 true;	2258	break :blk_4 true;
2225	} and p.parsenewline() and p.parseskip()) break :blk_3 true;	2259	} and p.parsenewline()) break :blk_3 true;
2226	p.i = pos_3;	2260	p.i = pos_3;
2227	break :blk_3 false;	2261	break :blk_3 false;
2228	}) {	2262	}) {
...	@@ -2347,7 +2381,7 @@ const Parser = struct {	...	@@ -2347,7 +2381,7 @@ const Parser = struct {
2347	pub fn parseCHAR_LITERAL(p: *Parser) bool {	2381	pub fn parseCHAR_LITERAL(p: *Parser) bool {
2348	return blk_0: {	2382	return blk_0: {
2349	const pos_0 = p.i;	2383	const pos_0 = p.i;
2350	if ((p.i < p.source.len and switch (p.source[p.i]) {	2384	if (p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
2351	'\''...'\'',	2385	'\''...'\'',
2352	=> blk_1: {	2386	=> blk_1: {
2353	p.i += 1;	2387	p.i += 1;
...	@@ -2364,7 +2398,7 @@ const Parser = struct {	...	@@ -2364,7 +2398,7 @@ const Parser = struct {
2364	break :blk_1 true;	2398	break :blk_1 true;
2365	},	2399	},
2366	else => false,	2400	else => false,
2367	}) and p.parseskip()) break :blk_0 true;	2401	})) break :blk_0 true;
2368	p.i = pos_0;	2402	p.i = pos_0;
2369	break :blk_0 false;	2403	break :blk_0 false;
2370	};	2404	};
...	@@ -2442,7 +2476,7 @@ const Parser = struct {	...	@@ -2442,7 +2476,7 @@ const Parser = struct {
2442	pub fn parseNUMBERLITERAL(p: *Parser) bool {	2476	pub fn parseNUMBERLITERAL(p: *Parser) bool {
2443	return blk_0: {	2477	return blk_0: {
2444	const pos_0 = p.i;	2478	const pos_0 = p.i;
2445	if ((p.i < p.source.len and switch (p.source[p.i]) {	2479	if (p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
2446	'0'...'9',	2480	'0'...'9',
2447	=> blk_1: {	2481	=> blk_1: {
2448	p.i += 1;	2482	p.i += 1;
...	@@ -2464,9 +2498,9 @@ const Parser = struct {	...	@@ -2464,9 +2498,9 @@ const Parser = struct {
2464	match_1 = true;	2498	match_1 = true;
2465	}	2499	}
2466	break :blk_1 match_1;	2500	break :blk_1 match_1;
2467	} and p.parseskip()) break :blk_0 true;	2501	}) break :blk_0 true;
2468	p.i = pos_0;	2502	p.i = pos_0;
2469	if ((p.i < p.source.len and switch (p.source[p.i]) {	2503	if (p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
2470	'0'...'9',	2504	'0'...'9',
2471	=> blk_1: {	2505	=> blk_1: {
2472	p.i += 1;	2506	p.i += 1;
...	@@ -2476,7 +2510,7 @@ const Parser = struct {	...	@@ -2476,7 +2510,7 @@ const Parser = struct {
2476	}) and blk_1: {	2510	}) and blk_1: {
2477	while (p.parsedigit_float()) {}	2511	while (p.parsedigit_float()) {}
2478	break :blk_1 true;	2512	break :blk_1 true;
2479	} and p.parseskip()) break :blk_0 true;	2513	}) break :blk_0 true;
2480	p.i = pos_0;	2514	p.i = pos_0;
2481	break :blk_0 false;	2515	break :blk_0 false;
2482	};	2516	};
...	@@ -2484,7 +2518,7 @@ const Parser = struct {	...	@@ -2484,7 +2518,7 @@ const Parser = struct {
2484	pub fn parseSTRINGLITERALSINGLE(p: *Parser) bool {	2518	pub fn parseSTRINGLITERALSINGLE(p: *Parser) bool {
2485	return blk_0: {	2519	return blk_0: {
2486	const pos_0 = p.i;	2520	const pos_0 = p.i;
2487	if ((p.i < p.source.len and switch (p.source[p.i]) {	2521	if (p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
2488	'"'...'"',	2522	'"'...'"',
2489	=> blk_1: {	2523	=> blk_1: {
2490	p.i += 1;	2524	p.i += 1;
...	@@ -2501,7 +2535,7 @@ const Parser = struct {	...	@@ -2501,7 +2535,7 @@ const Parser = struct {
2501	break :blk_1 true;	2535	break :blk_1 true;
2502	},	2536	},
2503	else => false,	2537	else => false,
2504	}) and p.parseskip()) break :blk_0 true;	2538	})) break :blk_0 true;
2505	p.i = pos_0;	2539	p.i = pos_0;
2506	break :blk_0 false;	2540	break :blk_0 false;
2507	};	2541	};
...	@@ -2515,7 +2549,7 @@ const Parser = struct {	...	@@ -2515,7 +2549,7 @@ const Parser = struct {
2515	var match_1 = false;	2549	var match_1 = false;
2516	while (blk_3: {	2550	while (blk_3: {
2517	const pos_3 = p.i;	2551	const pos_3 = p.i;
2518	if (p.parseline_string() and p.parseskip()) break :blk_3 true;	2552	if (p.parseskip() and p.parseline_string()) break :blk_3 true;
2519	p.i = pos_3;	2553	p.i = pos_3;
2520	break :blk_3 false;	2554	break :blk_3 false;
2521	}) {	2555	}) {
...	@@ -2530,7 +2564,7 @@ const Parser = struct {	...	@@ -2530,7 +2564,7 @@ const Parser = struct {
2530	pub fn parseIDENTIFIER(p: *Parser) bool {	2564	pub fn parseIDENTIFIER(p: *Parser) bool {
2531	return blk_0: {	2565	return blk_0: {
2532	const pos_0 = p.i;	2566	const pos_0 = p.i;
2533	if (blk_1: {	2567	if (p.parseskip() and blk_1: {
2534	const pos_1 = p.i;	2568	const pos_1 = p.i;
2535	const match_1 = p.parsekeyword();	2569	const match_1 = p.parsekeyword();
2536	p.i = pos_1;	2570	p.i = pos_1;
...	@@ -2557,9 +2591,9 @@ const Parser = struct {	...	@@ -2557,9 +2591,9 @@ const Parser = struct {
2557	else => false,	2591	else => false,
2558	})) {}	2592	})) {}
2559	break :blk_1 true;	2593	break :blk_1 true;
2560	} and p.parseskip()) break :blk_0 true;	2594	}) break :blk_0 true;
2561	p.i = pos_0;	2595	p.i = pos_0;
2562	if (blk_1: {	2596	if (p.parseskip() and blk_1: {
2563	if (std.mem.startsWith(u8, p.source[p.i..], "@")) {	2597	if (std.mem.startsWith(u8, p.source[p.i..], "@")) {
2564	p.i += 1;	2598	p.i += 1;
2565	break :blk_1 true;	2599	break :blk_1 true;
...	@@ -2573,7 +2607,7 @@ const Parser = struct {	...	@@ -2573,7 +2607,7 @@ const Parser = struct {
2573	pub fn parseBUILTINIDENTIFIER(p: *Parser) bool {	2607	pub fn parseBUILTINIDENTIFIER(p: *Parser) bool {
2574	return blk_0: {	2608	return blk_0: {
2575	const pos_0 = p.i;	2609	const pos_0 = p.i;
2576	if (blk_1: {	2610	if (p.parseskip() and blk_1: {
2577	if (std.mem.startsWith(u8, p.source[p.i..], "@")) {	2611	if (std.mem.startsWith(u8, p.source[p.i..], "@")) {
2578	p.i += 1;	2612	p.i += 1;
2579	break :blk_1 true;	2613	break :blk_1 true;
...	@@ -2601,7 +2635,7 @@ const Parser = struct {	...	@@ -2601,7 +2635,7 @@ const Parser = struct {
2601	else => false,	2635	else => false,
2602	})) {}	2636	})) {}
2603	break :blk_1 true;	2637	break :blk_1 true;
2604	} and p.parseskip()) break :blk_0 true;	2638	}) break :blk_0 true;
2605	p.i = pos_0;	2639	p.i = pos_0;
2606	break :blk_0 false;	2640	break :blk_0 false;
2607	};	2641	};
...	@@ -2609,7 +2643,7 @@ const Parser = struct {	...	@@ -2609,7 +2643,7 @@ const Parser = struct {
2609	pub fn parseAMPERSAND(p: *Parser) bool {	2643	pub fn parseAMPERSAND(p: *Parser) bool {
2610	return blk_0: {	2644	return blk_0: {
2611	const pos_0 = p.i;	2645	const pos_0 = p.i;
2612	if (blk_1: {	2646	if (p.parseskip() and blk_1: {
2613	if (std.mem.startsWith(u8, p.source[p.i..], "&")) {	2647	if (std.mem.startsWith(u8, p.source[p.i..], "&")) {
2614	p.i += 1;	2648	p.i += 1;
2615	break :blk_1 true;	2649	break :blk_1 true;
...	@@ -2627,7 +2661,7 @@ const Parser = struct {	...	@@ -2627,7 +2661,7 @@ const Parser = struct {
2627	});	2661	});
2628	p.i = pos_1;	2662	p.i = pos_1;
2629	break :blk_1 !match_1;	2663	break :blk_1 !match_1;
2630	} and p.parseskip()) break :blk_0 true;	2664	}) break :blk_0 true;
2631	p.i = pos_0;	2665	p.i = pos_0;
2632	break :blk_0 false;	2666	break :blk_0 false;
2633	};	2667	};
...	@@ -2635,13 +2669,13 @@ const Parser = struct {	...	@@ -2635,13 +2669,13 @@ const Parser = struct {
2635	pub fn parseAMPERSANDEQUAL(p: *Parser) bool {	2669	pub fn parseAMPERSANDEQUAL(p: *Parser) bool {
2636	return blk_0: {	2670	return blk_0: {
2637	const pos_0 = p.i;	2671	const pos_0 = p.i;
2638	if (blk_1: {	2672	if (p.parseskip() and blk_1: {
2639	if (std.mem.startsWith(u8, p.source[p.i..], "&=")) {	2673	if (std.mem.startsWith(u8, p.source[p.i..], "&=")) {
2640	p.i += 2;	2674	p.i += 2;
2641	break :blk_1 true;	2675	break :blk_1 true;
2642	}	2676	}
2643	break :blk_1 false;	2677	break :blk_1 false;
2644	} and p.parseskip()) break :blk_0 true;	2678	}) break :blk_0 true;
2645	p.i = pos_0;	2679	p.i = pos_0;
2646	break :blk_0 false;	2680	break :blk_0 false;
2647	};	2681	};
...	@@ -2649,7 +2683,7 @@ const Parser = struct {	...	@@ -2649,7 +2683,7 @@ const Parser = struct {
2649	pub fn parseASTERISK(p: *Parser) bool {	2683	pub fn parseASTERISK(p: *Parser) bool {
2650	return blk_0: {	2684	return blk_0: {
2651	const pos_0 = p.i;	2685	const pos_0 = p.i;
2652	if (blk_1: {	2686	if (p.parseskip() and blk_1: {
2653	if (std.mem.startsWith(u8, p.source[p.i..], "*")) {	2687	if (std.mem.startsWith(u8, p.source[p.i..], "*")) {
2654	p.i += 1;	2688	p.i += 1;
2655	break :blk_1 true;	2689	break :blk_1 true;
...	@@ -2669,7 +2703,7 @@ const Parser = struct {	...	@@ -2669,7 +2703,7 @@ const Parser = struct {
2669	});	2703	});
2670	p.i = pos_1;	2704	p.i = pos_1;
2671	break :blk_1 !match_1;	2705	break :blk_1 !match_1;
2672	} and p.parseskip()) break :blk_0 true;	2706	}) break :blk_0 true;
2673	p.i = pos_0;	2707	p.i = pos_0;
2674	break :blk_0 false;	2708	break :blk_0 false;
2675	};	2709	};
...	@@ -2677,13 +2711,13 @@ const Parser = struct {	...	@@ -2677,13 +2711,13 @@ const Parser = struct {
2677	pub fn parseASTERISKEQUAL(p: *Parser) bool {	2711	pub fn parseASTERISKEQUAL(p: *Parser) bool {
2678	return blk_0: {	2712	return blk_0: {
2679	const pos_0 = p.i;	2713	const pos_0 = p.i;
2680	if (blk_1: {	2714	if (p.parseskip() and blk_1: {
2681	if (std.mem.startsWith(u8, p.source[p.i..], "*=")) {	2715	if (std.mem.startsWith(u8, p.source[p.i..], "*=")) {
2682	p.i += 2;	2716	p.i += 2;
2683	break :blk_1 true;	2717	break :blk_1 true;
2684	}	2718	}
2685	break :blk_1 false;	2719	break :blk_1 false;
2686	} and p.parseskip()) break :blk_0 true;	2720	}) break :blk_0 true;
2687	p.i = pos_0;	2721	p.i = pos_0;
2688	break :blk_0 false;	2722	break :blk_0 false;
2689	};	2723	};
...	@@ -2691,7 +2725,7 @@ const Parser = struct {	...	@@ -2691,7 +2725,7 @@ const Parser = struct {
2691	pub fn parseASTERISKPERCENT(p: *Parser) bool {	2725	pub fn parseASTERISKPERCENT(p: *Parser) bool {
2692	return blk_0: {	2726	return blk_0: {
2693	const pos_0 = p.i;	2727	const pos_0 = p.i;
2694	if (blk_1: {	2728	if (p.parseskip() and blk_1: {
2695	if (std.mem.startsWith(u8, p.source[p.i..], "*%")) {	2729	if (std.mem.startsWith(u8, p.source[p.i..], "*%")) {
2696	p.i += 2;	2730	p.i += 2;
2697	break :blk_1 true;	2731	break :blk_1 true;
...	@@ -2709,7 +2743,7 @@ const Parser = struct {	...	@@ -2709,7 +2743,7 @@ const Parser = struct {
2709	});	2743	});
2710	p.i = pos_1;	2744	p.i = pos_1;
2711	break :blk_1 !match_1;	2745	break :blk_1 !match_1;
2712	} and p.parseskip()) break :blk_0 true;	2746	}) break :blk_0 true;
2713	p.i = pos_0;	2747	p.i = pos_0;
2714	break :blk_0 false;	2748	break :blk_0 false;
2715	};	2749	};
...	@@ -2717,13 +2751,13 @@ const Parser = struct {	...	@@ -2717,13 +2751,13 @@ const Parser = struct {
2717	pub fn parseASTERISKPERCENTEQUAL(p: *Parser) bool {	2751	pub fn parseASTERISKPERCENTEQUAL(p: *Parser) bool {
2718	return blk_0: {	2752	return blk_0: {
2719	const pos_0 = p.i;	2753	const pos_0 = p.i;
2720	if (blk_1: {	2754	if (p.parseskip() and blk_1: {
2721	if (std.mem.startsWith(u8, p.source[p.i..], "*%=")) {	2755	if (std.mem.startsWith(u8, p.source[p.i..], "*%=")) {
2722	p.i += 3;	2756	p.i += 3;
2723	break :blk_1 true;	2757	break :blk_1 true;
2724	}	2758	}
2725	break :blk_1 false;	2759	break :blk_1 false;
2726	} and p.parseskip()) break :blk_0 true;	2760	}) break :blk_0 true;
2727	p.i = pos_0;	2761	p.i = pos_0;
2728	break :blk_0 false;	2762	break :blk_0 false;
2729	};	2763	};
...	@@ -2731,7 +2765,7 @@ const Parser = struct {	...	@@ -2731,7 +2765,7 @@ const Parser = struct {
2731	pub fn parseASTERISKPIPE(p: *Parser) bool {	2765	pub fn parseASTERISKPIPE(p: *Parser) bool {
2732	return blk_0: {	2766	return blk_0: {
2733	const pos_0 = p.i;	2767	const pos_0 = p.i;
2734	if (blk_1: {	2768	if (p.parseskip() and blk_1: {
2735	if (std.mem.startsWith(u8, p.source[p.i..], "*\|")) {	2769	if (std.mem.startsWith(u8, p.source[p.i..], "*\|")) {
2736	p.i += 2;	2770	p.i += 2;
2737	break :blk_1 true;	2771	break :blk_1 true;
...	@@ -2749,7 +2783,7 @@ const Parser = struct {	...	@@ -2749,7 +2783,7 @@ const Parser = struct {
2749	});	2783	});
2750	p.i = pos_1;	2784	p.i = pos_1;
2751	break :blk_1 !match_1;	2785	break :blk_1 !match_1;
2752	} and p.parseskip()) break :blk_0 true;	2786	}) break :blk_0 true;
2753	p.i = pos_0;	2787	p.i = pos_0;
2754	break :blk_0 false;	2788	break :blk_0 false;
2755	};	2789	};
...	@@ -2757,13 +2791,13 @@ const Parser = struct {	...	@@ -2757,13 +2791,13 @@ const Parser = struct {
2757	pub fn parseASTERISKPIPEEQUAL(p: *Parser) bool {	2791	pub fn parseASTERISKPIPEEQUAL(p: *Parser) bool {
2758	return blk_0: {	2792	return blk_0: {
2759	const pos_0 = p.i;	2793	const pos_0 = p.i;
2760	if (blk_1: {	2794	if (p.parseskip() and blk_1: {
2761	if (std.mem.startsWith(u8, p.source[p.i..], "*\|=")) {	2795	if (std.mem.startsWith(u8, p.source[p.i..], "*\|=")) {
2762	p.i += 3;	2796	p.i += 3;
2763	break :blk_1 true;	2797	break :blk_1 true;
2764	}	2798	}
2765	break :blk_1 false;	2799	break :blk_1 false;
2766	} and p.parseskip()) break :blk_0 true;	2800	}) break :blk_0 true;
2767	p.i = pos_0;	2801	p.i = pos_0;
2768	break :blk_0 false;	2802	break :blk_0 false;
2769	};	2803	};
...	@@ -2771,7 +2805,7 @@ const Parser = struct {	...	@@ -2771,7 +2805,7 @@ const Parser = struct {
2771	pub fn parseCARET(p: *Parser) bool {	2805	pub fn parseCARET(p: *Parser) bool {
2772	return blk_0: {	2806	return blk_0: {
2773	const pos_0 = p.i;	2807	const pos_0 = p.i;
2774	if (blk_1: {	2808	if (p.parseskip() and blk_1: {
2775	if (std.mem.startsWith(u8, p.source[p.i..], "^")) {	2809	if (std.mem.startsWith(u8, p.source[p.i..], "^")) {
2776	p.i += 1;	2810	p.i += 1;
2777	break :blk_1 true;	2811	break :blk_1 true;
...	@@ -2789,7 +2823,7 @@ const Parser = struct {	...	@@ -2789,7 +2823,7 @@ const Parser = struct {
2789	});	2823	});
2790	p.i = pos_1;	2824	p.i = pos_1;
2791	break :blk_1 !match_1;	2825	break :blk_1 !match_1;
2792	} and p.parseskip()) break :blk_0 true;	2826	}) break :blk_0 true;
2793	p.i = pos_0;	2827	p.i = pos_0;
2794	break :blk_0 false;	2828	break :blk_0 false;
2795	};	2829	};
...	@@ -2797,13 +2831,13 @@ const Parser = struct {	...	@@ -2797,13 +2831,13 @@ const Parser = struct {
2797	pub fn parseCARETEQUAL(p: *Parser) bool {	2831	pub fn parseCARETEQUAL(p: *Parser) bool {
2798	return blk_0: {	2832	return blk_0: {
2799	const pos_0 = p.i;	2833	const pos_0 = p.i;
2800	if (blk_1: {	2834	if (p.parseskip() and blk_1: {
2801	if (std.mem.startsWith(u8, p.source[p.i..], "^=")) {	2835	if (std.mem.startsWith(u8, p.source[p.i..], "^=")) {
2802	p.i += 2;	2836	p.i += 2;
2803	break :blk_1 true;	2837	break :blk_1 true;
2804	}	2838	}
2805	break :blk_1 false;	2839	break :blk_1 false;
2806	} and p.parseskip()) break :blk_0 true;	2840	}) break :blk_0 true;
2807	p.i = pos_0;	2841	p.i = pos_0;
2808	break :blk_0 false;	2842	break :blk_0 false;
2809	};	2843	};
...	@@ -2811,13 +2845,13 @@ const Parser = struct {	...	@@ -2811,13 +2845,13 @@ const Parser = struct {
2811	pub fn parseCOLON(p: *Parser) bool {	2845	pub fn parseCOLON(p: *Parser) bool {
2812	return blk_0: {	2846	return blk_0: {
2813	const pos_0 = p.i;	2847	const pos_0 = p.i;
2814	if (blk_1: {	2848	if (p.parseskip() and blk_1: {
2815	if (std.mem.startsWith(u8, p.source[p.i..], ":")) {	2849	if (std.mem.startsWith(u8, p.source[p.i..], ":")) {
2816	p.i += 1;	2850	p.i += 1;
2817	break :blk_1 true;	2851	break :blk_1 true;
2818	}	2852	}
2819	break :blk_1 false;	2853	break :blk_1 false;
2820	} and p.parseskip()) break :blk_0 true;	2854	}) break :blk_0 true;
2821	p.i = pos_0;	2855	p.i = pos_0;
2822	break :blk_0 false;	2856	break :blk_0 false;
2823	};	2857	};
...	@@ -2825,13 +2859,13 @@ const Parser = struct {	...	@@ -2825,13 +2859,13 @@ const Parser = struct {
2825	pub fn parseCOMMA(p: *Parser) bool {	2859	pub fn parseCOMMA(p: *Parser) bool {
2826	return blk_0: {	2860	return blk_0: {
2827	const pos_0 = p.i;	2861	const pos_0 = p.i;
2828	if (blk_1: {	2862	if (p.parseskip() and blk_1: {
2829	if (std.mem.startsWith(u8, p.source[p.i..], ",")) {	2863	if (std.mem.startsWith(u8, p.source[p.i..], ",")) {
2830	p.i += 1;	2864	p.i += 1;
2831	break :blk_1 true;	2865	break :blk_1 true;
2832	}	2866	}
2833	break :blk_1 false;	2867	break :blk_1 false;
2834	} and p.parseskip()) break :blk_0 true;	2868	}) break :blk_0 true;
2835	p.i = pos_0;	2869	p.i = pos_0;
2836	break :blk_0 false;	2870	break :blk_0 false;
2837	};	2871	};
...	@@ -2839,7 +2873,7 @@ const Parser = struct {	...	@@ -2839,7 +2873,7 @@ const Parser = struct {
2839	pub fn parseDOT(p: *Parser) bool {	2873	pub fn parseDOT(p: *Parser) bool {
2840	return blk_0: {	2874	return blk_0: {
2841	const pos_0 = p.i;	2875	const pos_0 = p.i;
2842	if (blk_1: {	2876	if (p.parseskip() and blk_1: {
2843	if (std.mem.startsWith(u8, p.source[p.i..], ".")) {	2877	if (std.mem.startsWith(u8, p.source[p.i..], ".")) {
2844	p.i += 1;	2878	p.i += 1;
2845	break :blk_1 true;	2879	break :blk_1 true;
...	@@ -2859,7 +2893,7 @@ const Parser = struct {	...	@@ -2859,7 +2893,7 @@ const Parser = struct {
2859	});	2893	});
2860	p.i = pos_1;	2894	p.i = pos_1;
2861	break :blk_1 !match_1;	2895	break :blk_1 !match_1;
2862	} and p.parseskip()) break :blk_0 true;	2896	}) break :blk_0 true;
2863	p.i = pos_0;	2897	p.i = pos_0;
2864	break :blk_0 false;	2898	break :blk_0 false;
2865	};	2899	};
...	@@ -2867,7 +2901,7 @@ const Parser = struct {	...	@@ -2867,7 +2901,7 @@ const Parser = struct {
2867	pub fn parseDOT2(p: *Parser) bool {	2901	pub fn parseDOT2(p: *Parser) bool {
2868	return blk_0: {	2902	return blk_0: {
2869	const pos_0 = p.i;	2903	const pos_0 = p.i;
2870	if (blk_1: {	2904	if (p.parseskip() and blk_1: {
2871	if (std.mem.startsWith(u8, p.source[p.i..], "..")) {	2905	if (std.mem.startsWith(u8, p.source[p.i..], "..")) {
2872	p.i += 2;	2906	p.i += 2;
2873	break :blk_1 true;	2907	break :blk_1 true;
...	@@ -2885,7 +2919,7 @@ const Parser = struct {	...	@@ -2885,7 +2919,7 @@ const Parser = struct {
2885	});	2919	});
2886	p.i = pos_1;	2920	p.i = pos_1;
2887	break :blk_1 !match_1;	2921	break :blk_1 !match_1;
2888	} and p.parseskip()) break :blk_0 true;	2922	}) break :blk_0 true;
2889	p.i = pos_0;	2923	p.i = pos_0;
2890	break :blk_0 false;	2924	break :blk_0 false;
2891	};	2925	};
...	@@ -2893,13 +2927,13 @@ const Parser = struct {	...	@@ -2893,13 +2927,13 @@ const Parser = struct {
2893	pub fn parseDOT3(p: *Parser) bool {	2927	pub fn parseDOT3(p: *Parser) bool {
2894	return blk_0: {	2928	return blk_0: {
2895	const pos_0 = p.i;	2929	const pos_0 = p.i;
2896	if (blk_1: {	2930	if (p.parseskip() and blk_1: {
2897	if (std.mem.startsWith(u8, p.source[p.i..], "...")) {	2931	if (std.mem.startsWith(u8, p.source[p.i..], "...")) {
2898	p.i += 3;	2932	p.i += 3;
2899	break :blk_1 true;	2933	break :blk_1 true;
2900	}	2934	}
2901	break :blk_1 false;	2935	break :blk_1 false;
2902	} and p.parseskip()) break :blk_0 true;	2936	}) break :blk_0 true;
2903	p.i = pos_0;	2937	p.i = pos_0;
2904	break :blk_0 false;	2938	break :blk_0 false;
2905	};	2939	};
...	@@ -2907,13 +2941,13 @@ const Parser = struct {	...	@@ -2907,13 +2941,13 @@ const Parser = struct {
2907	pub fn parseDOTASTERISK(p: *Parser) bool {	2941	pub fn parseDOTASTERISK(p: *Parser) bool {
2908	return blk_0: {	2942	return blk_0: {
2909	const pos_0 = p.i;	2943	const pos_0 = p.i;
2910	if (blk_1: {	2944	if (p.parseskip() and blk_1: {
2911	if (std.mem.startsWith(u8, p.source[p.i..], ".*")) {	2945	if (std.mem.startsWith(u8, p.source[p.i..], ".*")) {
2912	p.i += 2;	2946	p.i += 2;
2913	break :blk_1 true;	2947	break :blk_1 true;
2914	}	2948	}
2915	break :blk_1 false;	2949	break :blk_1 false;
2916	} and p.parseskip()) break :blk_0 true;	2950	}) break :blk_0 true;
2917	p.i = pos_0;	2951	p.i = pos_0;
2918	break :blk_0 false;	2952	break :blk_0 false;
2919	};	2953	};
...	@@ -2921,13 +2955,13 @@ const Parser = struct {	...	@@ -2921,13 +2955,13 @@ const Parser = struct {
2921	pub fn parseDOTQUESTIONMARK(p: *Parser) bool {	2955	pub fn parseDOTQUESTIONMARK(p: *Parser) bool {
2922	return blk_0: {	2956	return blk_0: {
2923	const pos_0 = p.i;	2957	const pos_0 = p.i;
2924	if (blk_1: {	2958	if (p.parseskip() and blk_1: {
2925	if (std.mem.startsWith(u8, p.source[p.i..], ".?")) {	2959	if (std.mem.startsWith(u8, p.source[p.i..], ".?")) {
2926	p.i += 2;	2960	p.i += 2;
2927	break :blk_1 true;	2961	break :blk_1 true;
2928	}	2962	}
2929	break :blk_1 false;	2963	break :blk_1 false;
2930	} and p.parseskip()) break :blk_0 true;	2964	}) break :blk_0 true;
2931	p.i = pos_0;	2965	p.i = pos_0;
2932	break :blk_0 false;	2966	break :blk_0 false;
2933	};	2967	};
...	@@ -2935,7 +2969,7 @@ const Parser = struct {	...	@@ -2935,7 +2969,7 @@ const Parser = struct {
2935	pub fn parseEQUAL(p: *Parser) bool {	2969	pub fn parseEQUAL(p: *Parser) bool {
2936	return blk_0: {	2970	return blk_0: {
2937	const pos_0 = p.i;	2971	const pos_0 = p.i;
2938	if (blk_1: {	2972	if (p.parseskip() and blk_1: {
2939	if (std.mem.startsWith(u8, p.source[p.i..], "=")) {	2973	if (std.mem.startsWith(u8, p.source[p.i..], "=")) {
2940	p.i += 1;	2974	p.i += 1;
2941	break :blk_1 true;	2975	break :blk_1 true;
...	@@ -2954,7 +2988,7 @@ const Parser = struct {	...	@@ -2954,7 +2988,7 @@ const Parser = struct {
2954	});	2988	});
2955	p.i = pos_1;	2989	p.i = pos_1;
2956	break :blk_1 !match_1;	2990	break :blk_1 !match_1;
2957	} and p.parseskip()) break :blk_0 true;	2991	}) break :blk_0 true;
2958	p.i = pos_0;	2992	p.i = pos_0;
2959	break :blk_0 false;	2993	break :blk_0 false;
2960	};	2994	};
...	@@ -2962,13 +2996,13 @@ const Parser = struct {	...	@@ -2962,13 +2996,13 @@ const Parser = struct {
2962	pub fn parseEQUALEQUAL(p: *Parser) bool {	2996	pub fn parseEQUALEQUAL(p: *Parser) bool {
2963	return blk_0: {	2997	return blk_0: {
2964	const pos_0 = p.i;	2998	const pos_0 = p.i;
2965	if (blk_1: {	2999	if (p.parseskip() and blk_1: {
2966	if (std.mem.startsWith(u8, p.source[p.i..], "==")) {	3000	if (std.mem.startsWith(u8, p.source[p.i..], "==")) {
2967	p.i += 2;	3001	p.i += 2;
2968	break :blk_1 true;	3002	break :blk_1 true;
2969	}	3003	}
2970	break :blk_1 false;	3004	break :blk_1 false;
2971	} and p.parseskip()) break :blk_0 true;	3005	}) break :blk_0 true;
2972	p.i = pos_0;	3006	p.i = pos_0;
2973	break :blk_0 false;	3007	break :blk_0 false;
2974	};	3008	};
...	@@ -2976,13 +3010,13 @@ const Parser = struct {	...	@@ -2976,13 +3010,13 @@ const Parser = struct {
2976	pub fn parseEQUALRARROW(p: *Parser) bool {	3010	pub fn parseEQUALRARROW(p: *Parser) bool {
2977	return blk_0: {	3011	return blk_0: {
2978	const pos_0 = p.i;	3012	const pos_0 = p.i;
2979	if (blk_1: {	3013	if (p.parseskip() and blk_1: {
2980	if (std.mem.startsWith(u8, p.source[p.i..], "=>")) {	3014	if (std.mem.startsWith(u8, p.source[p.i..], "=>")) {
2981	p.i += 2;	3015	p.i += 2;
2982	break :blk_1 true;	3016	break :blk_1 true;
2983	}	3017	}
2984	break :blk_1 false;	3018	break :blk_1 false;
2985	} and p.parseskip()) break :blk_0 true;	3019	}) break :blk_0 true;
2986	p.i = pos_0;	3020	p.i = pos_0;
2987	break :blk_0 false;	3021	break :blk_0 false;
2988	};	3022	};
...	@@ -2990,7 +3024,7 @@ const Parser = struct {	...	@@ -2990,7 +3024,7 @@ const Parser = struct {
2990	pub fn parseEXCLAMATIONMARK(p: *Parser) bool {	3024	pub fn parseEXCLAMATIONMARK(p: *Parser) bool {
2991	return blk_0: {	3025	return blk_0: {
2992	const pos_0 = p.i;	3026	const pos_0 = p.i;
2993	if (blk_1: {	3027	if (p.parseskip() and blk_1: {
2994	if (std.mem.startsWith(u8, p.source[p.i..], "!")) {	3028	if (std.mem.startsWith(u8, p.source[p.i..], "!")) {
2995	p.i += 1;	3029	p.i += 1;
2996	break :blk_1 true;	3030	break :blk_1 true;
...	@@ -3008,7 +3042,7 @@ const Parser = struct {	...	@@ -3008,7 +3042,7 @@ const Parser = struct {
3008	});	3042	});
3009	p.i = pos_1;	3043	p.i = pos_1;
3010	break :blk_1 !match_1;	3044	break :blk_1 !match_1;
3011	} and p.parseskip()) break :blk_0 true;	3045	}) break :blk_0 true;
3012	p.i = pos_0;	3046	p.i = pos_0;
3013	break :blk_0 false;	3047	break :blk_0 false;
3014	};	3048	};
...	@@ -3016,13 +3050,13 @@ const Parser = struct {	...	@@ -3016,13 +3050,13 @@ const Parser = struct {
3016	pub fn parseEXCLAMATIONMARKEQUAL(p: *Parser) bool {	3050	pub fn parseEXCLAMATIONMARKEQUAL(p: *Parser) bool {
3017	return blk_0: {	3051	return blk_0: {
3018	const pos_0 = p.i;	3052	const pos_0 = p.i;
3019	if (blk_1: {	3053	if (p.parseskip() and blk_1: {
3020	if (std.mem.startsWith(u8, p.source[p.i..], "!=")) {	3054	if (std.mem.startsWith(u8, p.source[p.i..], "!=")) {
3021	p.i += 2;	3055	p.i += 2;
3022	break :blk_1 true;	3056	break :blk_1 true;
3023	}	3057	}
3024	break :blk_1 false;	3058	break :blk_1 false;
3025	} and p.parseskip()) break :blk_0 true;	3059	}) break :blk_0 true;
3026	p.i = pos_0;	3060	p.i = pos_0;
3027	break :blk_0 false;	3061	break :blk_0 false;
3028	};	3062	};
...	@@ -3030,7 +3064,7 @@ const Parser = struct {	...	@@ -3030,7 +3064,7 @@ const Parser = struct {
3030	pub fn parseLARROW(p: *Parser) bool {	3064	pub fn parseLARROW(p: *Parser) bool {
3031	return blk_0: {	3065	return blk_0: {
3032	const pos_0 = p.i;	3066	const pos_0 = p.i;
3033	if (blk_1: {	3067	if (p.parseskip() and blk_1: {
3034	if (std.mem.startsWith(u8, p.source[p.i..], "<")) {	3068	if (std.mem.startsWith(u8, p.source[p.i..], "<")) {
3035	p.i += 1;	3069	p.i += 1;
3036	break :blk_1 true;	3070	break :blk_1 true;
...	@@ -3049,7 +3083,7 @@ const Parser = struct {	...	@@ -3049,7 +3083,7 @@ const Parser = struct {
3049	});	3083	});
3050	p.i = pos_1;	3084	p.i = pos_1;
3051	break :blk_1 !match_1;	3085	break :blk_1 !match_1;
3052	} and p.parseskip()) break :blk_0 true;	3086	}) break :blk_0 true;
3053	p.i = pos_0;	3087	p.i = pos_0;
3054	break :blk_0 false;	3088	break :blk_0 false;
3055	};	3089	};
...	@@ -3057,7 +3091,7 @@ const Parser = struct {	...	@@ -3057,7 +3091,7 @@ const Parser = struct {
3057	pub fn parseLARROW2(p: *Parser) bool {	3091	pub fn parseLARROW2(p: *Parser) bool {
3058	return blk_0: {	3092	return blk_0: {
3059	const pos_0 = p.i;	3093	const pos_0 = p.i;
3060	if (blk_1: {	3094	if (p.parseskip() and blk_1: {
3061	if (std.mem.startsWith(u8, p.source[p.i..], "<<")) {	3095	if (std.mem.startsWith(u8, p.source[p.i..], "<<")) {
3062	p.i += 2;	3096	p.i += 2;
3063	break :blk_1 true;	3097	break :blk_1 true;
...	@@ -3076,7 +3110,7 @@ const Parser = struct {	...	@@ -3076,7 +3110,7 @@ const Parser = struct {
3076	});	3110	});
3077	p.i = pos_1;	3111	p.i = pos_1;
3078	break :blk_1 !match_1;	3112	break :blk_1 !match_1;
3079	} and p.parseskip()) break :blk_0 true;	3113	}) break :blk_0 true;
3080	p.i = pos_0;	3114	p.i = pos_0;
3081	break :blk_0 false;	3115	break :blk_0 false;
3082	};	3116	};
...	@@ -3084,13 +3118,13 @@ const Parser = struct {	...	@@ -3084,13 +3118,13 @@ const Parser = struct {
3084	pub fn parseLARROW2EQUAL(p: *Parser) bool {	3118	pub fn parseLARROW2EQUAL(p: *Parser) bool {
3085	return blk_0: {	3119	return blk_0: {
3086	const pos_0 = p.i;	3120	const pos_0 = p.i;
3087	if (blk_1: {	3121	if (p.parseskip() and blk_1: {
3088	if (std.mem.startsWith(u8, p.source[p.i..], "<<=")) {	3122	if (std.mem.startsWith(u8, p.source[p.i..], "<<=")) {
3089	p.i += 3;	3123	p.i += 3;
3090	break :blk_1 true;	3124	break :blk_1 true;
3091	}	3125	}
3092	break :blk_1 false;	3126	break :blk_1 false;
3093	} and p.parseskip()) break :blk_0 true;	3127	}) break :blk_0 true;
3094	p.i = pos_0;	3128	p.i = pos_0;
3095	break :blk_0 false;	3129	break :blk_0 false;
3096	};	3130	};
...	@@ -3098,7 +3132,7 @@ const Parser = struct {	...	@@ -3098,7 +3132,7 @@ const Parser = struct {
3098	pub fn parseLARROW2PIPE(p: *Parser) bool {	3132	pub fn parseLARROW2PIPE(p: *Parser) bool {
3099	return blk_0: {	3133	return blk_0: {
3100	const pos_0 = p.i;	3134	const pos_0 = p.i;
3101	if (blk_1: {	3135	if (p.parseskip() and blk_1: {
3102	if (std.mem.startsWith(u8, p.source[p.i..], "<<\|")) {	3136	if (std.mem.startsWith(u8, p.source[p.i..], "<<\|")) {
3103	p.i += 3;	3137	p.i += 3;
3104	break :blk_1 true;	3138	break :blk_1 true;
...	@@ -3116,7 +3150,7 @@ const Parser = struct {	...	@@ -3116,7 +3150,7 @@ const Parser = struct {
3116	});	3150	});
3117	p.i = pos_1;	3151	p.i = pos_1;
3118	break :blk_1 !match_1;	3152	break :blk_1 !match_1;
3119	} and p.parseskip()) break :blk_0 true;	3153	}) break :blk_0 true;
3120	p.i = pos_0;	3154	p.i = pos_0;
3121	break :blk_0 false;	3155	break :blk_0 false;
3122	};	3156	};
...	@@ -3124,13 +3158,13 @@ const Parser = struct {	...	@@ -3124,13 +3158,13 @@ const Parser = struct {
3124	pub fn parseLARROW2PIPEEQUAL(p: *Parser) bool {	3158	pub fn parseLARROW2PIPEEQUAL(p: *Parser) bool {
3125	return blk_0: {	3159	return blk_0: {
3126	const pos_0 = p.i;	3160	const pos_0 = p.i;
3127	if (blk_1: {	3161	if (p.parseskip() and blk_1: {
3128	if (std.mem.startsWith(u8, p.source[p.i..], "<<\|=")) {	3162	if (std.mem.startsWith(u8, p.source[p.i..], "<<\|=")) {
3129	p.i += 4;	3163	p.i += 4;
3130	break :blk_1 true;	3164	break :blk_1 true;
3131	}	3165	}
3132	break :blk_1 false;	3166	break :blk_1 false;
3133	} and p.parseskip()) break :blk_0 true;	3167	}) break :blk_0 true;
3134	p.i = pos_0;	3168	p.i = pos_0;
3135	break :blk_0 false;	3169	break :blk_0 false;
3136	};	3170	};
...	@@ -3138,13 +3172,13 @@ const Parser = struct {	...	@@ -3138,13 +3172,13 @@ const Parser = struct {
3138	pub fn parseLARROWEQUAL(p: *Parser) bool {	3172	pub fn parseLARROWEQUAL(p: *Parser) bool {
3139	return blk_0: {	3173	return blk_0: {
3140	const pos_0 = p.i;	3174	const pos_0 = p.i;
3141	if (blk_1: {	3175	if (p.parseskip() and blk_1: {
3142	if (std.mem.startsWith(u8, p.source[p.i..], "<=")) {	3176	if (std.mem.startsWith(u8, p.source[p.i..], "<=")) {
3143	p.i += 2;	3177	p.i += 2;
3144	break :blk_1 true;	3178	break :blk_1 true;
3145	}	3179	}
3146	break :blk_1 false;	3180	break :blk_1 false;
3147	} and p.parseskip()) break :blk_0 true;	3181	}) break :blk_0 true;
3148	p.i = pos_0;	3182	p.i = pos_0;
3149	break :blk_0 false;	3183	break :blk_0 false;
3150	};	3184	};
...	@@ -3152,13 +3186,13 @@ const Parser = struct {	...	@@ -3152,13 +3186,13 @@ const Parser = struct {
3152	pub fn parseLBRACE(p: *Parser) bool {	3186	pub fn parseLBRACE(p: *Parser) bool {
3153	return blk_0: {	3187	return blk_0: {
3154	const pos_0 = p.i;	3188	const pos_0 = p.i;
3155	if (blk_1: {	3189	if (p.parseskip() and blk_1: {
3156	if (std.mem.startsWith(u8, p.source[p.i..], "{")) {	3190	if (std.mem.startsWith(u8, p.source[p.i..], "{")) {
3157	p.i += 1;	3191	p.i += 1;
3158	break :blk_1 true;	3192	break :blk_1 true;
3159	}	3193	}
3160	break :blk_1 false;	3194	break :blk_1 false;
3161	} and p.parseskip()) break :blk_0 true;	3195	}) break :blk_0 true;
3162	p.i = pos_0;	3196	p.i = pos_0;
3163	break :blk_0 false;	3197	break :blk_0 false;
3164	};	3198	};
...	@@ -3166,13 +3200,13 @@ const Parser = struct {	...	@@ -3166,13 +3200,13 @@ const Parser = struct {
3166	pub fn parseLBRACKET(p: *Parser) bool {	3200	pub fn parseLBRACKET(p: *Parser) bool {
3167	return blk_0: {	3201	return blk_0: {
3168	const pos_0 = p.i;	3202	const pos_0 = p.i;
3169	if (blk_1: {	3203	if (p.parseskip() and blk_1: {
3170	if (std.mem.startsWith(u8, p.source[p.i..], "[")) {	3204	if (std.mem.startsWith(u8, p.source[p.i..], "[")) {
3171	p.i += 1;	3205	p.i += 1;
3172	break :blk_1 true;	3206	break :blk_1 true;
3173	}	3207	}
3174	break :blk_1 false;	3208	break :blk_1 false;
3175	} and p.parseskip()) break :blk_0 true;	3209	}) break :blk_0 true;
3176	p.i = pos_0;	3210	p.i = pos_0;
3177	break :blk_0 false;	3211	break :blk_0 false;
3178	};	3212	};
...	@@ -3180,13 +3214,13 @@ const Parser = struct {	...	@@ -3180,13 +3214,13 @@ const Parser = struct {
3180	pub fn parseLPAREN(p: *Parser) bool {	3214	pub fn parseLPAREN(p: *Parser) bool {
3181	return blk_0: {	3215	return blk_0: {
3182	const pos_0 = p.i;	3216	const pos_0 = p.i;
3183	if (blk_1: {	3217	if (p.parseskip() and blk_1: {
3184	if (std.mem.startsWith(u8, p.source[p.i..], "(")) {	3218	if (std.mem.startsWith(u8, p.source[p.i..], "(")) {
3185	p.i += 1;	3219	p.i += 1;
3186	break :blk_1 true;	3220	break :blk_1 true;
3187	}	3221	}
3188	break :blk_1 false;	3222	break :blk_1 false;
3189	} and p.parseskip()) break :blk_0 true;	3223	}) break :blk_0 true;
3190	p.i = pos_0;	3224	p.i = pos_0;
3191	break :blk_0 false;	3225	break :blk_0 false;
3192	};	3226	};
...	@@ -3194,7 +3228,7 @@ const Parser = struct {	...	@@ -3194,7 +3228,7 @@ const Parser = struct {
3194	pub fn parseMINUS(p: *Parser) bool {	3228	pub fn parseMINUS(p: *Parser) bool {
3195	return blk_0: {	3229	return blk_0: {
3196	const pos_0 = p.i;	3230	const pos_0 = p.i;
3197	if (blk_1: {	3231	if (p.parseskip() and blk_1: {
3198	if (std.mem.startsWith(u8, p.source[p.i..], "-")) {	3232	if (std.mem.startsWith(u8, p.source[p.i..], "-")) {
3199	p.i += 1;	3233	p.i += 1;
3200	break :blk_1 true;	3234	break :blk_1 true;
...	@@ -3215,7 +3249,7 @@ const Parser = struct {	...	@@ -3215,7 +3249,7 @@ const Parser = struct {
3215	});	3249	});
3216	p.i = pos_1;	3250	p.i = pos_1;
3217	break :blk_1 !match_1;	3251	break :blk_1 !match_1;
3218	} and p.parseskip()) break :blk_0 true;	3252	}) break :blk_0 true;
3219	p.i = pos_0;	3253	p.i = pos_0;
3220	break :blk_0 false;	3254	break :blk_0 false;
3221	};	3255	};
...	@@ -3223,13 +3257,13 @@ const Parser = struct {	...	@@ -3223,13 +3257,13 @@ const Parser = struct {
3223	pub fn parseMINUSEQUAL(p: *Parser) bool {	3257	pub fn parseMINUSEQUAL(p: *Parser) bool {
3224	return blk_0: {	3258	return blk_0: {
3225	const pos_0 = p.i;	3259	const pos_0 = p.i;
3226	if (blk_1: {	3260	if (p.parseskip() and blk_1: {
3227	if (std.mem.startsWith(u8, p.source[p.i..], "-=")) {	3261	if (std.mem.startsWith(u8, p.source[p.i..], "-=")) {
3228	p.i += 2;	3262	p.i += 2;
3229	break :blk_1 true;	3263	break :blk_1 true;
3230	}	3264	}
3231	break :blk_1 false;	3265	break :blk_1 false;
3232	} and p.parseskip()) break :blk_0 true;	3266	}) break :blk_0 true;
3233	p.i = pos_0;	3267	p.i = pos_0;
3234	break :blk_0 false;	3268	break :blk_0 false;
3235	};	3269	};
...	@@ -3237,7 +3271,7 @@ const Parser = struct {	...	@@ -3237,7 +3271,7 @@ const Parser = struct {
3237	pub fn parseMINUSPERCENT(p: *Parser) bool {	3271	pub fn parseMINUSPERCENT(p: *Parser) bool {
3238	return blk_0: {	3272	return blk_0: {
3239	const pos_0 = p.i;	3273	const pos_0 = p.i;
3240	if (blk_1: {	3274	if (p.parseskip() and blk_1: {
3241	if (std.mem.startsWith(u8, p.source[p.i..], "-%")) {	3275	if (std.mem.startsWith(u8, p.source[p.i..], "-%")) {
3242	p.i += 2;	3276	p.i += 2;
3243	break :blk_1 true;	3277	break :blk_1 true;
...	@@ -3255,7 +3289,7 @@ const Parser = struct {	...	@@ -3255,7 +3289,7 @@ const Parser = struct {
3255	});	3289	});
3256	p.i = pos_1;	3290	p.i = pos_1;
3257	break :blk_1 !match_1;	3291	break :blk_1 !match_1;
3258	} and p.parseskip()) break :blk_0 true;	3292	}) break :blk_0 true;
3259	p.i = pos_0;	3293	p.i = pos_0;
3260	break :blk_0 false;	3294	break :blk_0 false;
3261	};	3295	};
...	@@ -3263,13 +3297,13 @@ const Parser = struct {	...	@@ -3263,13 +3297,13 @@ const Parser = struct {
3263	pub fn parseMINUSPERCENTEQUAL(p: *Parser) bool {	3297	pub fn parseMINUSPERCENTEQUAL(p: *Parser) bool {
3264	return blk_0: {	3298	return blk_0: {
3265	const pos_0 = p.i;	3299	const pos_0 = p.i;
3266	if (blk_1: {	3300	if (p.parseskip() and blk_1: {
3267	if (std.mem.startsWith(u8, p.source[p.i..], "-%=")) {	3301	if (std.mem.startsWith(u8, p.source[p.i..], "-%=")) {
3268	p.i += 3;	3302	p.i += 3;
3269	break :blk_1 true;	3303	break :blk_1 true;
3270	}	3304	}
3271	break :blk_1 false;	3305	break :blk_1 false;
3272	} and p.parseskip()) break :blk_0 true;	3306	}) break :blk_0 true;
3273	p.i = pos_0;	3307	p.i = pos_0;
3274	break :blk_0 false;	3308	break :blk_0 false;
3275	};	3309	};
...	@@ -3277,7 +3311,7 @@ const Parser = struct {	...	@@ -3277,7 +3311,7 @@ const Parser = struct {
3277	pub fn parseMINUSPIPE(p: *Parser) bool {	3311	pub fn parseMINUSPIPE(p: *Parser) bool {
3278	return blk_0: {	3312	return blk_0: {
3279	const pos_0 = p.i;	3313	const pos_0 = p.i;
3280	if (blk_1: {	3314	if (p.parseskip() and blk_1: {
3281	if (std.mem.startsWith(u8, p.source[p.i..], "-\|")) {	3315	if (std.mem.startsWith(u8, p.source[p.i..], "-\|")) {
3282	p.i += 2;	3316	p.i += 2;
3283	break :blk_1 true;	3317	break :blk_1 true;
...	@@ -3295,7 +3329,7 @@ const Parser = struct {	...	@@ -3295,7 +3329,7 @@ const Parser = struct {
3295	});	3329	});
3296	p.i = pos_1;	3330	p.i = pos_1;
3297	break :blk_1 !match_1;	3331	break :blk_1 !match_1;
3298	} and p.parseskip()) break :blk_0 true;	3332	}) break :blk_0 true;
3299	p.i = pos_0;	3333	p.i = pos_0;
3300	break :blk_0 false;	3334	break :blk_0 false;
3301	};	3335	};
...	@@ -3303,13 +3337,13 @@ const Parser = struct {	...	@@ -3303,13 +3337,13 @@ const Parser = struct {
3303	pub fn parseMINUSPIPEEQUAL(p: *Parser) bool {	3337	pub fn parseMINUSPIPEEQUAL(p: *Parser) bool {
3304	return blk_0: {	3338	return blk_0: {
3305	const pos_0 = p.i;	3339	const pos_0 = p.i;
3306	if (blk_1: {	3340	if (p.parseskip() and blk_1: {
3307	if (std.mem.startsWith(u8, p.source[p.i..], "-\|=")) {	3341	if (std.mem.startsWith(u8, p.source[p.i..], "-\|=")) {
3308	p.i += 3;	3342	p.i += 3;
3309	break :blk_1 true;	3343	break :blk_1 true;
3310	}	3344	}
3311	break :blk_1 false;	3345	break :blk_1 false;
3312	} and p.parseskip()) break :blk_0 true;	3346	}) break :blk_0 true;
3313	p.i = pos_0;	3347	p.i = pos_0;
3314	break :blk_0 false;	3348	break :blk_0 false;
3315	};	3349	};
...	@@ -3317,13 +3351,13 @@ const Parser = struct {	...	@@ -3317,13 +3351,13 @@ const Parser = struct {
3317	pub fn parseMINUSRARROW(p: *Parser) bool {	3351	pub fn parseMINUSRARROW(p: *Parser) bool {
3318	return blk_0: {	3352	return blk_0: {
3319	const pos_0 = p.i;	3353	const pos_0 = p.i;
3320	if (blk_1: {	3354	if (p.parseskip() and blk_1: {
3321	if (std.mem.startsWith(u8, p.source[p.i..], "->")) {	3355	if (std.mem.startsWith(u8, p.source[p.i..], "->")) {
3322	p.i += 2;	3356	p.i += 2;
3323	break :blk_1 true;	3357	break :blk_1 true;
3324	}	3358	}
3325	break :blk_1 false;	3359	break :blk_1 false;
3326	} and p.parseskip()) break :blk_0 true;	3360	}) break :blk_0 true;
3327	p.i = pos_0;	3361	p.i = pos_0;
3328	break :blk_0 false;	3362	break :blk_0 false;
3329	};	3363	};
...	@@ -3331,7 +3365,7 @@ const Parser = struct {	...	@@ -3331,7 +3365,7 @@ const Parser = struct {
3331	pub fn parsePERCENT(p: *Parser) bool {	3365	pub fn parsePERCENT(p: *Parser) bool {
3332	return blk_0: {	3366	return blk_0: {
3333	const pos_0 = p.i;	3367	const pos_0 = p.i;
3334	if (blk_1: {	3368	if (p.parseskip() and blk_1: {
3335	if (std.mem.startsWith(u8, p.source[p.i..], "%")) {	3369	if (std.mem.startsWith(u8, p.source[p.i..], "%")) {
3336	p.i += 1;	3370	p.i += 1;
3337	break :blk_1 true;	3371	break :blk_1 true;
...	@@ -3349,7 +3383,7 @@ const Parser = struct {	...	@@ -3349,7 +3383,7 @@ const Parser = struct {
3349	});	3383	});
3350	p.i = pos_1;	3384	p.i = pos_1;
3351	break :blk_1 !match_1;	3385	break :blk_1 !match_1;
3352	} and p.parseskip()) break :blk_0 true;	3386	}) break :blk_0 true;
3353	p.i = pos_0;	3387	p.i = pos_0;
3354	break :blk_0 false;	3388	break :blk_0 false;
3355	};	3389	};
...	@@ -3357,13 +3391,13 @@ const Parser = struct {	...	@@ -3357,13 +3391,13 @@ const Parser = struct {
3357	pub fn parsePERCENTEQUAL(p: *Parser) bool {	3391	pub fn parsePERCENTEQUAL(p: *Parser) bool {
3358	return blk_0: {	3392	return blk_0: {
3359	const pos_0 = p.i;	3393	const pos_0 = p.i;
3360	if (blk_1: {	3394	if (p.parseskip() and blk_1: {
3361	if (std.mem.startsWith(u8, p.source[p.i..], "%=")) {	3395	if (std.mem.startsWith(u8, p.source[p.i..], "%=")) {
3362	p.i += 2;	3396	p.i += 2;
3363	break :blk_1 true;	3397	break :blk_1 true;
3364	}	3398	}
3365	break :blk_1 false;	3399	break :blk_1 false;
3366	} and p.parseskip()) break :blk_0 true;	3400	}) break :blk_0 true;
3367	p.i = pos_0;	3401	p.i = pos_0;
3368	break :blk_0 false;	3402	break :blk_0 false;
3369	};	3403	};
...	@@ -3371,7 +3405,7 @@ const Parser = struct {	...	@@ -3371,7 +3405,7 @@ const Parser = struct {
3371	pub fn parsePIPE(p: *Parser) bool {	3405	pub fn parsePIPE(p: *Parser) bool {
3372	return blk_0: {	3406	return blk_0: {
3373	const pos_0 = p.i;	3407	const pos_0 = p.i;
3374	if (blk_1: {	3408	if (p.parseskip() and blk_1: {
3375	if (std.mem.startsWith(u8, p.source[p.i..], "\|")) {	3409	if (std.mem.startsWith(u8, p.source[p.i..], "\|")) {
3376	p.i += 1;	3410	p.i += 1;
3377	break :blk_1 true;	3411	break :blk_1 true;
...	@@ -3390,7 +3424,7 @@ const Parser = struct {	...	@@ -3390,7 +3424,7 @@ const Parser = struct {
3390	});	3424	});
3391	p.i = pos_1;	3425	p.i = pos_1;
3392	break :blk_1 !match_1;	3426	break :blk_1 !match_1;
3393	} and p.parseskip()) break :blk_0 true;	3427	}) break :blk_0 true;
3394	p.i = pos_0;	3428	p.i = pos_0;
3395	break :blk_0 false;	3429	break :blk_0 false;
3396	};	3430	};
...	@@ -3398,13 +3432,13 @@ const Parser = struct {	...	@@ -3398,13 +3432,13 @@ const Parser = struct {
3398	pub fn parsePIPE2(p: *Parser) bool {	3432	pub fn parsePIPE2(p: *Parser) bool {
3399	return blk_0: {	3433	return blk_0: {
3400	const pos_0 = p.i;	3434	const pos_0 = p.i;
3401	if (blk_1: {	3435	if (p.parseskip() and blk_1: {
3402	if (std.mem.startsWith(u8, p.source[p.i..], "\|\|")) {	3436	if (std.mem.startsWith(u8, p.source[p.i..], "\|\|")) {
3403	p.i += 2;	3437	p.i += 2;
3404	break :blk_1 true;	3438	break :blk_1 true;
3405	}	3439	}
3406	break :blk_1 false;	3440	break :blk_1 false;
3407	} and p.parseskip()) break :blk_0 true;	3441	}) break :blk_0 true;
3408	p.i = pos_0;	3442	p.i = pos_0;
3409	break :blk_0 false;	3443	break :blk_0 false;
3410	};	3444	};
...	@@ -3412,13 +3446,13 @@ const Parser = struct {	...	@@ -3412,13 +3446,13 @@ const Parser = struct {
3412	pub fn parsePIPEEQUAL(p: *Parser) bool {	3446	pub fn parsePIPEEQUAL(p: *Parser) bool {
3413	return blk_0: {	3447	return blk_0: {
3414	const pos_0 = p.i;	3448	const pos_0 = p.i;
3415	if (blk_1: {	3449	if (p.parseskip() and blk_1: {
3416	if (std.mem.startsWith(u8, p.source[p.i..], "\|=")) {	3450	if (std.mem.startsWith(u8, p.source[p.i..], "\|=")) {
3417	p.i += 2;	3451	p.i += 2;
3418	break :blk_1 true;	3452	break :blk_1 true;
3419	}	3453	}
3420	break :blk_1 false;	3454	break :blk_1 false;
3421	} and p.parseskip()) break :blk_0 true;	3455	}) break :blk_0 true;
3422	p.i = pos_0;	3456	p.i = pos_0;
3423	break :blk_0 false;	3457	break :blk_0 false;
3424	};	3458	};
...	@@ -3426,7 +3460,7 @@ const Parser = struct {	...	@@ -3426,7 +3460,7 @@ const Parser = struct {
3426	pub fn parsePLUS(p: *Parser) bool {	3460	pub fn parsePLUS(p: *Parser) bool {
3427	return blk_0: {	3461	return blk_0: {
3428	const pos_0 = p.i;	3462	const pos_0 = p.i;
3429	if (blk_1: {	3463	if (p.parseskip() and blk_1: {
3430	if (std.mem.startsWith(u8, p.source[p.i..], "+")) {	3464	if (std.mem.startsWith(u8, p.source[p.i..], "+")) {
3431	p.i += 1;	3465	p.i += 1;
3432	break :blk_1 true;	3466	break :blk_1 true;
...	@@ -3447,7 +3481,7 @@ const Parser = struct {	...	@@ -3447,7 +3481,7 @@ const Parser = struct {
3447	});	3481	});
3448	p.i = pos_1;	3482	p.i = pos_1;
3449	break :blk_1 !match_1;	3483	break :blk_1 !match_1;
3450	} and p.parseskip()) break :blk_0 true;	3484	}) break :blk_0 true;
3451	p.i = pos_0;	3485	p.i = pos_0;
3452	break :blk_0 false;	3486	break :blk_0 false;
3453	};	3487	};
...	@@ -3455,13 +3489,13 @@ const Parser = struct {	...	@@ -3455,13 +3489,13 @@ const Parser = struct {
3455	pub fn parsePLUS2(p: *Parser) bool {	3489	pub fn parsePLUS2(p: *Parser) bool {
3456	return blk_0: {	3490	return blk_0: {
3457	const pos_0 = p.i;	3491	const pos_0 = p.i;
3458	if (blk_1: {	3492	if (p.parseskip() and blk_1: {
3459	if (std.mem.startsWith(u8, p.source[p.i..], "++")) {	3493	if (std.mem.startsWith(u8, p.source[p.i..], "++")) {
3460	p.i += 2;	3494	p.i += 2;
3461	break :blk_1 true;	3495	break :blk_1 true;
3462	}	3496	}
3463	break :blk_1 false;	3497	break :blk_1 false;
3464	} and p.parseskip()) break :blk_0 true;	3498	}) break :blk_0 true;
3465	p.i = pos_0;	3499	p.i = pos_0;
3466	break :blk_0 false;	3500	break :blk_0 false;
3467	};	3501	};
...	@@ -3469,13 +3503,13 @@ const Parser = struct {	...	@@ -3469,13 +3503,13 @@ const Parser = struct {
3469	pub fn parsePLUSEQUAL(p: *Parser) bool {	3503	pub fn parsePLUSEQUAL(p: *Parser) bool {
3470	return blk_0: {	3504	return blk_0: {
3471	const pos_0 = p.i;	3505	const pos_0 = p.i;
3472	if (blk_1: {	3506	if (p.parseskip() and blk_1: {
3473	if (std.mem.startsWith(u8, p.source[p.i..], "+=")) {	3507	if (std.mem.startsWith(u8, p.source[p.i..], "+=")) {
3474	p.i += 2;	3508	p.i += 2;
3475	break :blk_1 true;	3509	break :blk_1 true;
3476	}	3510	}
3477	break :blk_1 false;	3511	break :blk_1 false;
3478	} and p.parseskip()) break :blk_0 true;	3512	}) break :blk_0 true;
3479	p.i = pos_0;	3513	p.i = pos_0;
3480	break :blk_0 false;	3514	break :blk_0 false;
3481	};	3515	};
...	@@ -3483,7 +3517,7 @@ const Parser = struct {	...	@@ -3483,7 +3517,7 @@ const Parser = struct {
3483	pub fn parsePLUSPERCENT(p: *Parser) bool {	3517	pub fn parsePLUSPERCENT(p: *Parser) bool {
3484	return blk_0: {	3518	return blk_0: {
3485	const pos_0 = p.i;	3519	const pos_0 = p.i;
3486	if (blk_1: {	3520	if (p.parseskip() and blk_1: {
3487	if (std.mem.startsWith(u8, p.source[p.i..], "+%")) {	3521	if (std.mem.startsWith(u8, p.source[p.i..], "+%")) {
3488	p.i += 2;	3522	p.i += 2;
3489	break :blk_1 true;	3523	break :blk_1 true;
...	@@ -3501,7 +3535,7 @@ const Parser = struct {	...	@@ -3501,7 +3535,7 @@ const Parser = struct {
3501	});	3535	});
3502	p.i = pos_1;	3536	p.i = pos_1;
3503	break :blk_1 !match_1;	3537	break :blk_1 !match_1;
3504	} and p.parseskip()) break :blk_0 true;	3538	}) break :blk_0 true;
3505	p.i = pos_0;	3539	p.i = pos_0;
3506	break :blk_0 false;	3540	break :blk_0 false;
3507	};	3541	};
...	@@ -3509,13 +3543,13 @@ const Parser = struct {	...	@@ -3509,13 +3543,13 @@ const Parser = struct {
3509	pub fn parsePLUSPERCENTEQUAL(p: *Parser) bool {	3543	pub fn parsePLUSPERCENTEQUAL(p: *Parser) bool {
3510	return blk_0: {	3544	return blk_0: {
3511	const pos_0 = p.i;	3545	const pos_0 = p.i;
3512	if (blk_1: {	3546	if (p.parseskip() and blk_1: {
3513	if (std.mem.startsWith(u8, p.source[p.i..], "+%=")) {	3547	if (std.mem.startsWith(u8, p.source[p.i..], "+%=")) {
3514	p.i += 3;	3548	p.i += 3;
3515	break :blk_1 true;	3549	break :blk_1 true;
3516	}	3550	}
3517	break :blk_1 false;	3551	break :blk_1 false;
3518	} and p.parseskip()) break :blk_0 true;	3552	}) break :blk_0 true;
3519	p.i = pos_0;	3553	p.i = pos_0;
3520	break :blk_0 false;	3554	break :blk_0 false;
3521	};	3555	};
...	@@ -3523,7 +3557,7 @@ const Parser = struct {	...	@@ -3523,7 +3557,7 @@ const Parser = struct {
3523	pub fn parsePLUSPIPE(p: *Parser) bool {	3557	pub fn parsePLUSPIPE(p: *Parser) bool {
3524	return blk_0: {	3558	return blk_0: {
3525	const pos_0 = p.i;	3559	const pos_0 = p.i;
3526	if (blk_1: {	3560	if (p.parseskip() and blk_1: {
3527	if (std.mem.startsWith(u8, p.source[p.i..], "+\|")) {	3561	if (std.mem.startsWith(u8, p.source[p.i..], "+\|")) {
3528	p.i += 2;	3562	p.i += 2;
3529	break :blk_1 true;	3563	break :blk_1 true;
...	@@ -3541,7 +3575,7 @@ const Parser = struct {	...	@@ -3541,7 +3575,7 @@ const Parser = struct {
3541	});	3575	});
3542	p.i = pos_1;	3576	p.i = pos_1;
3543	break :blk_1 !match_1;	3577	break :blk_1 !match_1;
3544	} and p.parseskip()) break :blk_0 true;	3578	}) break :blk_0 true;
3545	p.i = pos_0;	3579	p.i = pos_0;
3546	break :blk_0 false;	3580	break :blk_0 false;
3547	};	3581	};
...	@@ -3549,13 +3583,13 @@ const Parser = struct {	...	@@ -3549,13 +3583,13 @@ const Parser = struct {
3549	pub fn parsePLUSPIPEEQUAL(p: *Parser) bool {	3583	pub fn parsePLUSPIPEEQUAL(p: *Parser) bool {
3550	return blk_0: {	3584	return blk_0: {
3551	const pos_0 = p.i;	3585	const pos_0 = p.i;
3552	if (blk_1: {	3586	if (p.parseskip() and blk_1: {
3553	if (std.mem.startsWith(u8, p.source[p.i..], "+\|=")) {	3587	if (std.mem.startsWith(u8, p.source[p.i..], "+\|=")) {
3554	p.i += 3;	3588	p.i += 3;
3555	break :blk_1 true;	3589	break :blk_1 true;
3556	}	3590	}
3557	break :blk_1 false;	3591	break :blk_1 false;
3558	} and p.parseskip()) break :blk_0 true;	3592	}) break :blk_0 true;
3559	p.i = pos_0;	3593	p.i = pos_0;
3560	break :blk_0 false;	3594	break :blk_0 false;
3561	};	3595	};
...	@@ -3563,13 +3597,13 @@ const Parser = struct {	...	@@ -3563,13 +3597,13 @@ const Parser = struct {
3563	pub fn parseLETTERC(p: *Parser) bool {	3597	pub fn parseLETTERC(p: *Parser) bool {
3564	return blk_0: {	3598	return blk_0: {
3565	const pos_0 = p.i;	3599	const pos_0 = p.i;
3566	if (blk_1: {	3600	if (p.parseskip() and blk_1: {
3567	if (std.mem.startsWith(u8, p.source[p.i..], "c")) {	3601	if (std.mem.startsWith(u8, p.source[p.i..], "c")) {
3568	p.i += 1;	3602	p.i += 1;
3569	break :blk_1 true;	3603	break :blk_1 true;
3570	}	3604	}
3571	break :blk_1 false;	3605	break :blk_1 false;
3572	} and p.parseskip()) break :blk_0 true;	3606	}) break :blk_0 true;
3573	p.i = pos_0;	3607	p.i = pos_0;
3574	break :blk_0 false;	3608	break :blk_0 false;
3575	};	3609	};
...	@@ -3577,13 +3611,13 @@ const Parser = struct {	...	@@ -3577,13 +3611,13 @@ const Parser = struct {
3577	pub fn parseQUESTIONMARK(p: *Parser) bool {	3611	pub fn parseQUESTIONMARK(p: *Parser) bool {
3578	return blk_0: {	3612	return blk_0: {
3579	const pos_0 = p.i;	3613	const pos_0 = p.i;
3580	if (blk_1: {	3614	if (p.parseskip() and blk_1: {
3581	if (std.mem.startsWith(u8, p.source[p.i..], "?")) {	3615	if (std.mem.startsWith(u8, p.source[p.i..], "?")) {
3582	p.i += 1;	3616	p.i += 1;
3583	break :blk_1 true;	3617	break :blk_1 true;
3584	}	3618	}
3585	break :blk_1 false;	3619	break :blk_1 false;
3586	} and p.parseskip()) break :blk_0 true;	3620	}) break :blk_0 true;
3587	p.i = pos_0;	3621	p.i = pos_0;
3588	break :blk_0 false;	3622	break :blk_0 false;
3589	};	3623	};
...	@@ -3591,7 +3625,7 @@ const Parser = struct {	...	@@ -3591,7 +3625,7 @@ const Parser = struct {
3591	pub fn parseRARROW(p: *Parser) bool {	3625	pub fn parseRARROW(p: *Parser) bool {
3592	return blk_0: {	3626	return blk_0: {
3593	const pos_0 = p.i;	3627	const pos_0 = p.i;
3594	if (blk_1: {	3628	if (p.parseskip() and blk_1: {
3595	if (std.mem.startsWith(u8, p.source[p.i..], ">")) {	3629	if (std.mem.startsWith(u8, p.source[p.i..], ">")) {
3596	p.i += 1;	3630	p.i += 1;
3597	break :blk_1 true;	3631	break :blk_1 true;
...	@@ -3610,7 +3644,7 @@ const Parser = struct {	...	@@ -3610,7 +3644,7 @@ const Parser = struct {
3610	});	3644	});
3611	p.i = pos_1;	3645	p.i = pos_1;
3612	break :blk_1 !match_1;	3646	break :blk_1 !match_1;
3613	} and p.parseskip()) break :blk_0 true;	3647	}) break :blk_0 true;
3614	p.i = pos_0;	3648	p.i = pos_0;
3615	break :blk_0 false;	3649	break :blk_0 false;
3616	};	3650	};
...	@@ -3618,7 +3652,7 @@ const Parser = struct {	...	@@ -3618,7 +3652,7 @@ const Parser = struct {
3618	pub fn parseRARROW2(p: *Parser) bool {	3652	pub fn parseRARROW2(p: *Parser) bool {
3619	return blk_0: {	3653	return blk_0: {
3620	const pos_0 = p.i;	3654	const pos_0 = p.i;
3621	if (blk_1: {	3655	if (p.parseskip() and blk_1: {
3622	if (std.mem.startsWith(u8, p.source[p.i..], ">>")) {	3656	if (std.mem.startsWith(u8, p.source[p.i..], ">>")) {
3623	p.i += 2;	3657	p.i += 2;
3624	break :blk_1 true;	3658	break :blk_1 true;
...	@@ -3636,7 +3670,7 @@ const Parser = struct {	...	@@ -3636,7 +3670,7 @@ const Parser = struct {
3636	});	3670	});
3637	p.i = pos_1;	3671	p.i = pos_1;
3638	break :blk_1 !match_1;	3672	break :blk_1 !match_1;
3639	} and p.parseskip()) break :blk_0 true;	3673	}) break :blk_0 true;
3640	p.i = pos_0;	3674	p.i = pos_0;
3641	break :blk_0 false;	3675	break :blk_0 false;
3642	};	3676	};
...	@@ -3644,13 +3678,13 @@ const Parser = struct {	...	@@ -3644,13 +3678,13 @@ const Parser = struct {
3644	pub fn parseRARROW2EQUAL(p: *Parser) bool {	3678	pub fn parseRARROW2EQUAL(p: *Parser) bool {
3645	return blk_0: {	3679	return blk_0: {
3646	const pos_0 = p.i;	3680	const pos_0 = p.i;
3647	if (blk_1: {	3681	if (p.parseskip() and blk_1: {
3648	if (std.mem.startsWith(u8, p.source[p.i..], ">>=")) {	3682	if (std.mem.startsWith(u8, p.source[p.i..], ">>=")) {
3649	p.i += 3;	3683	p.i += 3;
3650	break :blk_1 true;	3684	break :blk_1 true;
3651	}	3685	}
3652	break :blk_1 false;	3686	break :blk_1 false;
3653	} and p.parseskip()) break :blk_0 true;	3687	}) break :blk_0 true;
3654	p.i = pos_0;	3688	p.i = pos_0;
3655	break :blk_0 false;	3689	break :blk_0 false;
3656	};	3690	};
...	@@ -3658,13 +3692,13 @@ const Parser = struct {	...	@@ -3658,13 +3692,13 @@ const Parser = struct {
3658	pub fn parseRARROWEQUAL(p: *Parser) bool {	3692	pub fn parseRARROWEQUAL(p: *Parser) bool {
3659	return blk_0: {	3693	return blk_0: {
3660	const pos_0 = p.i;	3694	const pos_0 = p.i;
3661	if (blk_1: {	3695	if (p.parseskip() and blk_1: {
3662	if (std.mem.startsWith(u8, p.source[p.i..], ">=")) {	3696	if (std.mem.startsWith(u8, p.source[p.i..], ">=")) {
3663	p.i += 2;	3697	p.i += 2;
3664	break :blk_1 true;	3698	break :blk_1 true;
3665	}	3699	}
3666	break :blk_1 false;	3700	break :blk_1 false;
3667	} and p.parseskip()) break :blk_0 true;	3701	}) break :blk_0 true;
3668	p.i = pos_0;	3702	p.i = pos_0;
3669	break :blk_0 false;	3703	break :blk_0 false;
3670	};	3704	};
...	@@ -3672,13 +3706,13 @@ const Parser = struct {	...	@@ -3672,13 +3706,13 @@ const Parser = struct {
3672	pub fn parseRBRACE(p: *Parser) bool {	3706	pub fn parseRBRACE(p: *Parser) bool {
3673	return blk_0: {	3707	return blk_0: {
3674	const pos_0 = p.i;	3708	const pos_0 = p.i;
3675	if (blk_1: {	3709	if (p.parseskip() and blk_1: {
3676	if (std.mem.startsWith(u8, p.source[p.i..], "}")) {	3710	if (std.mem.startsWith(u8, p.source[p.i..], "}")) {
3677	p.i += 1;	3711	p.i += 1;
3678	break :blk_1 true;	3712	break :blk_1 true;
3679	}	3713	}
3680	break :blk_1 false;	3714	break :blk_1 false;
3681	} and p.parseskip()) break :blk_0 true;	3715	}) break :blk_0 true;
3682	p.i = pos_0;	3716	p.i = pos_0;
3683	break :blk_0 false;	3717	break :blk_0 false;
3684	};	3718	};
...	@@ -3686,13 +3720,13 @@ const Parser = struct {	...	@@ -3686,13 +3720,13 @@ const Parser = struct {
3686	pub fn parseRBRACKET(p: *Parser) bool {	3720	pub fn parseRBRACKET(p: *Parser) bool {
3687	return blk_0: {	3721	return blk_0: {
3688	const pos_0 = p.i;	3722	const pos_0 = p.i;
3689	if (blk_1: {	3723	if (p.parseskip() and blk_1: {
3690	if (std.mem.startsWith(u8, p.source[p.i..], "]")) {	3724	if (std.mem.startsWith(u8, p.source[p.i..], "]")) {
3691	p.i += 1;	3725	p.i += 1;
3692	break :blk_1 true;	3726	break :blk_1 true;
3693	}	3727	}
3694	break :blk_1 false;	3728	break :blk_1 false;
3695	} and p.parseskip()) break :blk_0 true;	3729	}) break :blk_0 true;
3696	p.i = pos_0;	3730	p.i = pos_0;
3697	break :blk_0 false;	3731	break :blk_0 false;
3698	};	3732	};
...	@@ -3700,13 +3734,13 @@ const Parser = struct {	...	@@ -3700,13 +3734,13 @@ const Parser = struct {
3700	pub fn parseRPAREN(p: *Parser) bool {	3734	pub fn parseRPAREN(p: *Parser) bool {
3701	return blk_0: {	3735	return blk_0: {
3702	const pos_0 = p.i;	3736	const pos_0 = p.i;
3703	if (blk_1: {	3737	if (p.parseskip() and blk_1: {
3704	if (std.mem.startsWith(u8, p.source[p.i..], ")")) {	3738	if (std.mem.startsWith(u8, p.source[p.i..], ")")) {
3705	p.i += 1;	3739	p.i += 1;
3706	break :blk_1 true;	3740	break :blk_1 true;
3707	}	3741	}
3708	break :blk_1 false;	3742	break :blk_1 false;
3709	} and p.parseskip()) break :blk_0 true;	3743	}) break :blk_0 true;
3710	p.i = pos_0;	3744	p.i = pos_0;
3711	break :blk_0 false;	3745	break :blk_0 false;
3712	};	3746	};
...	@@ -3714,13 +3748,13 @@ const Parser = struct {	...	@@ -3714,13 +3748,13 @@ const Parser = struct {
3714	pub fn parseSEMICOLON(p: *Parser) bool {	3748	pub fn parseSEMICOLON(p: *Parser) bool {
3715	return blk_0: {	3749	return blk_0: {
3716	const pos_0 = p.i;	3750	const pos_0 = p.i;
3717	if (blk_1: {	3751	if (p.parseskip() and blk_1: {
3718	if (std.mem.startsWith(u8, p.source[p.i..], ";")) {	3752	if (std.mem.startsWith(u8, p.source[p.i..], ";")) {
3719	p.i += 1;	3753	p.i += 1;
3720	break :blk_1 true;	3754	break :blk_1 true;
3721	}	3755	}
3722	break :blk_1 false;	3756	break :blk_1 false;
3723	} and p.parseskip()) break :blk_0 true;	3757	}) break :blk_0 true;
3724	p.i = pos_0;	3758	p.i = pos_0;
3725	break :blk_0 false;	3759	break :blk_0 false;
3726	};	3760	};
...	@@ -3728,7 +3762,7 @@ const Parser = struct {	...	@@ -3728,7 +3762,7 @@ const Parser = struct {
3728	pub fn parseSLASH(p: *Parser) bool {	3762	pub fn parseSLASH(p: *Parser) bool {
3729	return blk_0: {	3763	return blk_0: {
3730	const pos_0 = p.i;	3764	const pos_0 = p.i;
3731	if (blk_1: {	3765	if (p.parseskip() and blk_1: {
3732	if (std.mem.startsWith(u8, p.source[p.i..], "/")) {	3766	if (std.mem.startsWith(u8, p.source[p.i..], "/")) {
3733	p.i += 1;	3767	p.i += 1;
3734	break :blk_1 true;	3768	break :blk_1 true;
...	@@ -3746,7 +3780,7 @@ const Parser = struct {	...	@@ -3746,7 +3780,7 @@ const Parser = struct {
3746	});	3780	});
3747	p.i = pos_1;	3781	p.i = pos_1;
3748	break :blk_1 !match_1;	3782	break :blk_1 !match_1;
3749	} and p.parseskip()) break :blk_0 true;	3783	}) break :blk_0 true;
3750	p.i = pos_0;	3784	p.i = pos_0;
3751	break :blk_0 false;	3785	break :blk_0 false;
3752	};	3786	};
...	@@ -3754,13 +3788,13 @@ const Parser = struct {	...	@@ -3754,13 +3788,13 @@ const Parser = struct {
3754	pub fn parseSLASHEQUAL(p: *Parser) bool {	3788	pub fn parseSLASHEQUAL(p: *Parser) bool {
3755	return blk_0: {	3789	return blk_0: {
3756	const pos_0 = p.i;	3790	const pos_0 = p.i;
3757	if (blk_1: {	3791	if (p.parseskip() and blk_1: {
3758	if (std.mem.startsWith(u8, p.source[p.i..], "/=")) {	3792	if (std.mem.startsWith(u8, p.source[p.i..], "/=")) {
3759	p.i += 2;	3793	p.i += 2;
3760	break :blk_1 true;	3794	break :blk_1 true;
3761	}	3795	}
3762	break :blk_1 false;	3796	break :blk_1 false;
3763	} and p.parseskip()) break :blk_0 true;	3797	}) break :blk_0 true;
3764	p.i = pos_0;	3798	p.i = pos_0;
3765	break :blk_0 false;	3799	break :blk_0 false;
3766	};	3800	};
...	@@ -3768,13 +3802,13 @@ const Parser = struct {	...	@@ -3768,13 +3802,13 @@ const Parser = struct {
3768	pub fn parseTILDE(p: *Parser) bool {	3802	pub fn parseTILDE(p: *Parser) bool {
3769	return blk_0: {	3803	return blk_0: {
3770	const pos_0 = p.i;	3804	const pos_0 = p.i;
3771	if (blk_1: {	3805	if (p.parseskip() and blk_1: {
3772	if (std.mem.startsWith(u8, p.source[p.i..], "~")) {	3806	if (std.mem.startsWith(u8, p.source[p.i..], "~")) {
3773	p.i += 1;	3807	p.i += 1;
3774	break :blk_1 true;	3808	break :blk_1 true;
3775	}	3809	}
3776	break :blk_1 false;	3810	break :blk_1 false;
3777	} and p.parseskip()) break :blk_0 true;	3811	}) break :blk_0 true;
3778	p.i = pos_0;	3812	p.i = pos_0;
3779	break :blk_0 false;	3813	break :blk_0 false;
3780	};	3814	};
...	@@ -3797,7 +3831,7 @@ const Parser = struct {	...	@@ -3797,7 +3831,7 @@ const Parser = struct {
3797	});	3831	});
3798	p.i = pos_1;	3832	p.i = pos_1;
3799	break :blk_1 !match_1;	3833	break :blk_1 !match_1;
3800	} and p.parseskip()) break :blk_0 true;	3834	}) break :blk_0 true;
3801	p.i = pos_0;	3835	p.i = pos_0;
3802	break :blk_0 false;	3836	break :blk_0 false;
3803	};	3837	};
...	@@ -3805,7 +3839,7 @@ const Parser = struct {	...	@@ -3805,7 +3839,7 @@ const Parser = struct {
3805	pub fn parseKEYWORD_addrspace(p: *Parser) bool {	3839	pub fn parseKEYWORD_addrspace(p: *Parser) bool {
3806	return blk_0: {	3840	return blk_0: {
3807	const pos_0 = p.i;	3841	const pos_0 = p.i;
3808	if (blk_1: {	3842	if (p.parseskip() and blk_1: {
3809	if (std.mem.startsWith(u8, p.source[p.i..], "addrspace")) {	3843	if (std.mem.startsWith(u8, p.source[p.i..], "addrspace")) {
3810	p.i += 9;	3844	p.i += 9;
3811	break :blk_1 true;	3845	break :blk_1 true;
...	@@ -3819,7 +3853,7 @@ const Parser = struct {	...	@@ -3819,7 +3853,7 @@ const Parser = struct {
3819	pub fn parseKEYWORD_align(p: *Parser) bool {	3853	pub fn parseKEYWORD_align(p: *Parser) bool {
3820	return blk_0: {	3854	return blk_0: {
3821	const pos_0 = p.i;	3855	const pos_0 = p.i;
3822	if (blk_1: {	3856	if (p.parseskip() and blk_1: {
3823	if (std.mem.startsWith(u8, p.source[p.i..], "align")) {	3857	if (std.mem.startsWith(u8, p.source[p.i..], "align")) {
3824	p.i += 5;	3858	p.i += 5;
3825	break :blk_1 true;	3859	break :blk_1 true;
...	@@ -3833,7 +3867,7 @@ const Parser = struct {	...	@@ -3833,7 +3867,7 @@ const Parser = struct {
3833	pub fn parseKEYWORD_allowzero(p: *Parser) bool {	3867	pub fn parseKEYWORD_allowzero(p: *Parser) bool {
3834	return blk_0: {	3868	return blk_0: {
3835	const pos_0 = p.i;	3869	const pos_0 = p.i;
3836	if (blk_1: {	3870	if (p.parseskip() and blk_1: {
3837	if (std.mem.startsWith(u8, p.source[p.i..], "allowzero")) {	3871	if (std.mem.startsWith(u8, p.source[p.i..], "allowzero")) {
3838	p.i += 9;	3872	p.i += 9;
3839	break :blk_1 true;	3873	break :blk_1 true;
...	@@ -3847,7 +3881,7 @@ const Parser = struct {	...	@@ -3847,7 +3881,7 @@ const Parser = struct {
3847	pub fn parseKEYWORD_and(p: *Parser) bool {	3881	pub fn parseKEYWORD_and(p: *Parser) bool {
3848	return blk_0: {	3882	return blk_0: {
3849	const pos_0 = p.i;	3883	const pos_0 = p.i;
3850	if (blk_1: {	3884	if (p.parseskip() and blk_1: {
3851	if (std.mem.startsWith(u8, p.source[p.i..], "and")) {	3885	if (std.mem.startsWith(u8, p.source[p.i..], "and")) {
3852	p.i += 3;	3886	p.i += 3;
3853	break :blk_1 true;	3887	break :blk_1 true;
...	@@ -3861,7 +3895,7 @@ const Parser = struct {	...	@@ -3861,7 +3895,7 @@ const Parser = struct {
3861	pub fn parseKEYWORD_anyframe(p: *Parser) bool {	3895	pub fn parseKEYWORD_anyframe(p: *Parser) bool {
3862	return blk_0: {	3896	return blk_0: {
3863	const pos_0 = p.i;	3897	const pos_0 = p.i;
3864	if (blk_1: {	3898	if (p.parseskip() and blk_1: {
3865	if (std.mem.startsWith(u8, p.source[p.i..], "anyframe")) {	3899	if (std.mem.startsWith(u8, p.source[p.i..], "anyframe")) {
3866	p.i += 8;	3900	p.i += 8;
3867	break :blk_1 true;	3901	break :blk_1 true;
...	@@ -3875,7 +3909,7 @@ const Parser = struct {	...	@@ -3875,7 +3909,7 @@ const Parser = struct {
3875	pub fn parseKEYWORD_anytype(p: *Parser) bool {	3909	pub fn parseKEYWORD_anytype(p: *Parser) bool {
3876	return blk_0: {	3910	return blk_0: {
3877	const pos_0 = p.i;	3911	const pos_0 = p.i;
3878	if (blk_1: {	3912	if (p.parseskip() and blk_1: {
3879	if (std.mem.startsWith(u8, p.source[p.i..], "anytype")) {	3913	if (std.mem.startsWith(u8, p.source[p.i..], "anytype")) {
3880	p.i += 7;	3914	p.i += 7;
3881	break :blk_1 true;	3915	break :blk_1 true;
...	@@ -3889,7 +3923,7 @@ const Parser = struct {	...	@@ -3889,7 +3923,7 @@ const Parser = struct {
3889	pub fn parseKEYWORD_asm(p: *Parser) bool {	3923	pub fn parseKEYWORD_asm(p: *Parser) bool {
3890	return blk_0: {	3924	return blk_0: {
3891	const pos_0 = p.i;	3925	const pos_0 = p.i;
3892	if (blk_1: {	3926	if (p.parseskip() and blk_1: {
3893	if (std.mem.startsWith(u8, p.source[p.i..], "asm")) {	3927	if (std.mem.startsWith(u8, p.source[p.i..], "asm")) {
3894	p.i += 3;	3928	p.i += 3;
3895	break :blk_1 true;	3929	break :blk_1 true;
...	@@ -3903,7 +3937,7 @@ const Parser = struct {	...	@@ -3903,7 +3937,7 @@ const Parser = struct {
3903	pub fn parseKEYWORD_break(p: *Parser) bool {	3937	pub fn parseKEYWORD_break(p: *Parser) bool {
3904	return blk_0: {	3938	return blk_0: {
3905	const pos_0 = p.i;	3939	const pos_0 = p.i;
3906	if (blk_1: {	3940	if (p.parseskip() and blk_1: {
3907	if (std.mem.startsWith(u8, p.source[p.i..], "break")) {	3941	if (std.mem.startsWith(u8, p.source[p.i..], "break")) {
3908	p.i += 5;	3942	p.i += 5;
3909	break :blk_1 true;	3943	break :blk_1 true;
...	@@ -3917,7 +3951,7 @@ const Parser = struct {	...	@@ -3917,7 +3951,7 @@ const Parser = struct {
3917	pub fn parseKEYWORD_callconv(p: *Parser) bool {	3951	pub fn parseKEYWORD_callconv(p: *Parser) bool {
3918	return blk_0: {	3952	return blk_0: {
3919	const pos_0 = p.i;	3953	const pos_0 = p.i;
3920	if (blk_1: {	3954	if (p.parseskip() and blk_1: {
3921	if (std.mem.startsWith(u8, p.source[p.i..], "callconv")) {	3955	if (std.mem.startsWith(u8, p.source[p.i..], "callconv")) {
3922	p.i += 8;	3956	p.i += 8;
3923	break :blk_1 true;	3957	break :blk_1 true;
...	@@ -3931,7 +3965,7 @@ const Parser = struct {	...	@@ -3931,7 +3965,7 @@ const Parser = struct {
3931	pub fn parseKEYWORD_catch(p: *Parser) bool {	3965	pub fn parseKEYWORD_catch(p: *Parser) bool {
3932	return blk_0: {	3966	return blk_0: {
3933	const pos_0 = p.i;	3967	const pos_0 = p.i;
3934	if (blk_1: {	3968	if (p.parseskip() and blk_1: {
3935	if (std.mem.startsWith(u8, p.source[p.i..], "catch")) {	3969	if (std.mem.startsWith(u8, p.source[p.i..], "catch")) {
3936	p.i += 5;	3970	p.i += 5;
3937	break :blk_1 true;	3971	break :blk_1 true;
...	@@ -3945,7 +3979,7 @@ const Parser = struct {	...	@@ -3945,7 +3979,7 @@ const Parser = struct {
3945	pub fn parseKEYWORD_comptime(p: *Parser) bool {	3979	pub fn parseKEYWORD_comptime(p: *Parser) bool {
3946	return blk_0: {	3980	return blk_0: {
3947	const pos_0 = p.i;	3981	const pos_0 = p.i;
3948	if (blk_1: {	3982	if (p.parseskip() and blk_1: {
3949	if (std.mem.startsWith(u8, p.source[p.i..], "comptime")) {	3983	if (std.mem.startsWith(u8, p.source[p.i..], "comptime")) {
3950	p.i += 8;	3984	p.i += 8;
3951	break :blk_1 true;	3985	break :blk_1 true;
...	@@ -3959,7 +3993,7 @@ const Parser = struct {	...	@@ -3959,7 +3993,7 @@ const Parser = struct {
3959	pub fn parseKEYWORD_const(p: *Parser) bool {	3993	pub fn parseKEYWORD_const(p: *Parser) bool {
3960	return blk_0: {	3994	return blk_0: {
3961	const pos_0 = p.i;	3995	const pos_0 = p.i;
3962	if (blk_1: {	3996	if (p.parseskip() and blk_1: {
3963	if (std.mem.startsWith(u8, p.source[p.i..], "const")) {	3997	if (std.mem.startsWith(u8, p.source[p.i..], "const")) {
3964	p.i += 5;	3998	p.i += 5;
3965	break :blk_1 true;	3999	break :blk_1 true;
...	@@ -3973,7 +4007,7 @@ const Parser = struct {	...	@@ -3973,7 +4007,7 @@ const Parser = struct {
3973	pub fn parseKEYWORD_continue(p: *Parser) bool {	4007	pub fn parseKEYWORD_continue(p: *Parser) bool {
3974	return blk_0: {	4008	return blk_0: {
3975	const pos_0 = p.i;	4009	const pos_0 = p.i;
3976	if (blk_1: {	4010	if (p.parseskip() and blk_1: {
3977	if (std.mem.startsWith(u8, p.source[p.i..], "continue")) {	4011	if (std.mem.startsWith(u8, p.source[p.i..], "continue")) {
3978	p.i += 8;	4012	p.i += 8;
3979	break :blk_1 true;	4013	break :blk_1 true;
...	@@ -3987,7 +4021,7 @@ const Parser = struct {	...	@@ -3987,7 +4021,7 @@ const Parser = struct {
3987	pub fn parseKEYWORD_defer(p: *Parser) bool {	4021	pub fn parseKEYWORD_defer(p: *Parser) bool {
3988	return blk_0: {	4022	return blk_0: {
3989	const pos_0 = p.i;	4023	const pos_0 = p.i;
3990	if (blk_1: {	4024	if (p.parseskip() and blk_1: {
3991	if (std.mem.startsWith(u8, p.source[p.i..], "defer")) {	4025	if (std.mem.startsWith(u8, p.source[p.i..], "defer")) {
3992	p.i += 5;	4026	p.i += 5;
3993	break :blk_1 true;	4027	break :blk_1 true;
...	@@ -4001,7 +4035,7 @@ const Parser = struct {	...	@@ -4001,7 +4035,7 @@ const Parser = struct {
4001	pub fn parseKEYWORD_else(p: *Parser) bool {	4035	pub fn parseKEYWORD_else(p: *Parser) bool {
4002	return blk_0: {	4036	return blk_0: {
4003	const pos_0 = p.i;	4037	const pos_0 = p.i;
4004	if (blk_1: {	4038	if (p.parseskip() and blk_1: {
4005	if (std.mem.startsWith(u8, p.source[p.i..], "else")) {	4039	if (std.mem.startsWith(u8, p.source[p.i..], "else")) {
4006	p.i += 4;	4040	p.i += 4;
4007	break :blk_1 true;	4041	break :blk_1 true;
...	@@ -4015,7 +4049,7 @@ const Parser = struct {	...	@@ -4015,7 +4049,7 @@ const Parser = struct {
4015	pub fn parseKEYWORD_enum(p: *Parser) bool {	4049	pub fn parseKEYWORD_enum(p: *Parser) bool {
4016	return blk_0: {	4050	return blk_0: {
4017	const pos_0 = p.i;	4051	const pos_0 = p.i;
4018	if (blk_1: {	4052	if (p.parseskip() and blk_1: {
4019	if (std.mem.startsWith(u8, p.source[p.i..], "enum")) {	4053	if (std.mem.startsWith(u8, p.source[p.i..], "enum")) {
4020	p.i += 4;	4054	p.i += 4;
4021	break :blk_1 true;	4055	break :blk_1 true;
...	@@ -4029,7 +4063,7 @@ const Parser = struct {	...	@@ -4029,7 +4063,7 @@ const Parser = struct {
4029	pub fn parseKEYWORD_errdefer(p: *Parser) bool {	4063	pub fn parseKEYWORD_errdefer(p: *Parser) bool {
4030	return blk_0: {	4064	return blk_0: {
4031	const pos_0 = p.i;	4065	const pos_0 = p.i;
4032	if (blk_1: {	4066	if (p.parseskip() and blk_1: {
4033	if (std.mem.startsWith(u8, p.source[p.i..], "errdefer")) {	4067	if (std.mem.startsWith(u8, p.source[p.i..], "errdefer")) {
4034	p.i += 8;	4068	p.i += 8;
4035	break :blk_1 true;	4069	break :blk_1 true;
...	@@ -4043,7 +4077,7 @@ const Parser = struct {	...	@@ -4043,7 +4077,7 @@ const Parser = struct {
4043	pub fn parseKEYWORD_error(p: *Parser) bool {	4077	pub fn parseKEYWORD_error(p: *Parser) bool {
4044	return blk_0: {	4078	return blk_0: {
4045	const pos_0 = p.i;	4079	const pos_0 = p.i;
4046	if (blk_1: {	4080	if (p.parseskip() and blk_1: {
4047	if (std.mem.startsWith(u8, p.source[p.i..], "error")) {	4081	if (std.mem.startsWith(u8, p.source[p.i..], "error")) {
4048	p.i += 5;	4082	p.i += 5;
4049	break :blk_1 true;	4083	break :blk_1 true;
...	@@ -4057,7 +4091,7 @@ const Parser = struct {	...	@@ -4057,7 +4091,7 @@ const Parser = struct {
4057	pub fn parseKEYWORD_export(p: *Parser) bool {	4091	pub fn parseKEYWORD_export(p: *Parser) bool {
4058	return blk_0: {	4092	return blk_0: {
4059	const pos_0 = p.i;	4093	const pos_0 = p.i;
4060	if (blk_1: {	4094	if (p.parseskip() and blk_1: {
4061	if (std.mem.startsWith(u8, p.source[p.i..], "export")) {	4095	if (std.mem.startsWith(u8, p.source[p.i..], "export")) {
4062	p.i += 6;	4096	p.i += 6;
4063	break :blk_1 true;	4097	break :blk_1 true;
...	@@ -4071,7 +4105,7 @@ const Parser = struct {	...	@@ -4071,7 +4105,7 @@ const Parser = struct {
4071	pub fn parseKEYWORD_extern(p: *Parser) bool {	4105	pub fn parseKEYWORD_extern(p: *Parser) bool {
4072	return blk_0: {	4106	return blk_0: {
4073	const pos_0 = p.i;	4107	const pos_0 = p.i;
4074	if (blk_1: {	4108	if (p.parseskip() and blk_1: {
4075	if (std.mem.startsWith(u8, p.source[p.i..], "extern")) {	4109	if (std.mem.startsWith(u8, p.source[p.i..], "extern")) {
4076	p.i += 6;	4110	p.i += 6;
4077	break :blk_1 true;	4111	break :blk_1 true;
...	@@ -4085,7 +4119,7 @@ const Parser = struct {	...	@@ -4085,7 +4119,7 @@ const Parser = struct {
4085	pub fn parseKEYWORD_fn(p: *Parser) bool {	4119	pub fn parseKEYWORD_fn(p: *Parser) bool {
4086	return blk_0: {	4120	return blk_0: {
4087	const pos_0 = p.i;	4121	const pos_0 = p.i;
4088	if (blk_1: {	4122	if (p.parseskip() and blk_1: {
4089	if (std.mem.startsWith(u8, p.source[p.i..], "fn")) {	4123	if (std.mem.startsWith(u8, p.source[p.i..], "fn")) {
4090	p.i += 2;	4124	p.i += 2;
4091	break :blk_1 true;	4125	break :blk_1 true;
...	@@ -4099,7 +4133,7 @@ const Parser = struct {	...	@@ -4099,7 +4133,7 @@ const Parser = struct {
4099	pub fn parseKEYWORD_for(p: *Parser) bool {	4133	pub fn parseKEYWORD_for(p: *Parser) bool {
4100	return blk_0: {	4134	return blk_0: {
4101	const pos_0 = p.i;	4135	const pos_0 = p.i;
4102	if (blk_1: {	4136	if (p.parseskip() and blk_1: {
4103	if (std.mem.startsWith(u8, p.source[p.i..], "for")) {	4137	if (std.mem.startsWith(u8, p.source[p.i..], "for")) {
4104	p.i += 3;	4138	p.i += 3;
4105	break :blk_1 true;	4139	break :blk_1 true;
...	@@ -4113,7 +4147,7 @@ const Parser = struct {	...	@@ -4113,7 +4147,7 @@ const Parser = struct {
4113	pub fn parseKEYWORD_if(p: *Parser) bool {	4147	pub fn parseKEYWORD_if(p: *Parser) bool {
4114	return blk_0: {	4148	return blk_0: {
4115	const pos_0 = p.i;	4149	const pos_0 = p.i;
4116	if (blk_1: {	4150	if (p.parseskip() and blk_1: {
4117	if (std.mem.startsWith(u8, p.source[p.i..], "if")) {	4151	if (std.mem.startsWith(u8, p.source[p.i..], "if")) {
4118	p.i += 2;	4152	p.i += 2;
4119	break :blk_1 true;	4153	break :blk_1 true;
...	@@ -4127,7 +4161,7 @@ const Parser = struct {	...	@@ -4127,7 +4161,7 @@ const Parser = struct {
4127	pub fn parseKEYWORD_inline(p: *Parser) bool {	4161	pub fn parseKEYWORD_inline(p: *Parser) bool {
4128	return blk_0: {	4162	return blk_0: {
4129	const pos_0 = p.i;	4163	const pos_0 = p.i;
4130	if (blk_1: {	4164	if (p.parseskip() and blk_1: {
4131	if (std.mem.startsWith(u8, p.source[p.i..], "inline")) {	4165	if (std.mem.startsWith(u8, p.source[p.i..], "inline")) {
4132	p.i += 6;	4166	p.i += 6;
4133	break :blk_1 true;	4167	break :blk_1 true;
...	@@ -4141,7 +4175,7 @@ const Parser = struct {	...	@@ -4141,7 +4175,7 @@ const Parser = struct {
4141	pub fn parseKEYWORD_noalias(p: *Parser) bool {	4175	pub fn parseKEYWORD_noalias(p: *Parser) bool {
4142	return blk_0: {	4176	return blk_0: {
4143	const pos_0 = p.i;	4177	const pos_0 = p.i;
4144	if (blk_1: {	4178	if (p.parseskip() and blk_1: {
4145	if (std.mem.startsWith(u8, p.source[p.i..], "noalias")) {	4179	if (std.mem.startsWith(u8, p.source[p.i..], "noalias")) {
4146	p.i += 7;	4180	p.i += 7;
4147	break :blk_1 true;	4181	break :blk_1 true;
...	@@ -4155,7 +4189,7 @@ const Parser = struct {	...	@@ -4155,7 +4189,7 @@ const Parser = struct {
4155	pub fn parseKEYWORD_nosuspend(p: *Parser) bool {	4189	pub fn parseKEYWORD_nosuspend(p: *Parser) bool {
4156	return blk_0: {	4190	return blk_0: {
4157	const pos_0 = p.i;	4191	const pos_0 = p.i;
4158	if (blk_1: {	4192	if (p.parseskip() and blk_1: {
4159	if (std.mem.startsWith(u8, p.source[p.i..], "nosuspend")) {	4193	if (std.mem.startsWith(u8, p.source[p.i..], "nosuspend")) {
4160	p.i += 9;	4194	p.i += 9;
4161	break :blk_1 true;	4195	break :blk_1 true;
...	@@ -4169,7 +4203,7 @@ const Parser = struct {	...	@@ -4169,7 +4203,7 @@ const Parser = struct {
4169	pub fn parseKEYWORD_noinline(p: *Parser) bool {	4203	pub fn parseKEYWORD_noinline(p: *Parser) bool {
4170	return blk_0: {	4204	return blk_0: {
4171	const pos_0 = p.i;	4205	const pos_0 = p.i;
4172	if (blk_1: {	4206	if (p.parseskip() and blk_1: {
4173	if (std.mem.startsWith(u8, p.source[p.i..], "noinline")) {	4207	if (std.mem.startsWith(u8, p.source[p.i..], "noinline")) {
4174	p.i += 8;	4208	p.i += 8;
4175	break :blk_1 true;	4209	break :blk_1 true;
...	@@ -4183,7 +4217,7 @@ const Parser = struct {	...	@@ -4183,7 +4217,7 @@ const Parser = struct {
4183	pub fn parseKEYWORD_opaque(p: *Parser) bool {	4217	pub fn parseKEYWORD_opaque(p: *Parser) bool {
4184	return blk_0: {	4218	return blk_0: {
4185	const pos_0 = p.i;	4219	const pos_0 = p.i;
4186	if (blk_1: {	4220	if (p.parseskip() and blk_1: {
4187	if (std.mem.startsWith(u8, p.source[p.i..], "opaque")) {	4221	if (std.mem.startsWith(u8, p.source[p.i..], "opaque")) {
4188	p.i += 6;	4222	p.i += 6;
4189	break :blk_1 true;	4223	break :blk_1 true;
...	@@ -4197,7 +4231,7 @@ const Parser = struct {	...	@@ -4197,7 +4231,7 @@ const Parser = struct {
4197	pub fn parseKEYWORD_or(p: *Parser) bool {	4231	pub fn parseKEYWORD_or(p: *Parser) bool {
4198	return blk_0: {	4232	return blk_0: {
4199	const pos_0 = p.i;	4233	const pos_0 = p.i;
4200	if (blk_1: {	4234	if (p.parseskip() and blk_1: {
4201	if (std.mem.startsWith(u8, p.source[p.i..], "or")) {	4235	if (std.mem.startsWith(u8, p.source[p.i..], "or")) {
4202	p.i += 2;	4236	p.i += 2;
4203	break :blk_1 true;	4237	break :blk_1 true;
...	@@ -4211,7 +4245,7 @@ const Parser = struct {	...	@@ -4211,7 +4245,7 @@ const Parser = struct {
4211	pub fn parseKEYWORD_orelse(p: *Parser) bool {	4245	pub fn parseKEYWORD_orelse(p: *Parser) bool {
4212	return blk_0: {	4246	return blk_0: {
4213	const pos_0 = p.i;	4247	const pos_0 = p.i;
4214	if (blk_1: {	4248	if (p.parseskip() and blk_1: {
4215	if (std.mem.startsWith(u8, p.source[p.i..], "orelse")) {	4249	if (std.mem.startsWith(u8, p.source[p.i..], "orelse")) {
4216	p.i += 6;	4250	p.i += 6;
4217	break :blk_1 true;	4251	break :blk_1 true;
...	@@ -4225,7 +4259,7 @@ const Parser = struct {	...	@@ -4225,7 +4259,7 @@ const Parser = struct {
4225	pub fn parseKEYWORD_packed(p: *Parser) bool {	4259	pub fn parseKEYWORD_packed(p: *Parser) bool {
4226	return blk_0: {	4260	return blk_0: {
4227	const pos_0 = p.i;	4261	const pos_0 = p.i;
4228	if (blk_1: {	4262	if (p.parseskip() and blk_1: {
4229	if (std.mem.startsWith(u8, p.source[p.i..], "packed")) {	4263	if (std.mem.startsWith(u8, p.source[p.i..], "packed")) {
4230	p.i += 6;	4264	p.i += 6;
4231	break :blk_1 true;	4265	break :blk_1 true;
...	@@ -4239,7 +4273,7 @@ const Parser = struct {	...	@@ -4239,7 +4273,7 @@ const Parser = struct {
4239	pub fn parseKEYWORD_pub(p: *Parser) bool {	4273	pub fn parseKEYWORD_pub(p: *Parser) bool {
4240	return blk_0: {	4274	return blk_0: {
4241	const pos_0 = p.i;	4275	const pos_0 = p.i;
4242	if (blk_1: {	4276	if (p.parseskip() and blk_1: {
4243	if (std.mem.startsWith(u8, p.source[p.i..], "pub")) {	4277	if (std.mem.startsWith(u8, p.source[p.i..], "pub")) {
4244	p.i += 3;	4278	p.i += 3;
4245	break :blk_1 true;	4279	break :blk_1 true;
...	@@ -4253,7 +4287,7 @@ const Parser = struct {	...	@@ -4253,7 +4287,7 @@ const Parser = struct {
4253	pub fn parseKEYWORD_resume(p: *Parser) bool {	4287	pub fn parseKEYWORD_resume(p: *Parser) bool {
4254	return blk_0: {	4288	return blk_0: {
4255	const pos_0 = p.i;	4289	const pos_0 = p.i;
4256	if (blk_1: {	4290	if (p.parseskip() and blk_1: {
4257	if (std.mem.startsWith(u8, p.source[p.i..], "resume")) {	4291	if (std.mem.startsWith(u8, p.source[p.i..], "resume")) {
4258	p.i += 6;	4292	p.i += 6;
4259	break :blk_1 true;	4293	break :blk_1 true;
...	@@ -4267,7 +4301,7 @@ const Parser = struct {	...	@@ -4267,7 +4301,7 @@ const Parser = struct {
4267	pub fn parseKEYWORD_return(p: *Parser) bool {	4301	pub fn parseKEYWORD_return(p: *Parser) bool {
4268	return blk_0: {	4302	return blk_0: {
4269	const pos_0 = p.i;	4303	const pos_0 = p.i;
4270	if (blk_1: {	4304	if (p.parseskip() and blk_1: {
4271	if (std.mem.startsWith(u8, p.source[p.i..], "return")) {	4305	if (std.mem.startsWith(u8, p.source[p.i..], "return")) {
4272	p.i += 6;	4306	p.i += 6;
4273	break :blk_1 true;	4307	break :blk_1 true;
...	@@ -4281,7 +4315,7 @@ const Parser = struct {	...	@@ -4281,7 +4315,7 @@ const Parser = struct {
4281	pub fn parseKEYWORD_linksection(p: *Parser) bool {	4315	pub fn parseKEYWORD_linksection(p: *Parser) bool {
4282	return blk_0: {	4316	return blk_0: {
4283	const pos_0 = p.i;	4317	const pos_0 = p.i;
4284	if (blk_1: {	4318	if (p.parseskip() and blk_1: {
4285	if (std.mem.startsWith(u8, p.source[p.i..], "linksection")) {	4319	if (std.mem.startsWith(u8, p.source[p.i..], "linksection")) {
4286	p.i += 11;	4320	p.i += 11;
4287	break :blk_1 true;	4321	break :blk_1 true;
...	@@ -4295,7 +4329,7 @@ const Parser = struct {	...	@@ -4295,7 +4329,7 @@ const Parser = struct {
4295	pub fn parseKEYWORD_struct(p: *Parser) bool {	4329	pub fn parseKEYWORD_struct(p: *Parser) bool {
4296	return blk_0: {	4330	return blk_0: {
4297	const pos_0 = p.i;	4331	const pos_0 = p.i;
4298	if (blk_1: {	4332	if (p.parseskip() and blk_1: {
4299	if (std.mem.startsWith(u8, p.source[p.i..], "struct")) {	4333	if (std.mem.startsWith(u8, p.source[p.i..], "struct")) {
4300	p.i += 6;	4334	p.i += 6;
4301	break :blk_1 true;	4335	break :blk_1 true;
...	@@ -4309,7 +4343,7 @@ const Parser = struct {	...	@@ -4309,7 +4343,7 @@ const Parser = struct {
4309	pub fn parseKEYWORD_suspend(p: *Parser) bool {	4343	pub fn parseKEYWORD_suspend(p: *Parser) bool {
4310	return blk_0: {	4344	return blk_0: {
4311	const pos_0 = p.i;	4345	const pos_0 = p.i;
4312	if (blk_1: {	4346	if (p.parseskip() and blk_1: {
4313	if (std.mem.startsWith(u8, p.source[p.i..], "suspend")) {	4347	if (std.mem.startsWith(u8, p.source[p.i..], "suspend")) {
4314	p.i += 7;	4348	p.i += 7;
4315	break :blk_1 true;	4349	break :blk_1 true;
...	@@ -4323,7 +4357,7 @@ const Parser = struct {	...	@@ -4323,7 +4357,7 @@ const Parser = struct {
4323	pub fn parseKEYWORD_switch(p: *Parser) bool {	4357	pub fn parseKEYWORD_switch(p: *Parser) bool {
4324	return blk_0: {	4358	return blk_0: {
4325	const pos_0 = p.i;	4359	const pos_0 = p.i;
4326	if (blk_1: {	4360	if (p.parseskip() and blk_1: {
4327	if (std.mem.startsWith(u8, p.source[p.i..], "switch")) {	4361	if (std.mem.startsWith(u8, p.source[p.i..], "switch")) {
4328	p.i += 6;	4362	p.i += 6;
4329	break :blk_1 true;	4363	break :blk_1 true;
...	@@ -4337,7 +4371,7 @@ const Parser = struct {	...	@@ -4337,7 +4371,7 @@ const Parser = struct {
4337	pub fn parseKEYWORD_test(p: *Parser) bool {	4371	pub fn parseKEYWORD_test(p: *Parser) bool {
4338	return blk_0: {	4372	return blk_0: {
4339	const pos_0 = p.i;	4373	const pos_0 = p.i;
4340	if (blk_1: {	4374	if (p.parseskip() and blk_1: {
4341	if (std.mem.startsWith(u8, p.source[p.i..], "test")) {	4375	if (std.mem.startsWith(u8, p.source[p.i..], "test")) {
4342	p.i += 4;	4376	p.i += 4;
4343	break :blk_1 true;	4377	break :blk_1 true;
...	@@ -4351,7 +4385,7 @@ const Parser = struct {	...	@@ -4351,7 +4385,7 @@ const Parser = struct {
4351	pub fn parseKEYWORD_threadlocal(p: *Parser) bool {	4385	pub fn parseKEYWORD_threadlocal(p: *Parser) bool {
4352	return blk_0: {	4386	return blk_0: {
4353	const pos_0 = p.i;	4387	const pos_0 = p.i;
4354	if (blk_1: {	4388	if (p.parseskip() and blk_1: {
4355	if (std.mem.startsWith(u8, p.source[p.i..], "threadlocal")) {	4389	if (std.mem.startsWith(u8, p.source[p.i..], "threadlocal")) {
4356	p.i += 11;	4390	p.i += 11;
4357	break :blk_1 true;	4391	break :blk_1 true;
...	@@ -4365,7 +4399,7 @@ const Parser = struct {	...	@@ -4365,7 +4399,7 @@ const Parser = struct {
4365	pub fn parseKEYWORD_try(p: *Parser) bool {	4399	pub fn parseKEYWORD_try(p: *Parser) bool {
4366	return blk_0: {	4400	return blk_0: {
4367	const pos_0 = p.i;	4401	const pos_0 = p.i;
4368	if (blk_1: {	4402	if (p.parseskip() and blk_1: {
4369	if (std.mem.startsWith(u8, p.source[p.i..], "try")) {	4403	if (std.mem.startsWith(u8, p.source[p.i..], "try")) {
4370	p.i += 3;	4404	p.i += 3;
4371	break :blk_1 true;	4405	break :blk_1 true;
...	@@ -4379,7 +4413,7 @@ const Parser = struct {	...	@@ -4379,7 +4413,7 @@ const Parser = struct {
4379	pub fn parseKEYWORD_union(p: *Parser) bool {	4413	pub fn parseKEYWORD_union(p: *Parser) bool {
4380	return blk_0: {	4414	return blk_0: {
4381	const pos_0 = p.i;	4415	const pos_0 = p.i;
4382	if (blk_1: {	4416	if (p.parseskip() and blk_1: {
4383	if (std.mem.startsWith(u8, p.source[p.i..], "union")) {	4417	if (std.mem.startsWith(u8, p.source[p.i..], "union")) {
4384	p.i += 5;	4418	p.i += 5;
4385	break :blk_1 true;	4419	break :blk_1 true;
...	@@ -4393,7 +4427,7 @@ const Parser = struct {	...	@@ -4393,7 +4427,7 @@ const Parser = struct {
4393	pub fn parseKEYWORD_unreachable(p: *Parser) bool {	4427	pub fn parseKEYWORD_unreachable(p: *Parser) bool {
4394	return blk_0: {	4428	return blk_0: {
4395	const pos_0 = p.i;	4429	const pos_0 = p.i;
4396	if (blk_1: {	4430	if (p.parseskip() and blk_1: {
4397	if (std.mem.startsWith(u8, p.source[p.i..], "unreachable")) {	4431	if (std.mem.startsWith(u8, p.source[p.i..], "unreachable")) {
4398	p.i += 11;	4432	p.i += 11;
4399	break :blk_1 true;	4433	break :blk_1 true;
...	@@ -4407,7 +4441,7 @@ const Parser = struct {	...	@@ -4407,7 +4441,7 @@ const Parser = struct {
4407	pub fn parseKEYWORD_var(p: *Parser) bool {	4441	pub fn parseKEYWORD_var(p: *Parser) bool {
4408	return blk_0: {	4442	return blk_0: {
4409	const pos_0 = p.i;	4443	const pos_0 = p.i;
4410	if (blk_1: {	4444	if (p.parseskip() and blk_1: {
4411	if (std.mem.startsWith(u8, p.source[p.i..], "var")) {	4445	if (std.mem.startsWith(u8, p.source[p.i..], "var")) {
4412	p.i += 3;	4446	p.i += 3;
4413	break :blk_1 true;	4447	break :blk_1 true;
...	@@ -4421,7 +4455,7 @@ const Parser = struct {	...	@@ -4421,7 +4455,7 @@ const Parser = struct {
4421	pub fn parseKEYWORD_volatile(p: *Parser) bool {	4455	pub fn parseKEYWORD_volatile(p: *Parser) bool {
4422	return blk_0: {	4456	return blk_0: {
4423	const pos_0 = p.i;	4457	const pos_0 = p.i;
4424	if (blk_1: {	4458	if (p.parseskip() and blk_1: {
4425	if (std.mem.startsWith(u8, p.source[p.i..], "volatile")) {	4459	if (std.mem.startsWith(u8, p.source[p.i..], "volatile")) {
4426	p.i += 8;	4460	p.i += 8;
4427	break :blk_1 true;	4461	break :blk_1 true;
...	@@ -4435,7 +4469,7 @@ const Parser = struct {	...	@@ -4435,7 +4469,7 @@ const Parser = struct {
4435	pub fn parseKEYWORD_while(p: *Parser) bool {	4469	pub fn parseKEYWORD_while(p: *Parser) bool {
4436	return blk_0: {	4470	return blk_0: {
4437	const pos_0 = p.i;	4471	const pos_0 = p.i;
4438	if (blk_1: {	4472	if (p.parseskip() and blk_1: {
4439	if (std.mem.startsWith(u8, p.source[p.i..], "while")) {	4473	if (std.mem.startsWith(u8, p.source[p.i..], "while")) {
4440	p.i += 5;	4474	p.i += 5;
4441	break :blk_1 true;	4475	break :blk_1 true;