diff --git a/grammar.js b/grammar.js index 885b756..ce6a7b2 100644 --- a/grammar.js +++ b/grammar.js @@ -10,29 +10,30 @@ module.exports = grammar({ name: "bruno", + extras: (_) => [/\s/], + rules: { - source_file: ($) => - repeat( - field( - "tag", - choice( - $.meta, - $.http, - $.query, - $.headers, - $.auths, - $.bodies, - $.varsandassert, - $.script, - $.tests, - $.docs, - ), - ), + source_file: ($) => repeat($.section), + + section: ($) => + choice( + $.meta, + $.http, + $.query, + $.headers, + $.auth, + $.body, + $.vars, + $.assert, + $.params, + $.script, + $.tests, + $.docs, ), - meta: ($) => seq(alias("meta", $.keyword), $.dictionary), + meta: ($) => seq(alias("meta", $.keyword), $.object_block), - http: ($) => seq(alias($.http_verb, $.keyword), $.dictionary), + http: ($) => seq(alias($.http_verb, $.keyword), $.object_block), http_verb: (_) => choice( "get", @@ -46,11 +47,11 @@ module.exports = grammar({ "trace", ), - query: ($) => seq(alias("query", $.keyword), $.dictionary), + query: ($) => seq(alias("query", $.keyword), $.object_block), - headers: ($) => seq(alias("headers", $.keyword), $.dictionary), + headers: ($) => seq(alias("headers", $.keyword), $.object_block), - auths: ($) => + auth: ($) => choice( $.authawsv4, $.authbasic, @@ -58,13 +59,13 @@ module.exports = grammar({ $.authdigest, $.authoauth2, ), - authawsv4: ($) => seq(alias("auth:awsv4", $.keyword), $.dictionary), - authbasic: ($) => seq(alias("auth:basic", $.keyword), $.dictionary), - authbearer: ($) => seq(alias("auth:bearer", $.keyword), $.dictionary), - authdigest: ($) => seq(alias("auth:digest", $.keyword), $.dictionary), - authoauth2: ($) => seq(alias("auth:oauth2", $.keyword), $.dictionary), + authawsv4: ($) => seq(alias("auth:awsv4", $.keyword), $.object_block), + authbasic: ($) => seq(alias("auth:basic", $.keyword), $.object_block), + authbearer: ($) => seq(alias("auth:bearer", $.keyword), $.object_block), + authdigest: ($) => seq(alias("auth:digest", $.keyword), $.object_block), + authoauth2: ($) => seq(alias("auth:oauth2", $.keyword), $.object_block), - bodies: ($) => + body: ($) => choice( $.bodyjson, $.bodytext, @@ -72,58 +73,67 @@ module.exports = grammar({ $.bodysparql, $.bodygraphql, $.bodygraphqlvars, - $.bodyforms, - $.body, + $.bodyformurlencoded, + $.bodyformmultipart, + $.bodyraw, ), - bodyforms: ($) => choice($.bodyformurlencoded, $.bodyformmultipart), - body: ($) => seq(alias("body", $.keyword), $.textblock), - bodyjson: ($) => seq(alias("body:json", $.keyword), $.textblock), - bodytext: ($) => seq(alias("body:text", $.keyword), $.textblock), - bodyxml: ($) => seq(alias("body:xml", $.keyword), $.textblock), - bodysparql: ($) => seq(alias("body:sparql", $.keyword), $.textblock), - bodygraphql: ($) => seq(alias("body:graphql", $.keyword), $.textblock), + bodyraw: ($) => seq(alias("body", $.keyword), $.raw_block), + bodyjson: ($) => seq(alias("body:json", $.keyword), $.raw_block), + bodytext: ($) => seq(alias("body:text", $.keyword), $.raw_block), + bodyxml: ($) => seq(alias("body:xml", $.keyword), $.raw_block), + bodysparql: ($) => seq(alias("body:sparql", $.keyword), $.raw_block), + bodygraphql: ($) => seq(alias("body:graphql", $.keyword), $.raw_block), bodygraphqlvars: ($) => - seq(alias("body:graphql:vars", $.keyword), $.textblock), + seq(alias("body:graphql:vars", $.keyword), $.raw_block), bodyformurlencoded: ($) => - seq(alias("body:form-urlencoded", $.keyword), $.dictionary), + seq(alias("body:form-urlencoded", $.keyword), $.object_block), bodyformmultipart: ($) => - seq(alias("body:multipart-form", $.keyword), $.dictionary), + seq(alias("body:multipart-form", $.keyword), $.object_block), - varsandassert: ($) => - choice($.vars, $.vars_secret, $.varsreq, $.varsres, $.assert, $.params), - vars: ($) => seq(alias("vars", $.keyword), $.dictionary), - vars_secret: ($) => seq(alias("vars:secret", $.keyword), $.array), - varsreq: ($) => seq(alias("vars:pre-request", $.keyword), $.dictionary), - varsres: ($) => seq(alias("vars:post-response", $.keyword), $.dictionary), + vars: ($) => + choice($.vars_plain, $.vars_secret, $.varsreq, $.varsres), + vars_plain: ($) => seq(alias("vars", $.keyword), $.object_block), + vars_secret: ($) => seq(alias("vars:secret", $.keyword), $.array_block), + varsreq: ($) => seq(alias("vars:pre-request", $.keyword), $.object_block), + varsres: ($) => seq(alias("vars:post-response", $.keyword), $.object_block), - assert: ($) => seq(alias("assert", $.keyword), $.assert_dictionary), + assert: ($) => seq(alias("assert", $.keyword), $.assert_block), script: ($) => choice($.scriptreq, $.scriptres), - scriptreq: ($) => seq(alias("script:pre-request", $.keyword), $.textblock), + scriptreq: ($) => seq(alias("script:pre-request", $.keyword), $.raw_block), scriptres: ($) => - seq(alias("script:post-response", $.keyword), $.textblock), + seq(alias("script:post-response", $.keyword), $.raw_block), params: ($) => choice($.params_path, $.params_query), - params_query: ($) => seq(alias("params:query", $.keyword), $.dictionary), - params_path: ($) => seq(alias("params:path", $.keyword), $.dictionary), + params_query: ($) => seq(alias("params:query", $.keyword), $.object_block), + params_path: ($) => seq(alias("params:path", $.keyword), $.object_block), - tests: ($) => seq(alias("tests", $.keyword), $.textblock), + tests: ($) => seq(alias("tests", $.keyword), $.raw_block), - docs: ($) => seq(alias("docs", $.keyword), $.textblock), + docs: ($) => seq(alias("docs", $.keyword), $.raw_block), - textblock: ($) => seq("{", optional($.rawtext), "}"), + object_block: ($) => seq("{", repeat($.dictionary_pair), "}"), + dictionary_pair: ($) => seq($.key, ":", $.dictionary_value), + dictionary_value: ($) => + choice($.template_value, $.quoted_value, $.bare_value), - array: ($) => seq("[", repeat(seq($.array_value, optional(","))), "]"), - array_value: (_) => /[^\r\n\s\t\[\],]+/, + assert_block: ($) => seq("{", repeat($.assert_dictionary_pair), "}"), + assert_dictionary_pair: ($) => seq($.assert_key, ":", $.dictionary_value), - dictionary: ($) => seq("{", repeat($.dictionary_pair), "}"), - dictionary_pair: ($) => seq($.key, ":", $.value), + array_block: ($) => seq("[", repeat(seq($.array_value, optional(","))), "]"), + array_value: ($) => + choice($.template_value, $.quoted_value, $.bare_value), + + raw_block: ($) => seq("{", repeat($.raw_fragment), "}"), + raw_fragment: ($) => choice($.raw_text, $.raw_block), + raw_text: (_) => token(prec(-1, /[^{}]+/)), - assert_dictionary: ($) => seq("{", repeat($.assert_dictionary_pair), "}"), - assert_dictionary_pair: ($) => seq($.assert_key, ":", $.value), assert_key: (_) => /[^\r\n:]+/, key: (_) => /[^\s\r\n:]+/, - value: (_) => /[^\r\n]*/, + bare_value: (_) => /[^\s\r\n",\]}][^\r\n]*/, + quoted_value: (_) => token(seq('"', repeat(choice(/[^"\\]+/, /\\./)), '"')), + template_value: (_) => + token(seq("{{", repeat(choice(/[^}]+/, /}[^}]/)), "}}")), }, }); diff --git a/src/grammar.json b/src/grammar.json new file mode 100644 index 0000000..072adb9 --- /dev/null +++ b/src/grammar.json @@ -0,0 +1,1019 @@ +{ + "$schema": "https://tree-sitter.github.io/tree-sitter/assets/schemas/grammar.schema.json", + "name": "bruno", + "rules": { + "source_file": { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "section" + } + }, + "section": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "meta" + }, + { + "type": "SYMBOL", + "name": "http" + }, + { + "type": "SYMBOL", + "name": "query" + }, + { + "type": "SYMBOL", + "name": "headers" + }, + { + "type": "SYMBOL", + "name": "auth" + }, + { + "type": "SYMBOL", + "name": "body" + }, + { + "type": "SYMBOL", + "name": "vars" + }, + { + "type": "SYMBOL", + "name": "assert" + }, + { + "type": "SYMBOL", + "name": "params" + }, + { + "type": "SYMBOL", + "name": "script" + }, + { + "type": "SYMBOL", + "name": "tests" + }, + { + "type": "SYMBOL", + "name": "docs" + } + ] + }, + "meta": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "meta" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "http": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "http_verb" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "http_verb": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "get" + }, + { + "type": "STRING", + "value": "post" + }, + { + "type": "STRING", + "value": "put" + }, + { + "type": "STRING", + "value": "delete" + }, + { + "type": "STRING", + "value": "patch" + }, + { + "type": "STRING", + "value": "options" + }, + { + "type": "STRING", + "value": "head" + }, + { + "type": "STRING", + "value": "connect" + }, + { + "type": "STRING", + "value": "trace" + } + ] + }, + "query": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "query" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "headers": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "headers" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "auth": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "authawsv4" + }, + { + "type": "SYMBOL", + "name": "authbasic" + }, + { + "type": "SYMBOL", + "name": "authbearer" + }, + { + "type": "SYMBOL", + "name": "authdigest" + }, + { + "type": "SYMBOL", + "name": "authoauth2" + } + ] + }, + "authawsv4": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "auth:awsv4" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "authbasic": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "auth:basic" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "authbearer": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "auth:bearer" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "authdigest": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "auth:digest" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "authoauth2": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "auth:oauth2" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "body": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "bodyjson" + }, + { + "type": "SYMBOL", + "name": "bodytext" + }, + { + "type": "SYMBOL", + "name": "bodyxml" + }, + { + "type": "SYMBOL", + "name": "bodysparql" + }, + { + "type": "SYMBOL", + "name": "bodygraphql" + }, + { + "type": "SYMBOL", + "name": "bodygraphqlvars" + }, + { + "type": "SYMBOL", + "name": "bodyformurlencoded" + }, + { + "type": "SYMBOL", + "name": "bodyformmultipart" + }, + { + "type": "SYMBOL", + "name": "bodyraw" + } + ] + }, + "bodyraw": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "body" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "bodyjson": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "body:json" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "bodytext": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "body:text" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "bodyxml": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "body:xml" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "bodysparql": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "body:sparql" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "bodygraphql": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "body:graphql" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "bodygraphqlvars": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "body:graphql:vars" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "bodyformurlencoded": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "body:form-urlencoded" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "bodyformmultipart": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "body:multipart-form" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "vars": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "vars_plain" + }, + { + "type": "SYMBOL", + "name": "vars_secret" + }, + { + "type": "SYMBOL", + "name": "varsreq" + }, + { + "type": "SYMBOL", + "name": "varsres" + } + ] + }, + "vars_plain": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "vars" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "vars_secret": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "vars:secret" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "array_block" + } + ] + }, + "varsreq": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "vars:pre-request" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "varsres": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "vars:post-response" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "assert": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "assert" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "assert_block" + } + ] + }, + "script": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "scriptreq" + }, + { + "type": "SYMBOL", + "name": "scriptres" + } + ] + }, + "scriptreq": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "script:pre-request" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "scriptres": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "script:post-response" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "params": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "params_path" + }, + { + "type": "SYMBOL", + "name": "params_query" + } + ] + }, + "params_query": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "params:query" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "params_path": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "params:path" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "object_block" + } + ] + }, + "tests": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "tests" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "docs": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "STRING", + "value": "docs" + }, + "named": true, + "value": "keyword" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "object_block": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "dictionary_pair" + } + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "dictionary_pair": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "key" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "dictionary_value" + } + ] + }, + "dictionary_value": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "template_value" + }, + { + "type": "SYMBOL", + "name": "quoted_value" + }, + { + "type": "SYMBOL", + "name": "bare_value" + } + ] + }, + "assert_block": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "assert_dictionary_pair" + } + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "assert_dictionary_pair": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "assert_key" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "dictionary_value" + } + ] + }, + "array_block": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "array_value" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + } + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + "array_value": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "template_value" + }, + { + "type": "SYMBOL", + "name": "quoted_value" + }, + { + "type": "SYMBOL", + "name": "bare_value" + } + ] + }, + "raw_block": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "raw_fragment" + } + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "raw_fragment": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "raw_text" + }, + { + "type": "SYMBOL", + "name": "raw_block" + } + ] + }, + "raw_text": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": -1, + "content": { + "type": "PATTERN", + "value": "[^{}]+" + } + } + }, + "assert_key": { + "type": "PATTERN", + "value": "[^\\r\\n:]+" + }, + "key": { + "type": "PATTERN", + "value": "[^\\s\\r\\n:]+" + }, + "bare_value": { + "type": "PATTERN", + "value": "[^\\s\\r\\n\",\\]}][^\\r\\n]*" + }, + "quoted_value": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "\"" + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[^\"\\\\]+" + }, + { + "type": "PATTERN", + "value": "\\\\." + } + ] + } + }, + { + "type": "STRING", + "value": "\"" + } + ] + } + }, + "template_value": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{{" + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[^}]+" + }, + { + "type": "PATTERN", + "value": "}[^}]" + } + ] + } + }, + { + "type": "STRING", + "value": "}}" + } + ] + } + } + }, + "extras": [ + { + "type": "PATTERN", + "value": "\\s" + } + ], + "conflicts": [], + "precedences": [], + "externals": [], + "inline": [], + "supertypes": [], + "reserved": {} +} \ No newline at end of file diff --git a/src/node-types.json b/src/node-types.json new file mode 100644 index 0000000..dcf14ac --- /dev/null +++ b/src/node-types.json @@ -0,0 +1,1023 @@ +[ + { + "type": "array_block", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "array_value", + "named": true + } + ] + } + }, + { + "type": "array_value", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "bare_value", + "named": true + }, + { + "type": "quoted_value", + "named": true + }, + { + "type": "template_value", + "named": true + } + ] + } + }, + { + "type": "assert", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "assert_block", + "named": true + }, + { + "type": "keyword", + "named": true + } + ] + } + }, + { + "type": "assert_block", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "assert_dictionary_pair", + "named": true + } + ] + } + }, + { + "type": "assert_dictionary_pair", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "assert_key", + "named": true + }, + { + "type": "dictionary_value", + "named": true + } + ] + } + }, + { + "type": "auth", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "authawsv4", + "named": true + }, + { + "type": "authbasic", + "named": true + }, + { + "type": "authbearer", + "named": true + }, + { + "type": "authdigest", + "named": true + }, + { + "type": "authoauth2", + "named": true + } + ] + } + }, + { + "type": "authawsv4", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "authbasic", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "authbearer", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "authdigest", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "authoauth2", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "body", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "bodyformmultipart", + "named": true + }, + { + "type": "bodyformurlencoded", + "named": true + }, + { + "type": "bodygraphql", + "named": true + }, + { + "type": "bodygraphqlvars", + "named": true + }, + { + "type": "bodyjson", + "named": true + }, + { + "type": "bodyraw", + "named": true + }, + { + "type": "bodysparql", + "named": true + }, + { + "type": "bodytext", + "named": true + }, + { + "type": "bodyxml", + "named": true + } + ] + } + }, + { + "type": "bodyformmultipart", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "bodyformurlencoded", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "bodygraphql", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "bodygraphqlvars", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "bodyjson", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "bodyraw", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "bodysparql", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "bodytext", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "bodyxml", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "dictionary_pair", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "dictionary_value", + "named": true + }, + { + "type": "key", + "named": true + } + ] + } + }, + { + "type": "dictionary_value", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "bare_value", + "named": true + }, + { + "type": "quoted_value", + "named": true + }, + { + "type": "template_value", + "named": true + } + ] + } + }, + { + "type": "docs", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "headers", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "http", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "keyword", + "named": true, + "fields": {} + }, + { + "type": "meta", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "object_block", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "dictionary_pair", + "named": true + } + ] + } + }, + { + "type": "params", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "params_path", + "named": true + }, + { + "type": "params_query", + "named": true + } + ] + } + }, + { + "type": "params_path", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "params_query", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "query", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "raw_block", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "raw_fragment", + "named": true + } + ] + } + }, + { + "type": "raw_fragment", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "raw_block", + "named": true + }, + { + "type": "raw_text", + "named": true + } + ] + } + }, + { + "type": "script", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "scriptreq", + "named": true + }, + { + "type": "scriptres", + "named": true + } + ] + } + }, + { + "type": "scriptreq", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "scriptres", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "section", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "assert", + "named": true + }, + { + "type": "auth", + "named": true + }, + { + "type": "body", + "named": true + }, + { + "type": "docs", + "named": true + }, + { + "type": "headers", + "named": true + }, + { + "type": "http", + "named": true + }, + { + "type": "meta", + "named": true + }, + { + "type": "params", + "named": true + }, + { + "type": "query", + "named": true + }, + { + "type": "script", + "named": true + }, + { + "type": "tests", + "named": true + }, + { + "type": "vars", + "named": true + } + ] + } + }, + { + "type": "source_file", + "named": true, + "root": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "section", + "named": true + } + ] + } + }, + { + "type": "tests", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "raw_block", + "named": true + } + ] + } + }, + { + "type": "vars", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "vars_plain", + "named": true + }, + { + "type": "vars_secret", + "named": true + }, + { + "type": "varsreq", + "named": true + }, + { + "type": "varsres", + "named": true + } + ] + } + }, + { + "type": "vars_plain", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "vars_secret", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "array_block", + "named": true + }, + { + "type": "keyword", + "named": true + } + ] + } + }, + { + "type": "varsreq", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": "varsres", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "keyword", + "named": true + }, + { + "type": "object_block", + "named": true + } + ] + } + }, + { + "type": ",", + "named": false + }, + { + "type": ":", + "named": false + }, + { + "type": "[", + "named": false + }, + { + "type": "]", + "named": false + }, + { + "type": "assert_key", + "named": true + }, + { + "type": "bare_value", + "named": true + }, + { + "type": "connect", + "named": false + }, + { + "type": "delete", + "named": false + }, + { + "type": "get", + "named": false + }, + { + "type": "head", + "named": false + }, + { + "type": "key", + "named": true + }, + { + "type": "options", + "named": false + }, + { + "type": "patch", + "named": false + }, + { + "type": "post", + "named": false + }, + { + "type": "put", + "named": false + }, + { + "type": "quoted_value", + "named": true + }, + { + "type": "raw_text", + "named": true + }, + { + "type": "template_value", + "named": true + }, + { + "type": "trace", + "named": false + }, + { + "type": "{", + "named": false + }, + { + "type": "}", + "named": false + } +] \ No newline at end of file diff --git a/src/parser.c b/src/parser.c new file mode 100644 index 0000000..96c27c4 --- /dev/null +++ b/src/parser.c @@ -0,0 +1,4675 @@ +/* Automatically @generated by tree-sitter v0.25.10 */ + +#include "tree_sitter/parser.h" + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +#define LANGUAGE_VERSION 15 +#define STATE_COUNT 106 +#define LARGE_STATE_COUNT 4 +#define SYMBOL_COUNT 101 +#define ALIAS_COUNT 0 +#define TOKEN_COUNT 50 +#define EXTERNAL_TOKEN_COUNT 0 +#define FIELD_COUNT 0 +#define MAX_ALIAS_SEQUENCE_LENGTH 3 +#define MAX_RESERVED_WORD_SET_SIZE 0 +#define PRODUCTION_ID_COUNT 1 +#define SUPERTYPE_COUNT 0 + +enum ts_symbol_identifiers { + anon_sym_meta = 1, + anon_sym_get = 2, + anon_sym_post = 3, + anon_sym_put = 4, + anon_sym_delete = 5, + anon_sym_patch = 6, + anon_sym_options = 7, + anon_sym_head = 8, + anon_sym_connect = 9, + anon_sym_trace = 10, + anon_sym_query = 11, + anon_sym_headers = 12, + anon_sym_auth_COLONawsv4 = 13, + anon_sym_auth_COLONbasic = 14, + anon_sym_auth_COLONbearer = 15, + anon_sym_auth_COLONdigest = 16, + anon_sym_auth_COLONoauth2 = 17, + anon_sym_body = 18, + anon_sym_body_COLONjson = 19, + anon_sym_body_COLONtext = 20, + anon_sym_body_COLONxml = 21, + anon_sym_body_COLONsparql = 22, + anon_sym_body_COLONgraphql = 23, + anon_sym_body_COLONgraphql_COLONvars = 24, + anon_sym_body_COLONform_DASHurlencoded = 25, + anon_sym_body_COLONmultipart_DASHform = 26, + anon_sym_vars = 27, + anon_sym_vars_COLONsecret = 28, + anon_sym_vars_COLONpre_DASHrequest = 29, + anon_sym_vars_COLONpost_DASHresponse = 30, + anon_sym_assert = 31, + anon_sym_script_COLONpre_DASHrequest = 32, + anon_sym_script_COLONpost_DASHresponse = 33, + anon_sym_params_COLONquery = 34, + anon_sym_params_COLONpath = 35, + anon_sym_tests = 36, + anon_sym_docs = 37, + anon_sym_LBRACE = 38, + anon_sym_RBRACE = 39, + anon_sym_COLON = 40, + anon_sym_LBRACK = 41, + anon_sym_COMMA = 42, + anon_sym_RBRACK = 43, + sym_raw_text = 44, + sym_assert_key = 45, + sym_key = 46, + sym_bare_value = 47, + sym_quoted_value = 48, + sym_template_value = 49, + sym_source_file = 50, + sym_section = 51, + sym_meta = 52, + sym_http = 53, + sym_http_verb = 54, + sym_query = 55, + sym_headers = 56, + sym_auth = 57, + sym_authawsv4 = 58, + sym_authbasic = 59, + sym_authbearer = 60, + sym_authdigest = 61, + sym_authoauth2 = 62, + sym_body = 63, + sym_bodyraw = 64, + sym_bodyjson = 65, + sym_bodytext = 66, + sym_bodyxml = 67, + sym_bodysparql = 68, + sym_bodygraphql = 69, + sym_bodygraphqlvars = 70, + sym_bodyformurlencoded = 71, + sym_bodyformmultipart = 72, + sym_vars = 73, + sym_vars_plain = 74, + sym_vars_secret = 75, + sym_varsreq = 76, + sym_varsres = 77, + sym_assert = 78, + sym_script = 79, + sym_scriptreq = 80, + sym_scriptres = 81, + sym_params = 82, + sym_params_query = 83, + sym_params_path = 84, + sym_tests = 85, + sym_docs = 86, + sym_object_block = 87, + sym_dictionary_pair = 88, + sym_dictionary_value = 89, + sym_assert_block = 90, + sym_assert_dictionary_pair = 91, + sym_array_block = 92, + sym_array_value = 93, + sym_raw_block = 94, + sym_raw_fragment = 95, + aux_sym_source_file_repeat1 = 96, + aux_sym_object_block_repeat1 = 97, + aux_sym_assert_block_repeat1 = 98, + aux_sym_array_block_repeat1 = 99, + aux_sym_raw_block_repeat1 = 100, +}; + +static const char * const ts_symbol_names[] = { + [ts_builtin_sym_end] = "end", + [anon_sym_meta] = "keyword", + [anon_sym_get] = "get", + [anon_sym_post] = "post", + [anon_sym_put] = "put", + [anon_sym_delete] = "delete", + [anon_sym_patch] = "patch", + [anon_sym_options] = "options", + [anon_sym_head] = "head", + [anon_sym_connect] = "connect", + [anon_sym_trace] = "trace", + [anon_sym_query] = "keyword", + [anon_sym_headers] = "keyword", + [anon_sym_auth_COLONawsv4] = "keyword", + [anon_sym_auth_COLONbasic] = "keyword", + [anon_sym_auth_COLONbearer] = "keyword", + [anon_sym_auth_COLONdigest] = "keyword", + [anon_sym_auth_COLONoauth2] = "keyword", + [anon_sym_body] = "keyword", + [anon_sym_body_COLONjson] = "keyword", + [anon_sym_body_COLONtext] = "keyword", + [anon_sym_body_COLONxml] = "keyword", + [anon_sym_body_COLONsparql] = "keyword", + [anon_sym_body_COLONgraphql] = "keyword", + [anon_sym_body_COLONgraphql_COLONvars] = "keyword", + [anon_sym_body_COLONform_DASHurlencoded] = "keyword", + [anon_sym_body_COLONmultipart_DASHform] = "keyword", + [anon_sym_vars] = "keyword", + [anon_sym_vars_COLONsecret] = "keyword", + [anon_sym_vars_COLONpre_DASHrequest] = "keyword", + [anon_sym_vars_COLONpost_DASHresponse] = "keyword", + [anon_sym_assert] = "keyword", + [anon_sym_script_COLONpre_DASHrequest] = "keyword", + [anon_sym_script_COLONpost_DASHresponse] = "keyword", + [anon_sym_params_COLONquery] = "keyword", + [anon_sym_params_COLONpath] = "keyword", + [anon_sym_tests] = "keyword", + [anon_sym_docs] = "keyword", + [anon_sym_LBRACE] = "{", + [anon_sym_RBRACE] = "}", + [anon_sym_COLON] = ":", + [anon_sym_LBRACK] = "[", + [anon_sym_COMMA] = ",", + [anon_sym_RBRACK] = "]", + [sym_raw_text] = "raw_text", + [sym_assert_key] = "assert_key", + [sym_key] = "key", + [sym_bare_value] = "bare_value", + [sym_quoted_value] = "quoted_value", + [sym_template_value] = "template_value", + [sym_source_file] = "source_file", + [sym_section] = "section", + [sym_meta] = "meta", + [sym_http] = "http", + [sym_http_verb] = "keyword", + [sym_query] = "query", + [sym_headers] = "headers", + [sym_auth] = "auth", + [sym_authawsv4] = "authawsv4", + [sym_authbasic] = "authbasic", + [sym_authbearer] = "authbearer", + [sym_authdigest] = "authdigest", + [sym_authoauth2] = "authoauth2", + [sym_body] = "body", + [sym_bodyraw] = "bodyraw", + [sym_bodyjson] = "bodyjson", + [sym_bodytext] = "bodytext", + [sym_bodyxml] = "bodyxml", + [sym_bodysparql] = "bodysparql", + [sym_bodygraphql] = "bodygraphql", + [sym_bodygraphqlvars] = "bodygraphqlvars", + [sym_bodyformurlencoded] = "bodyformurlencoded", + [sym_bodyformmultipart] = "bodyformmultipart", + [sym_vars] = "vars", + [sym_vars_plain] = "vars_plain", + [sym_vars_secret] = "vars_secret", + [sym_varsreq] = "varsreq", + [sym_varsres] = "varsres", + [sym_assert] = "assert", + [sym_script] = "script", + [sym_scriptreq] = "scriptreq", + [sym_scriptres] = "scriptres", + [sym_params] = "params", + [sym_params_query] = "params_query", + [sym_params_path] = "params_path", + [sym_tests] = "tests", + [sym_docs] = "docs", + [sym_object_block] = "object_block", + [sym_dictionary_pair] = "dictionary_pair", + [sym_dictionary_value] = "dictionary_value", + [sym_assert_block] = "assert_block", + [sym_assert_dictionary_pair] = "assert_dictionary_pair", + [sym_array_block] = "array_block", + [sym_array_value] = "array_value", + [sym_raw_block] = "raw_block", + [sym_raw_fragment] = "raw_fragment", + [aux_sym_source_file_repeat1] = "source_file_repeat1", + [aux_sym_object_block_repeat1] = "object_block_repeat1", + [aux_sym_assert_block_repeat1] = "assert_block_repeat1", + [aux_sym_array_block_repeat1] = "array_block_repeat1", + [aux_sym_raw_block_repeat1] = "raw_block_repeat1", +}; + +static const TSSymbol ts_symbol_map[] = { + [ts_builtin_sym_end] = ts_builtin_sym_end, + [anon_sym_meta] = anon_sym_meta, + [anon_sym_get] = anon_sym_get, + [anon_sym_post] = anon_sym_post, + [anon_sym_put] = anon_sym_put, + [anon_sym_delete] = anon_sym_delete, + [anon_sym_patch] = anon_sym_patch, + [anon_sym_options] = anon_sym_options, + [anon_sym_head] = anon_sym_head, + [anon_sym_connect] = anon_sym_connect, + [anon_sym_trace] = anon_sym_trace, + [anon_sym_query] = anon_sym_meta, + [anon_sym_headers] = anon_sym_meta, + [anon_sym_auth_COLONawsv4] = anon_sym_meta, + [anon_sym_auth_COLONbasic] = anon_sym_meta, + [anon_sym_auth_COLONbearer] = anon_sym_meta, + [anon_sym_auth_COLONdigest] = anon_sym_meta, + [anon_sym_auth_COLONoauth2] = anon_sym_meta, + [anon_sym_body] = anon_sym_meta, + [anon_sym_body_COLONjson] = anon_sym_meta, + [anon_sym_body_COLONtext] = anon_sym_meta, + [anon_sym_body_COLONxml] = anon_sym_meta, + [anon_sym_body_COLONsparql] = anon_sym_meta, + [anon_sym_body_COLONgraphql] = anon_sym_meta, + [anon_sym_body_COLONgraphql_COLONvars] = anon_sym_meta, + [anon_sym_body_COLONform_DASHurlencoded] = anon_sym_meta, + [anon_sym_body_COLONmultipart_DASHform] = anon_sym_meta, + [anon_sym_vars] = anon_sym_meta, + [anon_sym_vars_COLONsecret] = anon_sym_meta, + [anon_sym_vars_COLONpre_DASHrequest] = anon_sym_meta, + [anon_sym_vars_COLONpost_DASHresponse] = anon_sym_meta, + [anon_sym_assert] = anon_sym_meta, + [anon_sym_script_COLONpre_DASHrequest] = anon_sym_meta, + [anon_sym_script_COLONpost_DASHresponse] = anon_sym_meta, + [anon_sym_params_COLONquery] = anon_sym_meta, + [anon_sym_params_COLONpath] = anon_sym_meta, + [anon_sym_tests] = anon_sym_meta, + [anon_sym_docs] = anon_sym_meta, + [anon_sym_LBRACE] = anon_sym_LBRACE, + [anon_sym_RBRACE] = anon_sym_RBRACE, + [anon_sym_COLON] = anon_sym_COLON, + [anon_sym_LBRACK] = anon_sym_LBRACK, + [anon_sym_COMMA] = anon_sym_COMMA, + [anon_sym_RBRACK] = anon_sym_RBRACK, + [sym_raw_text] = sym_raw_text, + [sym_assert_key] = sym_assert_key, + [sym_key] = sym_key, + [sym_bare_value] = sym_bare_value, + [sym_quoted_value] = sym_quoted_value, + [sym_template_value] = sym_template_value, + [sym_source_file] = sym_source_file, + [sym_section] = sym_section, + [sym_meta] = sym_meta, + [sym_http] = sym_http, + [sym_http_verb] = anon_sym_meta, + [sym_query] = sym_query, + [sym_headers] = sym_headers, + [sym_auth] = sym_auth, + [sym_authawsv4] = sym_authawsv4, + [sym_authbasic] = sym_authbasic, + [sym_authbearer] = sym_authbearer, + [sym_authdigest] = sym_authdigest, + [sym_authoauth2] = sym_authoauth2, + [sym_body] = sym_body, + [sym_bodyraw] = sym_bodyraw, + [sym_bodyjson] = sym_bodyjson, + [sym_bodytext] = sym_bodytext, + [sym_bodyxml] = sym_bodyxml, + [sym_bodysparql] = sym_bodysparql, + [sym_bodygraphql] = sym_bodygraphql, + [sym_bodygraphqlvars] = sym_bodygraphqlvars, + [sym_bodyformurlencoded] = sym_bodyformurlencoded, + [sym_bodyformmultipart] = sym_bodyformmultipart, + [sym_vars] = sym_vars, + [sym_vars_plain] = sym_vars_plain, + [sym_vars_secret] = sym_vars_secret, + [sym_varsreq] = sym_varsreq, + [sym_varsres] = sym_varsres, + [sym_assert] = sym_assert, + [sym_script] = sym_script, + [sym_scriptreq] = sym_scriptreq, + [sym_scriptres] = sym_scriptres, + [sym_params] = sym_params, + [sym_params_query] = sym_params_query, + [sym_params_path] = sym_params_path, + [sym_tests] = sym_tests, + [sym_docs] = sym_docs, + [sym_object_block] = sym_object_block, + [sym_dictionary_pair] = sym_dictionary_pair, + [sym_dictionary_value] = sym_dictionary_value, + [sym_assert_block] = sym_assert_block, + [sym_assert_dictionary_pair] = sym_assert_dictionary_pair, + [sym_array_block] = sym_array_block, + [sym_array_value] = sym_array_value, + [sym_raw_block] = sym_raw_block, + [sym_raw_fragment] = sym_raw_fragment, + [aux_sym_source_file_repeat1] = aux_sym_source_file_repeat1, + [aux_sym_object_block_repeat1] = aux_sym_object_block_repeat1, + [aux_sym_assert_block_repeat1] = aux_sym_assert_block_repeat1, + [aux_sym_array_block_repeat1] = aux_sym_array_block_repeat1, + [aux_sym_raw_block_repeat1] = aux_sym_raw_block_repeat1, +}; + +static const TSSymbolMetadata ts_symbol_metadata[] = { + [ts_builtin_sym_end] = { + .visible = false, + .named = true, + }, + [anon_sym_meta] = { + .visible = true, + .named = true, + }, + [anon_sym_get] = { + .visible = true, + .named = false, + }, + [anon_sym_post] = { + .visible = true, + .named = false, + }, + [anon_sym_put] = { + .visible = true, + .named = false, + }, + [anon_sym_delete] = { + .visible = true, + .named = false, + }, + [anon_sym_patch] = { + .visible = true, + .named = false, + }, + [anon_sym_options] = { + .visible = true, + .named = false, + }, + [anon_sym_head] = { + .visible = true, + .named = false, + }, + [anon_sym_connect] = { + .visible = true, + .named = false, + }, + [anon_sym_trace] = { + .visible = true, + .named = false, + }, + [anon_sym_query] = { + .visible = true, + .named = true, + }, + [anon_sym_headers] = { + .visible = true, + .named = true, + }, + [anon_sym_auth_COLONawsv4] = { + .visible = true, + .named = true, + }, + [anon_sym_auth_COLONbasic] = { + .visible = true, + .named = true, + }, + [anon_sym_auth_COLONbearer] = { + .visible = true, + .named = true, + }, + [anon_sym_auth_COLONdigest] = { + .visible = true, + .named = true, + }, + [anon_sym_auth_COLONoauth2] = { + .visible = true, + .named = true, + }, + [anon_sym_body] = { + .visible = true, + .named = true, + }, + [anon_sym_body_COLONjson] = { + .visible = true, + .named = true, + }, + [anon_sym_body_COLONtext] = { + .visible = true, + .named = true, + }, + [anon_sym_body_COLONxml] = { + .visible = true, + .named = true, + }, + [anon_sym_body_COLONsparql] = { + .visible = true, + .named = true, + }, + [anon_sym_body_COLONgraphql] = { + .visible = true, + .named = true, + }, + [anon_sym_body_COLONgraphql_COLONvars] = { + .visible = true, + .named = true, + }, + [anon_sym_body_COLONform_DASHurlencoded] = { + .visible = true, + .named = true, + }, + [anon_sym_body_COLONmultipart_DASHform] = { + .visible = true, + .named = true, + }, + [anon_sym_vars] = { + .visible = true, + .named = true, + }, + [anon_sym_vars_COLONsecret] = { + .visible = true, + .named = true, + }, + [anon_sym_vars_COLONpre_DASHrequest] = { + .visible = true, + .named = true, + }, + [anon_sym_vars_COLONpost_DASHresponse] = { + .visible = true, + .named = true, + }, + [anon_sym_assert] = { + .visible = true, + .named = true, + }, + [anon_sym_script_COLONpre_DASHrequest] = { + .visible = true, + .named = true, + }, + [anon_sym_script_COLONpost_DASHresponse] = { + .visible = true, + .named = true, + }, + [anon_sym_params_COLONquery] = { + .visible = true, + .named = true, + }, + [anon_sym_params_COLONpath] = { + .visible = true, + .named = true, + }, + [anon_sym_tests] = { + .visible = true, + .named = true, + }, + [anon_sym_docs] = { + .visible = true, + .named = true, + }, + [anon_sym_LBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_COMMA] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACK] = { + .visible = true, + .named = false, + }, + [sym_raw_text] = { + .visible = true, + .named = true, + }, + [sym_assert_key] = { + .visible = true, + .named = true, + }, + [sym_key] = { + .visible = true, + .named = true, + }, + [sym_bare_value] = { + .visible = true, + .named = true, + }, + [sym_quoted_value] = { + .visible = true, + .named = true, + }, + [sym_template_value] = { + .visible = true, + .named = true, + }, + [sym_source_file] = { + .visible = true, + .named = true, + }, + [sym_section] = { + .visible = true, + .named = true, + }, + [sym_meta] = { + .visible = true, + .named = true, + }, + [sym_http] = { + .visible = true, + .named = true, + }, + [sym_http_verb] = { + .visible = true, + .named = true, + }, + [sym_query] = { + .visible = true, + .named = true, + }, + [sym_headers] = { + .visible = true, + .named = true, + }, + [sym_auth] = { + .visible = true, + .named = true, + }, + [sym_authawsv4] = { + .visible = true, + .named = true, + }, + [sym_authbasic] = { + .visible = true, + .named = true, + }, + [sym_authbearer] = { + .visible = true, + .named = true, + }, + [sym_authdigest] = { + .visible = true, + .named = true, + }, + [sym_authoauth2] = { + .visible = true, + .named = true, + }, + [sym_body] = { + .visible = true, + .named = true, + }, + [sym_bodyraw] = { + .visible = true, + .named = true, + }, + [sym_bodyjson] = { + .visible = true, + .named = true, + }, + [sym_bodytext] = { + .visible = true, + .named = true, + }, + [sym_bodyxml] = { + .visible = true, + .named = true, + }, + [sym_bodysparql] = { + .visible = true, + .named = true, + }, + [sym_bodygraphql] = { + .visible = true, + .named = true, + }, + [sym_bodygraphqlvars] = { + .visible = true, + .named = true, + }, + [sym_bodyformurlencoded] = { + .visible = true, + .named = true, + }, + [sym_bodyformmultipart] = { + .visible = true, + .named = true, + }, + [sym_vars] = { + .visible = true, + .named = true, + }, + [sym_vars_plain] = { + .visible = true, + .named = true, + }, + [sym_vars_secret] = { + .visible = true, + .named = true, + }, + [sym_varsreq] = { + .visible = true, + .named = true, + }, + [sym_varsres] = { + .visible = true, + .named = true, + }, + [sym_assert] = { + .visible = true, + .named = true, + }, + [sym_script] = { + .visible = true, + .named = true, + }, + [sym_scriptreq] = { + .visible = true, + .named = true, + }, + [sym_scriptres] = { + .visible = true, + .named = true, + }, + [sym_params] = { + .visible = true, + .named = true, + }, + [sym_params_query] = { + .visible = true, + .named = true, + }, + [sym_params_path] = { + .visible = true, + .named = true, + }, + [sym_tests] = { + .visible = true, + .named = true, + }, + [sym_docs] = { + .visible = true, + .named = true, + }, + [sym_object_block] = { + .visible = true, + .named = true, + }, + [sym_dictionary_pair] = { + .visible = true, + .named = true, + }, + [sym_dictionary_value] = { + .visible = true, + .named = true, + }, + [sym_assert_block] = { + .visible = true, + .named = true, + }, + [sym_assert_dictionary_pair] = { + .visible = true, + .named = true, + }, + [sym_array_block] = { + .visible = true, + .named = true, + }, + [sym_array_value] = { + .visible = true, + .named = true, + }, + [sym_raw_block] = { + .visible = true, + .named = true, + }, + [sym_raw_fragment] = { + .visible = true, + .named = true, + }, + [aux_sym_source_file_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_object_block_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_assert_block_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_array_block_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_raw_block_repeat1] = { + .visible = false, + .named = false, + }, +}; + +static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { + [0] = {0}, +}; + +static const uint16_t ts_non_terminal_alias_map[] = { + 0, +}; + +static const TSStateId ts_primary_state_ids[STATE_COUNT] = { + [0] = 0, + [1] = 1, + [2] = 2, + [3] = 3, + [4] = 4, + [5] = 5, + [6] = 6, + [7] = 7, + [8] = 8, + [9] = 9, + [10] = 10, + [11] = 11, + [12] = 12, + [13] = 13, + [14] = 14, + [15] = 15, + [16] = 16, + [17] = 17, + [18] = 18, + [19] = 19, + [20] = 20, + [21] = 21, + [22] = 22, + [23] = 23, + [24] = 24, + [25] = 25, + [26] = 26, + [27] = 27, + [28] = 28, + [29] = 29, + [30] = 30, + [31] = 31, + [32] = 32, + [33] = 33, + [34] = 34, + [35] = 35, + [36] = 36, + [37] = 37, + [38] = 38, + [39] = 39, + [40] = 40, + [41] = 41, + [42] = 42, + [43] = 43, + [44] = 44, + [45] = 45, + [46] = 46, + [47] = 47, + [48] = 48, + [49] = 49, + [50] = 50, + [51] = 49, + [52] = 52, + [53] = 53, + [54] = 48, + [55] = 55, + [56] = 56, + [57] = 57, + [58] = 58, + [59] = 59, + [60] = 60, + [61] = 61, + [62] = 62, + [63] = 63, + [64] = 64, + [65] = 65, + [66] = 4, + [67] = 67, + [68] = 38, + [69] = 69, + [70] = 70, + [71] = 71, + [72] = 72, + [73] = 73, + [74] = 74, + [75] = 75, + [76] = 76, + [77] = 77, + [78] = 78, + [79] = 79, + [80] = 80, + [81] = 81, + [82] = 82, + [83] = 83, + [84] = 84, + [85] = 85, + [86] = 86, + [87] = 87, + [88] = 88, + [89] = 89, + [90] = 90, + [91] = 91, + [92] = 92, + [93] = 93, + [94] = 94, + [95] = 95, + [96] = 96, + [97] = 97, + [98] = 93, + [99] = 99, + [100] = 100, + [101] = 101, + [102] = 102, + [103] = 103, + [104] = 104, + [105] = 105, +}; + +static bool ts_lex(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(211); + ADVANCE_MAP( + '"', 2, + ',', 255, + ':', 253, + '[', 254, + ']', 256, + 'a', 146, + 'b', 100, + 'c', 101, + 'd', 41, + 'g', 49, + 'h', 48, + 'm', 51, + 'o', 112, + 'p', 14, + 'q', 192, + 's', 29, + 't', 63, + 'v', 19, + '{', 249, + '}', 250, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(0); + END_STATE(); + case 1: + if (lookahead == '"') ADVANCE(2); + if (lookahead == ',') ADVANCE(255); + if (lookahead == ']') ADVANCE(256); + if (lookahead == '{') ADVANCE(262); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(1); + if (lookahead != 0 && + lookahead != '}') ADVANCE(265); + END_STATE(); + case 2: + if (lookahead == '"') ADVANCE(266); + if (lookahead == '\\') ADVANCE(210); + if (lookahead != 0) ADVANCE(2); + END_STATE(); + case 3: + if (lookahead == '-') ADVANCE(71); + END_STATE(); + case 4: + if (lookahead == '-') ADVANCE(193); + END_STATE(); + case 5: + if (lookahead == '-') ADVANCE(138); + END_STATE(); + case 6: + if (lookahead == '-') ADVANCE(139); + END_STATE(); + case 7: + if (lookahead == '-') ADVANCE(145); + END_STATE(); + case 8: + if (lookahead == '-') ADVANCE(144); + END_STATE(); + case 9: + if (lookahead == '2') ADVANCE(228); + END_STATE(); + case 10: + if (lookahead == '4') ADVANCE(224); + END_STATE(); + case 11: + if (lookahead == ':') ADVANCE(17); + END_STATE(); + case 12: + if (lookahead == ':') ADVANCE(114); + END_STATE(); + case 13: + if (lookahead == ':') ADVANCE(120); + END_STATE(); + case 14: + if (lookahead == 'a') ADVANCE(133); + if (lookahead == 'o') ADVANCE(157); + if (lookahead == 'u') ADVANCE(172); + END_STATE(); + case 15: + if (lookahead == 'a') ADVANCE(212); + END_STATE(); + case 16: + if (lookahead == 'a') ADVANCE(92); + END_STATE(); + case 17: + if (lookahead == 'a') ADVANCE(200); + if (lookahead == 'b') ADVANCE(25); + if (lookahead == 'd') ADVANCE(78); + if (lookahead == 'o') ADVANCE(20); + END_STATE(); + case 18: + if (lookahead == 'a') ADVANCE(38); + END_STATE(); + case 19: + if (lookahead == 'a') ADVANCE(131); + END_STATE(); + case 20: + if (lookahead == 'a') ADVANCE(194); + END_STATE(); + case 21: + if (lookahead == 'a') ADVANCE(113); + END_STATE(); + case 22: + if (lookahead == 'a') ADVANCE(33); + END_STATE(); + case 23: + if (lookahead == 'a') ADVANCE(142); + END_STATE(); + case 24: + if (lookahead == 'a') ADVANCE(125); + END_STATE(); + case 25: + if (lookahead == 'a') ADVANCE(155); + if (lookahead == 'e') ADVANCE(23); + END_STATE(); + case 26: + if (lookahead == 'a') ADVANCE(141); + END_STATE(); + case 27: + if (lookahead == 'a') ADVANCE(186); + END_STATE(); + case 28: + if (lookahead == 'a') ADVANCE(140); + END_STATE(); + case 29: + if (lookahead == 'c') ADVANCE(128); + END_STATE(); + case 30: + if (lookahead == 'c') ADVANCE(225); + END_STATE(); + case 31: + if (lookahead == 'c') ADVANCE(74); + END_STATE(); + case 32: + if (lookahead == 'c') ADVANCE(147); + END_STATE(); + case 33: + if (lookahead == 'c') ADVANCE(42); + END_STATE(); + case 34: + if (lookahead == 'c') ADVANCE(143); + END_STATE(); + case 35: + if (lookahead == 'c') ADVANCE(175); + END_STATE(); + case 36: + if (lookahead == 'c') ADVANCE(102); + END_STATE(); + case 37: + if (lookahead == 'd') ADVANCE(202); + END_STATE(); + case 38: + if (lookahead == 'd') ADVANCE(219); + END_STATE(); + case 39: + if (lookahead == 'd') ADVANCE(236); + END_STATE(); + case 40: + if (lookahead == 'd') ADVANCE(53); + END_STATE(); + case 41: + if (lookahead == 'e') ADVANCE(88); + if (lookahead == 'o') ADVANCE(32); + END_STATE(); + case 42: + if (lookahead == 'e') ADVANCE(221); + END_STATE(); + case 43: + if (lookahead == 'e') ADVANCE(216); + END_STATE(); + case 44: + if (lookahead == 'e') ADVANCE(201); + END_STATE(); + case 45: + if (lookahead == 'e') ADVANCE(5); + END_STATE(); + case 46: + if (lookahead == 'e') ADVANCE(241); + END_STATE(); + case 47: + if (lookahead == 'e') ADVANCE(244); + END_STATE(); + case 48: + if (lookahead == 'e') ADVANCE(18); + END_STATE(); + case 49: + if (lookahead == 'e') ADVANCE(170); + END_STATE(); + case 50: + if (lookahead == 'e') ADVANCE(123); + END_STATE(); + case 51: + if (lookahead == 'e') ADVANCE(184); + END_STATE(); + case 52: + if (lookahead == 'e') ADVANCE(127); + END_STATE(); + case 53: + if (lookahead == 'e') ADVANCE(39); + END_STATE(); + case 54: + if (lookahead == 'e') ADVANCE(137); + END_STATE(); + case 55: + if (lookahead == 'e') ADVANCE(35); + END_STATE(); + case 56: + if (lookahead == 'e') ADVANCE(96); + END_STATE(); + case 57: + if (lookahead == 'e') ADVANCE(188); + END_STATE(); + case 58: + if (lookahead == 'e') ADVANCE(126); + END_STATE(); + case 59: + if (lookahead == 'e') ADVANCE(156); + END_STATE(); + case 60: + if (lookahead == 'e') ADVANCE(129); + END_STATE(); + case 61: + if (lookahead == 'e') ADVANCE(178); + END_STATE(); + case 62: + if (lookahead == 'e') ADVANCE(34); + END_STATE(); + case 63: + if (lookahead == 'e') ADVANCE(158); + if (lookahead == 'r') ADVANCE(22); + END_STATE(); + case 64: + if (lookahead == 'e') ADVANCE(161); + END_STATE(); + case 65: + if (lookahead == 'e') ADVANCE(163); + END_STATE(); + case 66: + if (lookahead == 'e') ADVANCE(164); + END_STATE(); + case 67: + if (lookahead == 'e') ADVANCE(167); + END_STATE(); + case 68: + if (lookahead == 'e') ADVANCE(124); + END_STATE(); + case 69: + if (lookahead == 'e') ADVANCE(8); + END_STATE(); + case 70: + if (lookahead == 'f') ADVANCE(106); + if (lookahead == 'g') ADVANCE(135); + if (lookahead == 'j') ADVANCE(165); + if (lookahead == 'm') ADVANCE(191); + if (lookahead == 's') ADVANCE(116); + if (lookahead == 't') ADVANCE(44); + if (lookahead == 'x') ADVANCE(91); + END_STATE(); + case 71: + if (lookahead == 'f') ADVANCE(107); + END_STATE(); + case 72: + if (lookahead == 'g') ADVANCE(64); + END_STATE(); + case 73: + if (lookahead == 'h') ADVANCE(11); + END_STATE(); + case 74: + if (lookahead == 'h') ADVANCE(217); + END_STATE(); + case 75: + if (lookahead == 'h') ADVANCE(9); + END_STATE(); + case 76: + if (lookahead == 'h') ADVANCE(246); + END_STATE(); + case 77: + if (lookahead == 'h') ADVANCE(122); + END_STATE(); + case 78: + if (lookahead == 'i') ADVANCE(72); + END_STATE(); + case 79: + if (lookahead == 'i') ADVANCE(103); + END_STATE(); + case 80: + if (lookahead == 'i') ADVANCE(30); + END_STATE(); + case 81: + if (lookahead == 'i') ADVANCE(115); + END_STATE(); + case 82: + if (lookahead == 'i') ADVANCE(118); + END_STATE(); + case 83: + if (lookahead == 'l') ADVANCE(232); + END_STATE(); + case 84: + if (lookahead == 'l') ADVANCE(233); + END_STATE(); + case 85: + if (lookahead == 'l') ADVANCE(234); + END_STATE(); + case 86: + if (lookahead == 'l') ADVANCE(187); + END_STATE(); + case 87: + if (lookahead == 'l') ADVANCE(56); + END_STATE(); + case 88: + if (lookahead == 'l') ADVANCE(57); + END_STATE(); + case 89: + if (lookahead == 'm') ADVANCE(237); + END_STATE(); + case 90: + if (lookahead == 'm') ADVANCE(4); + END_STATE(); + case 91: + if (lookahead == 'm') ADVANCE(83); + END_STATE(); + case 92: + if (lookahead == 'm') ADVANCE(154); + END_STATE(); + case 93: + if (lookahead == 'n') ADVANCE(230); + END_STATE(); + case 94: + if (lookahead == 'n') ADVANCE(95); + END_STATE(); + case 95: + if (lookahead == 'n') ADVANCE(55); + END_STATE(); + case 96: + if (lookahead == 'n') ADVANCE(36); + END_STATE(); + case 97: + if (lookahead == 'n') ADVANCE(151); + END_STATE(); + case 98: + if (lookahead == 'n') ADVANCE(159); + END_STATE(); + case 99: + if (lookahead == 'n') ADVANCE(162); + END_STATE(); + case 100: + if (lookahead == 'o') ADVANCE(37); + END_STATE(); + case 101: + if (lookahead == 'o') ADVANCE(94); + END_STATE(); + case 102: + if (lookahead == 'o') ADVANCE(40); + END_STATE(); + case 103: + if (lookahead == 'o') ADVANCE(97); + END_STATE(); + case 104: + if (lookahead == 'o') ADVANCE(93); + END_STATE(); + case 105: + if (lookahead == 'o') ADVANCE(98); + END_STATE(); + case 106: + if (lookahead == 'o') ADVANCE(130); + END_STATE(); + case 107: + if (lookahead == 'o') ADVANCE(132); + END_STATE(); + case 108: + if (lookahead == 'o') ADVANCE(160); + if (lookahead == 'r') ADVANCE(45); + END_STATE(); + case 109: + if (lookahead == 'o') ADVANCE(99); + END_STATE(); + case 110: + if (lookahead == 'o') ADVANCE(168); + if (lookahead == 'r') ADVANCE(69); + END_STATE(); + case 111: + if (lookahead == 'p') ADVANCE(108); + if (lookahead == 's') ADVANCE(62); + END_STATE(); + case 112: + if (lookahead == 'p') ADVANCE(171); + END_STATE(); + case 113: + if (lookahead == 'p') ADVANCE(77); + END_STATE(); + case 114: + if (lookahead == 'p') ADVANCE(27); + if (lookahead == 'q') ADVANCE(195); + END_STATE(); + case 115: + if (lookahead == 'p') ADVANCE(182); + END_STATE(); + case 116: + if (lookahead == 'p') ADVANCE(24); + END_STATE(); + case 117: + if (lookahead == 'p') ADVANCE(105); + END_STATE(); + case 118: + if (lookahead == 'p') ADVANCE(26); + END_STATE(); + case 119: + if (lookahead == 'p') ADVANCE(109); + END_STATE(); + case 120: + if (lookahead == 'p') ADVANCE(110); + END_STATE(); + case 121: + if (lookahead == 'q') ADVANCE(84); + END_STATE(); + case 122: + if (lookahead == 'q') ADVANCE(85); + END_STATE(); + case 123: + if (lookahead == 'q') ADVANCE(196); + END_STATE(); + case 124: + if (lookahead == 'q') ADVANCE(197); + END_STATE(); + case 125: + if (lookahead == 'r') ADVANCE(121); + END_STATE(); + case 126: + if (lookahead == 'r') ADVANCE(226); + END_STATE(); + case 127: + if (lookahead == 'r') ADVANCE(203); + END_STATE(); + case 128: + if (lookahead == 'r') ADVANCE(81); + END_STATE(); + case 129: + if (lookahead == 'r') ADVANCE(204); + END_STATE(); + case 130: + if (lookahead == 'r') ADVANCE(90); + END_STATE(); + case 131: + if (lookahead == 'r') ADVANCE(148); + END_STATE(); + case 132: + if (lookahead == 'r') ADVANCE(89); + END_STATE(); + case 133: + if (lookahead == 'r') ADVANCE(16); + if (lookahead == 't') ADVANCE(31); + END_STATE(); + case 134: + if (lookahead == 'r') ADVANCE(87); + END_STATE(); + case 135: + if (lookahead == 'r') ADVANCE(21); + END_STATE(); + case 136: + if (lookahead == 'r') ADVANCE(150); + END_STATE(); + case 137: + if (lookahead == 'r') ADVANCE(174); + END_STATE(); + case 138: + if (lookahead == 'r') ADVANCE(50); + END_STATE(); + case 139: + if (lookahead == 'r') ADVANCE(59); + END_STATE(); + case 140: + if (lookahead == 'r') ADVANCE(153); + END_STATE(); + case 141: + if (lookahead == 'r') ADVANCE(183); + END_STATE(); + case 142: + if (lookahead == 'r') ADVANCE(58); + END_STATE(); + case 143: + if (lookahead == 'r') ADVANCE(61); + END_STATE(); + case 144: + if (lookahead == 'r') ADVANCE(68); + END_STATE(); + case 145: + if (lookahead == 'r') ADVANCE(67); + END_STATE(); + case 146: + if (lookahead == 's') ADVANCE(166); + if (lookahead == 'u') ADVANCE(169); + END_STATE(); + case 147: + if (lookahead == 's') ADVANCE(248); + END_STATE(); + case 148: + if (lookahead == 's') ADVANCE(238); + END_STATE(); + case 149: + if (lookahead == 's') ADVANCE(247); + END_STATE(); + case 150: + if (lookahead == 's') ADVANCE(223); + END_STATE(); + case 151: + if (lookahead == 's') ADVANCE(218); + END_STATE(); + case 152: + if (lookahead == 's') ADVANCE(198); + END_STATE(); + case 153: + if (lookahead == 's') ADVANCE(235); + END_STATE(); + case 154: + if (lookahead == 's') ADVANCE(12); + END_STATE(); + case 155: + if (lookahead == 's') ADVANCE(80); + END_STATE(); + case 156: + if (lookahead == 's') ADVANCE(117); + END_STATE(); + case 157: + if (lookahead == 's') ADVANCE(173); + END_STATE(); + case 158: + if (lookahead == 's') ADVANCE(185); + END_STATE(); + case 159: + if (lookahead == 's') ADVANCE(46); + END_STATE(); + case 160: + if (lookahead == 's') ADVANCE(189); + END_STATE(); + case 161: + if (lookahead == 's') ADVANCE(177); + END_STATE(); + case 162: + if (lookahead == 's') ADVANCE(47); + END_STATE(); + case 163: + if (lookahead == 's') ADVANCE(179); + END_STATE(); + case 164: + if (lookahead == 's') ADVANCE(180); + END_STATE(); + case 165: + if (lookahead == 's') ADVANCE(104); + END_STATE(); + case 166: + if (lookahead == 's') ADVANCE(54); + END_STATE(); + case 167: + if (lookahead == 's') ADVANCE(119); + END_STATE(); + case 168: + if (lookahead == 's') ADVANCE(190); + END_STATE(); + case 169: + if (lookahead == 't') ADVANCE(73); + END_STATE(); + case 170: + if (lookahead == 't') ADVANCE(213); + END_STATE(); + case 171: + if (lookahead == 't') ADVANCE(79); + END_STATE(); + case 172: + if (lookahead == 't') ADVANCE(215); + END_STATE(); + case 173: + if (lookahead == 't') ADVANCE(214); + END_STATE(); + case 174: + if (lookahead == 't') ADVANCE(242); + END_STATE(); + case 175: + if (lookahead == 't') ADVANCE(220); + END_STATE(); + case 176: + if (lookahead == 't') ADVANCE(231); + END_STATE(); + case 177: + if (lookahead == 't') ADVANCE(227); + END_STATE(); + case 178: + if (lookahead == 't') ADVANCE(239); + END_STATE(); + case 179: + if (lookahead == 't') ADVANCE(240); + END_STATE(); + case 180: + if (lookahead == 't') ADVANCE(243); + END_STATE(); + case 181: + if (lookahead == 't') ADVANCE(75); + END_STATE(); + case 182: + if (lookahead == 't') ADVANCE(13); + END_STATE(); + case 183: + if (lookahead == 't') ADVANCE(3); + END_STATE(); + case 184: + if (lookahead == 't') ADVANCE(15); + END_STATE(); + case 185: + if (lookahead == 't') ADVANCE(149); + END_STATE(); + case 186: + if (lookahead == 't') ADVANCE(76); + END_STATE(); + case 187: + if (lookahead == 't') ADVANCE(82); + END_STATE(); + case 188: + if (lookahead == 't') ADVANCE(43); + END_STATE(); + case 189: + if (lookahead == 't') ADVANCE(6); + END_STATE(); + case 190: + if (lookahead == 't') ADVANCE(7); + END_STATE(); + case 191: + if (lookahead == 'u') ADVANCE(86); + END_STATE(); + case 192: + if (lookahead == 'u') ADVANCE(52); + END_STATE(); + case 193: + if (lookahead == 'u') ADVANCE(134); + END_STATE(); + case 194: + if (lookahead == 'u') ADVANCE(181); + END_STATE(); + case 195: + if (lookahead == 'u') ADVANCE(60); + END_STATE(); + case 196: + if (lookahead == 'u') ADVANCE(65); + END_STATE(); + case 197: + if (lookahead == 'u') ADVANCE(66); + END_STATE(); + case 198: + if (lookahead == 'v') ADVANCE(10); + END_STATE(); + case 199: + if (lookahead == 'v') ADVANCE(28); + END_STATE(); + case 200: + if (lookahead == 'w') ADVANCE(152); + END_STATE(); + case 201: + if (lookahead == 'x') ADVANCE(176); + END_STATE(); + case 202: + if (lookahead == 'y') ADVANCE(229); + END_STATE(); + case 203: + if (lookahead == 'y') ADVANCE(222); + END_STATE(); + case 204: + if (lookahead == 'y') ADVANCE(245); + END_STATE(); + case 205: + if (lookahead == '{') ADVANCE(249); + if (lookahead == '}') ADVANCE(250); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(257); + if (lookahead != 0) ADVANCE(258); + END_STATE(); + case 206: + if (lookahead == '}') ADVANCE(267); + if (lookahead != 0) ADVANCE(209); + END_STATE(); + case 207: + if (lookahead == '}') ADVANCE(251); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(207); + if (lookahead != 0 && + lookahead != ':') ADVANCE(261); + END_STATE(); + case 208: + if (lookahead == '}') ADVANCE(252); + if (lookahead == '\n' || + lookahead == '\r') SKIP(208); + if (('\t' <= lookahead && lookahead <= '\f') || + lookahead == ' ') ADVANCE(259); + if (lookahead != 0 && + lookahead != ':') ADVANCE(260); + END_STATE(); + case 209: + if (lookahead == '}') ADVANCE(206); + if (lookahead != 0) ADVANCE(209); + END_STATE(); + case 210: + if (lookahead != 0 && + lookahead != '\n') ADVANCE(2); + END_STATE(); + case 211: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 212: + ACCEPT_TOKEN(anon_sym_meta); + END_STATE(); + case 213: + ACCEPT_TOKEN(anon_sym_get); + END_STATE(); + case 214: + ACCEPT_TOKEN(anon_sym_post); + END_STATE(); + case 215: + ACCEPT_TOKEN(anon_sym_put); + END_STATE(); + case 216: + ACCEPT_TOKEN(anon_sym_delete); + END_STATE(); + case 217: + ACCEPT_TOKEN(anon_sym_patch); + END_STATE(); + case 218: + ACCEPT_TOKEN(anon_sym_options); + END_STATE(); + case 219: + ACCEPT_TOKEN(anon_sym_head); + if (lookahead == 'e') ADVANCE(136); + END_STATE(); + case 220: + ACCEPT_TOKEN(anon_sym_connect); + END_STATE(); + case 221: + ACCEPT_TOKEN(anon_sym_trace); + END_STATE(); + case 222: + ACCEPT_TOKEN(anon_sym_query); + END_STATE(); + case 223: + ACCEPT_TOKEN(anon_sym_headers); + END_STATE(); + case 224: + ACCEPT_TOKEN(anon_sym_auth_COLONawsv4); + END_STATE(); + case 225: + ACCEPT_TOKEN(anon_sym_auth_COLONbasic); + END_STATE(); + case 226: + ACCEPT_TOKEN(anon_sym_auth_COLONbearer); + END_STATE(); + case 227: + ACCEPT_TOKEN(anon_sym_auth_COLONdigest); + END_STATE(); + case 228: + ACCEPT_TOKEN(anon_sym_auth_COLONoauth2); + END_STATE(); + case 229: + ACCEPT_TOKEN(anon_sym_body); + if (lookahead == ':') ADVANCE(70); + END_STATE(); + case 230: + ACCEPT_TOKEN(anon_sym_body_COLONjson); + END_STATE(); + case 231: + ACCEPT_TOKEN(anon_sym_body_COLONtext); + END_STATE(); + case 232: + ACCEPT_TOKEN(anon_sym_body_COLONxml); + END_STATE(); + case 233: + ACCEPT_TOKEN(anon_sym_body_COLONsparql); + END_STATE(); + case 234: + ACCEPT_TOKEN(anon_sym_body_COLONgraphql); + if (lookahead == ':') ADVANCE(199); + END_STATE(); + case 235: + ACCEPT_TOKEN(anon_sym_body_COLONgraphql_COLONvars); + END_STATE(); + case 236: + ACCEPT_TOKEN(anon_sym_body_COLONform_DASHurlencoded); + END_STATE(); + case 237: + ACCEPT_TOKEN(anon_sym_body_COLONmultipart_DASHform); + END_STATE(); + case 238: + ACCEPT_TOKEN(anon_sym_vars); + if (lookahead == ':') ADVANCE(111); + END_STATE(); + case 239: + ACCEPT_TOKEN(anon_sym_vars_COLONsecret); + END_STATE(); + case 240: + ACCEPT_TOKEN(anon_sym_vars_COLONpre_DASHrequest); + END_STATE(); + case 241: + ACCEPT_TOKEN(anon_sym_vars_COLONpost_DASHresponse); + END_STATE(); + case 242: + ACCEPT_TOKEN(anon_sym_assert); + END_STATE(); + case 243: + ACCEPT_TOKEN(anon_sym_script_COLONpre_DASHrequest); + END_STATE(); + case 244: + ACCEPT_TOKEN(anon_sym_script_COLONpost_DASHresponse); + END_STATE(); + case 245: + ACCEPT_TOKEN(anon_sym_params_COLONquery); + END_STATE(); + case 246: + ACCEPT_TOKEN(anon_sym_params_COLONpath); + END_STATE(); + case 247: + ACCEPT_TOKEN(anon_sym_tests); + END_STATE(); + case 248: + ACCEPT_TOKEN(anon_sym_docs); + END_STATE(); + case 249: + ACCEPT_TOKEN(anon_sym_LBRACE); + END_STATE(); + case 250: + ACCEPT_TOKEN(anon_sym_RBRACE); + END_STATE(); + case 251: + ACCEPT_TOKEN(anon_sym_RBRACE); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ' ' && + lookahead != ':') ADVANCE(261); + END_STATE(); + case 252: + ACCEPT_TOKEN(anon_sym_RBRACE); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r' && + lookahead != ':') ADVANCE(260); + END_STATE(); + case 253: + ACCEPT_TOKEN(anon_sym_COLON); + END_STATE(); + case 254: + ACCEPT_TOKEN(anon_sym_LBRACK); + END_STATE(); + case 255: + ACCEPT_TOKEN(anon_sym_COMMA); + END_STATE(); + case 256: + ACCEPT_TOKEN(anon_sym_RBRACK); + END_STATE(); + case 257: + ACCEPT_TOKEN(sym_raw_text); + if (lookahead == '{') ADVANCE(249); + if (lookahead == '}') ADVANCE(250); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(257); + if (lookahead != 0) ADVANCE(258); + END_STATE(); + case 258: + ACCEPT_TOKEN(sym_raw_text); + if (lookahead != 0 && + lookahead != '{' && + lookahead != '}') ADVANCE(258); + END_STATE(); + case 259: + ACCEPT_TOKEN(sym_assert_key); + if (lookahead == '}') ADVANCE(252); + if (lookahead == '\t' || + lookahead == 0x0b || + lookahead == '\f' || + lookahead == ' ') ADVANCE(259); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ':') ADVANCE(260); + END_STATE(); + case 260: + ACCEPT_TOKEN(sym_assert_key); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r' && + lookahead != ':') ADVANCE(260); + END_STATE(); + case 261: + ACCEPT_TOKEN(sym_key); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != ' ' && + lookahead != ':') ADVANCE(261); + END_STATE(); + case 262: + ACCEPT_TOKEN(sym_bare_value); + if (lookahead == '{') ADVANCE(264); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(265); + END_STATE(); + case 263: + ACCEPT_TOKEN(sym_bare_value); + if (lookahead == '}') ADVANCE(265); + if (lookahead == '\n' || + lookahead == '\r') ADVANCE(209); + if (lookahead != 0) ADVANCE(264); + END_STATE(); + case 264: + ACCEPT_TOKEN(sym_bare_value); + if (lookahead == '}') ADVANCE(263); + if (lookahead == '\n' || + lookahead == '\r') ADVANCE(209); + if (lookahead != 0) ADVANCE(264); + END_STATE(); + case 265: + ACCEPT_TOKEN(sym_bare_value); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '\r') ADVANCE(265); + END_STATE(); + case 266: + ACCEPT_TOKEN(sym_quoted_value); + END_STATE(); + case 267: + ACCEPT_TOKEN(sym_template_value); + END_STATE(); + default: + return false; + } +} + +static const TSLexerMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0}, + [1] = {.lex_state = 0}, + [2] = {.lex_state = 0}, + [3] = {.lex_state = 0}, + [4] = {.lex_state = 0}, + [5] = {.lex_state = 0}, + [6] = {.lex_state = 0}, + [7] = {.lex_state = 0}, + [8] = {.lex_state = 0}, + [9] = {.lex_state = 0}, + [10] = {.lex_state = 0}, + [11] = {.lex_state = 0}, + [12] = {.lex_state = 0}, + [13] = {.lex_state = 0}, + [14] = {.lex_state = 0}, + [15] = {.lex_state = 0}, + [16] = {.lex_state = 0}, + [17] = {.lex_state = 0}, + [18] = {.lex_state = 0}, + [19] = {.lex_state = 0}, + [20] = {.lex_state = 0}, + [21] = {.lex_state = 0}, + [22] = {.lex_state = 0}, + [23] = {.lex_state = 0}, + [24] = {.lex_state = 0}, + [25] = {.lex_state = 0}, + [26] = {.lex_state = 0}, + [27] = {.lex_state = 0}, + [28] = {.lex_state = 0}, + [29] = {.lex_state = 0}, + [30] = {.lex_state = 0}, + [31] = {.lex_state = 0}, + [32] = {.lex_state = 0}, + [33] = {.lex_state = 0}, + [34] = {.lex_state = 0}, + [35] = {.lex_state = 0}, + [36] = {.lex_state = 0}, + [37] = {.lex_state = 0}, + [38] = {.lex_state = 0}, + [39] = {.lex_state = 0}, + [40] = {.lex_state = 0}, + [41] = {.lex_state = 0}, + [42] = {.lex_state = 0}, + [43] = {.lex_state = 0}, + [44] = {.lex_state = 0}, + [45] = {.lex_state = 0}, + [46] = {.lex_state = 0}, + [47] = {.lex_state = 1}, + [48] = {.lex_state = 205}, + [49] = {.lex_state = 205}, + [50] = {.lex_state = 205}, + [51] = {.lex_state = 205}, + [52] = {.lex_state = 1}, + [53] = {.lex_state = 1}, + [54] = {.lex_state = 205}, + [55] = {.lex_state = 1}, + [56] = {.lex_state = 1}, + [57] = {.lex_state = 1}, + [58] = {.lex_state = 207}, + [59] = {.lex_state = 208}, + [60] = {.lex_state = 207}, + [61] = {.lex_state = 1}, + [62] = {.lex_state = 1}, + [63] = {.lex_state = 208}, + [64] = {.lex_state = 207}, + [65] = {.lex_state = 208}, + [66] = {.lex_state = 205}, + [67] = {.lex_state = 205}, + [68] = {.lex_state = 205}, + [69] = {.lex_state = 0}, + [70] = {.lex_state = 0}, + [71] = {.lex_state = 0}, + [72] = {.lex_state = 0}, + [73] = {.lex_state = 0}, + [74] = {.lex_state = 0}, + [75] = {.lex_state = 0}, + [76] = {.lex_state = 0}, + [77] = {.lex_state = 0}, + [78] = {.lex_state = 0}, + [79] = {.lex_state = 0}, + [80] = {.lex_state = 0}, + [81] = {.lex_state = 0}, + [82] = {.lex_state = 0}, + [83] = {.lex_state = 0}, + [84] = {.lex_state = 0}, + [85] = {.lex_state = 0}, + [86] = {.lex_state = 0}, + [87] = {.lex_state = 0}, + [88] = {.lex_state = 0}, + [89] = {.lex_state = 0}, + [90] = {.lex_state = 0}, + [91] = {.lex_state = 0}, + [92] = {.lex_state = 0}, + [93] = {.lex_state = 207}, + [94] = {.lex_state = 207}, + [95] = {.lex_state = 208}, + [96] = {.lex_state = 0}, + [97] = {.lex_state = 0}, + [98] = {.lex_state = 208}, + [99] = {.lex_state = 0}, + [100] = {.lex_state = 0}, + [101] = {.lex_state = 0}, + [102] = {.lex_state = 0}, + [103] = {.lex_state = 0}, + [104] = {.lex_state = 0}, + [105] = {.lex_state = 0}, +}; + +static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [STATE(0)] = { + [ts_builtin_sym_end] = ACTIONS(1), + [anon_sym_meta] = ACTIONS(1), + [anon_sym_get] = ACTIONS(1), + [anon_sym_post] = ACTIONS(1), + [anon_sym_put] = ACTIONS(1), + [anon_sym_delete] = ACTIONS(1), + [anon_sym_patch] = ACTIONS(1), + [anon_sym_options] = ACTIONS(1), + [anon_sym_head] = ACTIONS(1), + [anon_sym_connect] = ACTIONS(1), + [anon_sym_trace] = ACTIONS(1), + [anon_sym_query] = ACTIONS(1), + [anon_sym_headers] = ACTIONS(1), + [anon_sym_auth_COLONawsv4] = ACTIONS(1), + [anon_sym_auth_COLONbasic] = ACTIONS(1), + [anon_sym_auth_COLONbearer] = ACTIONS(1), + [anon_sym_auth_COLONdigest] = ACTIONS(1), + [anon_sym_auth_COLONoauth2] = ACTIONS(1), + [anon_sym_body] = ACTIONS(1), + [anon_sym_body_COLONjson] = ACTIONS(1), + [anon_sym_body_COLONtext] = ACTIONS(1), + [anon_sym_body_COLONxml] = ACTIONS(1), + [anon_sym_body_COLONsparql] = ACTIONS(1), + [anon_sym_body_COLONgraphql] = ACTIONS(1), + [anon_sym_body_COLONgraphql_COLONvars] = ACTIONS(1), + [anon_sym_body_COLONform_DASHurlencoded] = ACTIONS(1), + [anon_sym_body_COLONmultipart_DASHform] = ACTIONS(1), + [anon_sym_vars] = ACTIONS(1), + [anon_sym_vars_COLONsecret] = ACTIONS(1), + [anon_sym_vars_COLONpre_DASHrequest] = ACTIONS(1), + [anon_sym_vars_COLONpost_DASHresponse] = ACTIONS(1), + [anon_sym_assert] = ACTIONS(1), + [anon_sym_script_COLONpre_DASHrequest] = ACTIONS(1), + [anon_sym_script_COLONpost_DASHresponse] = ACTIONS(1), + [anon_sym_params_COLONquery] = ACTIONS(1), + [anon_sym_params_COLONpath] = ACTIONS(1), + [anon_sym_tests] = ACTIONS(1), + [anon_sym_docs] = ACTIONS(1), + [anon_sym_LBRACE] = ACTIONS(1), + [anon_sym_RBRACE] = ACTIONS(1), + [anon_sym_COLON] = ACTIONS(1), + [anon_sym_LBRACK] = ACTIONS(1), + [anon_sym_COMMA] = ACTIONS(1), + [anon_sym_RBRACK] = ACTIONS(1), + [sym_quoted_value] = ACTIONS(1), + }, + [STATE(1)] = { + [sym_source_file] = STATE(102), + [sym_section] = STATE(2), + [sym_meta] = STATE(26), + [sym_http] = STATE(26), + [sym_http_verb] = STATE(85), + [sym_query] = STATE(26), + [sym_headers] = STATE(26), + [sym_auth] = STATE(26), + [sym_authawsv4] = STATE(6), + [sym_authbasic] = STATE(6), + [sym_authbearer] = STATE(6), + [sym_authdigest] = STATE(6), + [sym_authoauth2] = STATE(6), + [sym_body] = STATE(26), + [sym_bodyraw] = STATE(36), + [sym_bodyjson] = STATE(36), + [sym_bodytext] = STATE(36), + [sym_bodyxml] = STATE(36), + [sym_bodysparql] = STATE(36), + [sym_bodygraphql] = STATE(36), + [sym_bodygraphqlvars] = STATE(36), + [sym_bodyformurlencoded] = STATE(36), + [sym_bodyformmultipart] = STATE(36), + [sym_vars] = STATE(26), + [sym_vars_plain] = STATE(42), + [sym_vars_secret] = STATE(42), + [sym_varsreq] = STATE(42), + [sym_varsres] = STATE(42), + [sym_assert] = STATE(26), + [sym_script] = STATE(26), + [sym_scriptreq] = STATE(44), + [sym_scriptres] = STATE(44), + [sym_params] = STATE(26), + [sym_params_query] = STATE(5), + [sym_params_path] = STATE(5), + [sym_tests] = STATE(26), + [sym_docs] = STATE(26), + [aux_sym_source_file_repeat1] = STATE(2), + [ts_builtin_sym_end] = ACTIONS(3), + [anon_sym_meta] = ACTIONS(5), + [anon_sym_get] = ACTIONS(7), + [anon_sym_post] = ACTIONS(7), + [anon_sym_put] = ACTIONS(7), + [anon_sym_delete] = ACTIONS(7), + [anon_sym_patch] = ACTIONS(7), + [anon_sym_options] = ACTIONS(7), + [anon_sym_head] = ACTIONS(9), + [anon_sym_connect] = ACTIONS(7), + [anon_sym_trace] = ACTIONS(7), + [anon_sym_query] = ACTIONS(11), + [anon_sym_headers] = ACTIONS(13), + [anon_sym_auth_COLONawsv4] = ACTIONS(15), + [anon_sym_auth_COLONbasic] = ACTIONS(17), + [anon_sym_auth_COLONbearer] = ACTIONS(19), + [anon_sym_auth_COLONdigest] = ACTIONS(21), + [anon_sym_auth_COLONoauth2] = ACTIONS(23), + [anon_sym_body] = ACTIONS(25), + [anon_sym_body_COLONjson] = ACTIONS(27), + [anon_sym_body_COLONtext] = ACTIONS(29), + [anon_sym_body_COLONxml] = ACTIONS(31), + [anon_sym_body_COLONsparql] = ACTIONS(33), + [anon_sym_body_COLONgraphql] = ACTIONS(35), + [anon_sym_body_COLONgraphql_COLONvars] = ACTIONS(37), + [anon_sym_body_COLONform_DASHurlencoded] = ACTIONS(39), + [anon_sym_body_COLONmultipart_DASHform] = ACTIONS(41), + [anon_sym_vars] = ACTIONS(43), + [anon_sym_vars_COLONsecret] = ACTIONS(45), + [anon_sym_vars_COLONpre_DASHrequest] = ACTIONS(47), + [anon_sym_vars_COLONpost_DASHresponse] = ACTIONS(49), + [anon_sym_assert] = ACTIONS(51), + [anon_sym_script_COLONpre_DASHrequest] = ACTIONS(53), + [anon_sym_script_COLONpost_DASHresponse] = ACTIONS(55), + [anon_sym_params_COLONquery] = ACTIONS(57), + [anon_sym_params_COLONpath] = ACTIONS(59), + [anon_sym_tests] = ACTIONS(61), + [anon_sym_docs] = ACTIONS(63), + }, + [STATE(2)] = { + [sym_section] = STATE(3), + [sym_meta] = STATE(26), + [sym_http] = STATE(26), + [sym_http_verb] = STATE(85), + [sym_query] = STATE(26), + [sym_headers] = STATE(26), + [sym_auth] = STATE(26), + [sym_authawsv4] = STATE(6), + [sym_authbasic] = STATE(6), + [sym_authbearer] = STATE(6), + [sym_authdigest] = STATE(6), + [sym_authoauth2] = STATE(6), + [sym_body] = STATE(26), + [sym_bodyraw] = STATE(36), + [sym_bodyjson] = STATE(36), + [sym_bodytext] = STATE(36), + [sym_bodyxml] = STATE(36), + [sym_bodysparql] = STATE(36), + [sym_bodygraphql] = STATE(36), + [sym_bodygraphqlvars] = STATE(36), + [sym_bodyformurlencoded] = STATE(36), + [sym_bodyformmultipart] = STATE(36), + [sym_vars] = STATE(26), + [sym_vars_plain] = STATE(42), + [sym_vars_secret] = STATE(42), + [sym_varsreq] = STATE(42), + [sym_varsres] = STATE(42), + [sym_assert] = STATE(26), + [sym_script] = STATE(26), + [sym_scriptreq] = STATE(44), + [sym_scriptres] = STATE(44), + [sym_params] = STATE(26), + [sym_params_query] = STATE(5), + [sym_params_path] = STATE(5), + [sym_tests] = STATE(26), + [sym_docs] = STATE(26), + [aux_sym_source_file_repeat1] = STATE(3), + [ts_builtin_sym_end] = ACTIONS(65), + [anon_sym_meta] = ACTIONS(5), + [anon_sym_get] = ACTIONS(7), + [anon_sym_post] = ACTIONS(7), + [anon_sym_put] = ACTIONS(7), + [anon_sym_delete] = ACTIONS(7), + [anon_sym_patch] = ACTIONS(7), + [anon_sym_options] = ACTIONS(7), + [anon_sym_head] = ACTIONS(9), + [anon_sym_connect] = ACTIONS(7), + [anon_sym_trace] = ACTIONS(7), + [anon_sym_query] = ACTIONS(11), + [anon_sym_headers] = ACTIONS(13), + [anon_sym_auth_COLONawsv4] = ACTIONS(15), + [anon_sym_auth_COLONbasic] = ACTIONS(17), + [anon_sym_auth_COLONbearer] = ACTIONS(19), + [anon_sym_auth_COLONdigest] = ACTIONS(21), + [anon_sym_auth_COLONoauth2] = ACTIONS(23), + [anon_sym_body] = ACTIONS(25), + [anon_sym_body_COLONjson] = ACTIONS(27), + [anon_sym_body_COLONtext] = ACTIONS(29), + [anon_sym_body_COLONxml] = ACTIONS(31), + [anon_sym_body_COLONsparql] = ACTIONS(33), + [anon_sym_body_COLONgraphql] = ACTIONS(35), + [anon_sym_body_COLONgraphql_COLONvars] = ACTIONS(37), + [anon_sym_body_COLONform_DASHurlencoded] = ACTIONS(39), + [anon_sym_body_COLONmultipart_DASHform] = ACTIONS(41), + [anon_sym_vars] = ACTIONS(43), + [anon_sym_vars_COLONsecret] = ACTIONS(45), + [anon_sym_vars_COLONpre_DASHrequest] = ACTIONS(47), + [anon_sym_vars_COLONpost_DASHresponse] = ACTIONS(49), + [anon_sym_assert] = ACTIONS(51), + [anon_sym_script_COLONpre_DASHrequest] = ACTIONS(53), + [anon_sym_script_COLONpost_DASHresponse] = ACTIONS(55), + [anon_sym_params_COLONquery] = ACTIONS(57), + [anon_sym_params_COLONpath] = ACTIONS(59), + [anon_sym_tests] = ACTIONS(61), + [anon_sym_docs] = ACTIONS(63), + }, + [STATE(3)] = { + [sym_section] = STATE(3), + [sym_meta] = STATE(26), + [sym_http] = STATE(26), + [sym_http_verb] = STATE(85), + [sym_query] = STATE(26), + [sym_headers] = STATE(26), + [sym_auth] = STATE(26), + [sym_authawsv4] = STATE(6), + [sym_authbasic] = STATE(6), + [sym_authbearer] = STATE(6), + [sym_authdigest] = STATE(6), + [sym_authoauth2] = STATE(6), + [sym_body] = STATE(26), + [sym_bodyraw] = STATE(36), + [sym_bodyjson] = STATE(36), + [sym_bodytext] = STATE(36), + [sym_bodyxml] = STATE(36), + [sym_bodysparql] = STATE(36), + [sym_bodygraphql] = STATE(36), + [sym_bodygraphqlvars] = STATE(36), + [sym_bodyformurlencoded] = STATE(36), + [sym_bodyformmultipart] = STATE(36), + [sym_vars] = STATE(26), + [sym_vars_plain] = STATE(42), + [sym_vars_secret] = STATE(42), + [sym_varsreq] = STATE(42), + [sym_varsres] = STATE(42), + [sym_assert] = STATE(26), + [sym_script] = STATE(26), + [sym_scriptreq] = STATE(44), + [sym_scriptres] = STATE(44), + [sym_params] = STATE(26), + [sym_params_query] = STATE(5), + [sym_params_path] = STATE(5), + [sym_tests] = STATE(26), + [sym_docs] = STATE(26), + [aux_sym_source_file_repeat1] = STATE(3), + [ts_builtin_sym_end] = ACTIONS(67), + [anon_sym_meta] = ACTIONS(69), + [anon_sym_get] = ACTIONS(72), + [anon_sym_post] = ACTIONS(72), + [anon_sym_put] = ACTIONS(72), + [anon_sym_delete] = ACTIONS(72), + [anon_sym_patch] = ACTIONS(72), + [anon_sym_options] = ACTIONS(72), + [anon_sym_head] = ACTIONS(75), + [anon_sym_connect] = ACTIONS(72), + [anon_sym_trace] = ACTIONS(72), + [anon_sym_query] = ACTIONS(78), + [anon_sym_headers] = ACTIONS(81), + [anon_sym_auth_COLONawsv4] = ACTIONS(84), + [anon_sym_auth_COLONbasic] = ACTIONS(87), + [anon_sym_auth_COLONbearer] = ACTIONS(90), + [anon_sym_auth_COLONdigest] = ACTIONS(93), + [anon_sym_auth_COLONoauth2] = ACTIONS(96), + [anon_sym_body] = ACTIONS(99), + [anon_sym_body_COLONjson] = ACTIONS(102), + [anon_sym_body_COLONtext] = ACTIONS(105), + [anon_sym_body_COLONxml] = ACTIONS(108), + [anon_sym_body_COLONsparql] = ACTIONS(111), + [anon_sym_body_COLONgraphql] = ACTIONS(114), + [anon_sym_body_COLONgraphql_COLONvars] = ACTIONS(117), + [anon_sym_body_COLONform_DASHurlencoded] = ACTIONS(120), + [anon_sym_body_COLONmultipart_DASHform] = ACTIONS(123), + [anon_sym_vars] = ACTIONS(126), + [anon_sym_vars_COLONsecret] = ACTIONS(129), + [anon_sym_vars_COLONpre_DASHrequest] = ACTIONS(132), + [anon_sym_vars_COLONpost_DASHresponse] = ACTIONS(135), + [anon_sym_assert] = ACTIONS(138), + [anon_sym_script_COLONpre_DASHrequest] = ACTIONS(141), + [anon_sym_script_COLONpost_DASHresponse] = ACTIONS(144), + [anon_sym_params_COLONquery] = ACTIONS(147), + [anon_sym_params_COLONpath] = ACTIONS(150), + [anon_sym_tests] = ACTIONS(153), + [anon_sym_docs] = ACTIONS(156), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 2, + ACTIONS(161), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(159), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [43] = 2, + ACTIONS(165), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(163), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [86] = 2, + ACTIONS(169), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(167), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [129] = 2, + ACTIONS(173), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(171), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [172] = 2, + ACTIONS(177), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(175), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [215] = 2, + ACTIONS(181), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(179), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [258] = 2, + ACTIONS(185), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(183), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [301] = 2, + ACTIONS(189), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(187), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [344] = 2, + ACTIONS(193), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(191), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [387] = 2, + ACTIONS(197), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(195), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [430] = 2, + ACTIONS(201), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(199), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [473] = 2, + ACTIONS(205), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(203), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [516] = 2, + ACTIONS(209), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(207), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [559] = 2, + ACTIONS(213), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(211), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [602] = 2, + ACTIONS(217), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(215), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [645] = 2, + ACTIONS(221), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(219), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [688] = 2, + ACTIONS(225), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(223), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [731] = 2, + ACTIONS(229), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(227), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [774] = 2, + ACTIONS(233), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(231), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [817] = 2, + ACTIONS(237), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(235), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [860] = 2, + ACTIONS(241), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(239), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [903] = 2, + ACTIONS(245), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(243), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [946] = 2, + ACTIONS(249), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(247), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [989] = 2, + ACTIONS(253), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(251), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1032] = 2, + ACTIONS(257), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(255), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1075] = 2, + ACTIONS(261), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(259), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1118] = 2, + ACTIONS(265), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(263), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1161] = 2, + ACTIONS(269), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(267), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1204] = 2, + ACTIONS(273), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(271), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1247] = 2, + ACTIONS(277), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(275), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1290] = 2, + ACTIONS(281), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(279), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1333] = 2, + ACTIONS(285), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(283), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1376] = 2, + ACTIONS(289), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(287), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1419] = 2, + ACTIONS(293), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(291), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1462] = 2, + ACTIONS(297), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(295), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1505] = 2, + ACTIONS(301), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(299), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1548] = 2, + ACTIONS(305), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(303), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1591] = 2, + ACTIONS(309), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(307), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1634] = 2, + ACTIONS(313), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(311), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1677] = 2, + ACTIONS(317), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(315), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1720] = 2, + ACTIONS(321), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(319), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1763] = 2, + ACTIONS(325), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(323), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1806] = 2, + ACTIONS(329), 4, + anon_sym_head, + anon_sym_body, + anon_sym_body_COLONgraphql, + anon_sym_vars, + ACTIONS(327), 34, + ts_builtin_sym_end, + anon_sym_meta, + anon_sym_get, + anon_sym_post, + anon_sym_put, + anon_sym_delete, + anon_sym_patch, + anon_sym_options, + anon_sym_connect, + anon_sym_trace, + anon_sym_query, + anon_sym_headers, + anon_sym_auth_COLONawsv4, + anon_sym_auth_COLONbasic, + anon_sym_auth_COLONbearer, + anon_sym_auth_COLONdigest, + anon_sym_auth_COLONoauth2, + anon_sym_body_COLONjson, + anon_sym_body_COLONtext, + anon_sym_body_COLONxml, + anon_sym_body_COLONsparql, + anon_sym_body_COLONgraphql_COLONvars, + anon_sym_body_COLONform_DASHurlencoded, + anon_sym_body_COLONmultipart_DASHform, + anon_sym_vars_COLONsecret, + anon_sym_vars_COLONpre_DASHrequest, + anon_sym_vars_COLONpost_DASHresponse, + anon_sym_assert, + anon_sym_script_COLONpre_DASHrequest, + anon_sym_script_COLONpost_DASHresponse, + anon_sym_params_COLONquery, + anon_sym_params_COLONpath, + anon_sym_tests, + anon_sym_docs, + [1849] = 5, + ACTIONS(331), 1, + anon_sym_RBRACK, + ACTIONS(335), 1, + sym_quoted_value, + STATE(53), 1, + aux_sym_array_block_repeat1, + STATE(55), 1, + sym_array_value, + ACTIONS(333), 2, + sym_bare_value, + sym_template_value, + [1866] = 5, + ACTIONS(337), 1, + anon_sym_LBRACE, + ACTIONS(339), 1, + anon_sym_RBRACE, + ACTIONS(341), 1, + sym_raw_text, + STATE(67), 1, + sym_raw_block, + STATE(50), 2, + sym_raw_fragment, + aux_sym_raw_block_repeat1, + [1883] = 5, + ACTIONS(337), 1, + anon_sym_LBRACE, + ACTIONS(341), 1, + sym_raw_text, + ACTIONS(343), 1, + anon_sym_RBRACE, + STATE(67), 1, + sym_raw_block, + STATE(48), 2, + sym_raw_fragment, + aux_sym_raw_block_repeat1, + [1900] = 5, + ACTIONS(345), 1, + anon_sym_LBRACE, + ACTIONS(348), 1, + anon_sym_RBRACE, + ACTIONS(350), 1, + sym_raw_text, + STATE(67), 1, + sym_raw_block, + STATE(50), 2, + sym_raw_fragment, + aux_sym_raw_block_repeat1, + [1917] = 5, + ACTIONS(337), 1, + anon_sym_LBRACE, + ACTIONS(341), 1, + sym_raw_text, + ACTIONS(353), 1, + anon_sym_RBRACE, + STATE(67), 1, + sym_raw_block, + STATE(54), 2, + sym_raw_fragment, + aux_sym_raw_block_repeat1, + [1934] = 5, + ACTIONS(355), 1, + anon_sym_RBRACK, + ACTIONS(360), 1, + sym_quoted_value, + STATE(52), 1, + aux_sym_array_block_repeat1, + STATE(55), 1, + sym_array_value, + ACTIONS(357), 2, + sym_bare_value, + sym_template_value, + [1951] = 5, + ACTIONS(335), 1, + sym_quoted_value, + ACTIONS(363), 1, + anon_sym_RBRACK, + STATE(52), 1, + aux_sym_array_block_repeat1, + STATE(55), 1, + sym_array_value, + ACTIONS(333), 2, + sym_bare_value, + sym_template_value, + [1968] = 5, + ACTIONS(337), 1, + anon_sym_LBRACE, + ACTIONS(341), 1, + sym_raw_text, + ACTIONS(365), 1, + anon_sym_RBRACE, + STATE(67), 1, + sym_raw_block, + STATE(50), 2, + sym_raw_fragment, + aux_sym_raw_block_repeat1, + [1985] = 3, + ACTIONS(367), 1, + anon_sym_COMMA, + ACTIONS(369), 2, + anon_sym_RBRACK, + sym_quoted_value, + ACTIONS(371), 2, + sym_bare_value, + sym_template_value, + [1997] = 2, + ACTIONS(375), 2, + sym_bare_value, + sym_template_value, + ACTIONS(373), 3, + anon_sym_COMMA, + anon_sym_RBRACK, + sym_quoted_value, + [2007] = 3, + ACTIONS(379), 1, + sym_quoted_value, + STATE(95), 1, + sym_dictionary_value, + ACTIONS(377), 2, + sym_bare_value, + sym_template_value, + [2018] = 3, + ACTIONS(381), 1, + anon_sym_RBRACE, + ACTIONS(383), 1, + sym_key, + STATE(64), 2, + sym_dictionary_pair, + aux_sym_object_block_repeat1, + [2029] = 3, + ACTIONS(385), 1, + anon_sym_RBRACE, + ACTIONS(387), 1, + sym_assert_key, + STATE(63), 2, + sym_assert_dictionary_pair, + aux_sym_assert_block_repeat1, + [2040] = 3, + ACTIONS(383), 1, + sym_key, + ACTIONS(389), 1, + anon_sym_RBRACE, + STATE(58), 2, + sym_dictionary_pair, + aux_sym_object_block_repeat1, + [2051] = 3, + ACTIONS(393), 1, + sym_quoted_value, + STATE(94), 1, + sym_dictionary_value, + ACTIONS(391), 2, + sym_bare_value, + sym_template_value, + [2062] = 2, + ACTIONS(355), 2, + anon_sym_RBRACK, + sym_quoted_value, + ACTIONS(395), 2, + sym_bare_value, + sym_template_value, + [2071] = 3, + ACTIONS(387), 1, + sym_assert_key, + ACTIONS(397), 1, + anon_sym_RBRACE, + STATE(65), 2, + sym_assert_dictionary_pair, + aux_sym_assert_block_repeat1, + [2082] = 3, + ACTIONS(399), 1, + anon_sym_RBRACE, + ACTIONS(401), 1, + sym_key, + STATE(64), 2, + sym_dictionary_pair, + aux_sym_object_block_repeat1, + [2093] = 3, + ACTIONS(404), 1, + anon_sym_RBRACE, + ACTIONS(406), 1, + sym_assert_key, + STATE(65), 2, + sym_assert_dictionary_pair, + aux_sym_assert_block_repeat1, + [2104] = 1, + ACTIONS(161), 3, + anon_sym_LBRACE, + anon_sym_RBRACE, + sym_raw_text, + [2110] = 1, + ACTIONS(409), 3, + anon_sym_LBRACE, + anon_sym_RBRACE, + sym_raw_text, + [2116] = 1, + ACTIONS(297), 3, + anon_sym_LBRACE, + anon_sym_RBRACE, + sym_raw_text, + [2122] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(18), 1, + sym_raw_block, + [2129] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(11), 1, + sym_object_block, + [2136] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(12), 1, + sym_object_block, + [2143] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(33), 1, + sym_raw_block, + [2150] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(13), 1, + sym_object_block, + [2157] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(34), 1, + sym_raw_block, + [2164] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(14), 1, + sym_object_block, + [2171] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(15), 1, + sym_raw_block, + [2178] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(16), 1, + sym_raw_block, + [2185] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(17), 1, + sym_raw_block, + [2192] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(30), 1, + sym_raw_block, + [2199] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(19), 1, + sym_raw_block, + [2206] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(20), 1, + sym_raw_block, + [2213] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(31), 1, + sym_object_block, + [2220] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(7), 1, + sym_object_block, + [2227] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(21), 1, + sym_raw_block, + [2234] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(35), 1, + sym_object_block, + [2241] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(22), 1, + sym_object_block, + [2248] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(23), 1, + sym_object_block, + [2255] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(24), 1, + sym_object_block, + [2262] = 2, + ACTIONS(415), 1, + anon_sym_LBRACK, + STATE(25), 1, + sym_array_block, + [2269] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(46), 1, + sym_object_block, + [2276] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(27), 1, + sym_object_block, + [2283] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(8), 1, + sym_object_block, + [2290] = 1, + ACTIONS(417), 2, + anon_sym_RBRACE, + sym_key, + [2295] = 1, + ACTIONS(419), 2, + anon_sym_RBRACE, + sym_key, + [2300] = 1, + ACTIONS(421), 2, + anon_sym_RBRACE, + sym_assert_key, + [2305] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(9), 1, + sym_object_block, + [2312] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(10), 1, + sym_object_block, + [2319] = 1, + ACTIONS(417), 2, + anon_sym_RBRACE, + sym_assert_key, + [2324] = 2, + ACTIONS(423), 1, + anon_sym_LBRACE, + STATE(28), 1, + sym_assert_block, + [2331] = 2, + ACTIONS(411), 1, + anon_sym_LBRACE, + STATE(29), 1, + sym_raw_block, + [2338] = 2, + ACTIONS(413), 1, + anon_sym_LBRACE, + STATE(32), 1, + sym_object_block, + [2345] = 1, + ACTIONS(425), 1, + ts_builtin_sym_end, + [2349] = 1, + ACTIONS(427), 1, + anon_sym_COLON, + [2353] = 1, + ACTIONS(429), 1, + anon_sym_LBRACE, + [2357] = 1, + ACTIONS(431), 1, + anon_sym_COLON, +}; + +static const uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(4)] = 0, + [SMALL_STATE(5)] = 43, + [SMALL_STATE(6)] = 86, + [SMALL_STATE(7)] = 129, + [SMALL_STATE(8)] = 172, + [SMALL_STATE(9)] = 215, + [SMALL_STATE(10)] = 258, + [SMALL_STATE(11)] = 301, + [SMALL_STATE(12)] = 344, + [SMALL_STATE(13)] = 387, + [SMALL_STATE(14)] = 430, + [SMALL_STATE(15)] = 473, + [SMALL_STATE(16)] = 516, + [SMALL_STATE(17)] = 559, + [SMALL_STATE(18)] = 602, + [SMALL_STATE(19)] = 645, + [SMALL_STATE(20)] = 688, + [SMALL_STATE(21)] = 731, + [SMALL_STATE(22)] = 774, + [SMALL_STATE(23)] = 817, + [SMALL_STATE(24)] = 860, + [SMALL_STATE(25)] = 903, + [SMALL_STATE(26)] = 946, + [SMALL_STATE(27)] = 989, + [SMALL_STATE(28)] = 1032, + [SMALL_STATE(29)] = 1075, + [SMALL_STATE(30)] = 1118, + [SMALL_STATE(31)] = 1161, + [SMALL_STATE(32)] = 1204, + [SMALL_STATE(33)] = 1247, + [SMALL_STATE(34)] = 1290, + [SMALL_STATE(35)] = 1333, + [SMALL_STATE(36)] = 1376, + [SMALL_STATE(37)] = 1419, + [SMALL_STATE(38)] = 1462, + [SMALL_STATE(39)] = 1505, + [SMALL_STATE(40)] = 1548, + [SMALL_STATE(41)] = 1591, + [SMALL_STATE(42)] = 1634, + [SMALL_STATE(43)] = 1677, + [SMALL_STATE(44)] = 1720, + [SMALL_STATE(45)] = 1763, + [SMALL_STATE(46)] = 1806, + [SMALL_STATE(47)] = 1849, + [SMALL_STATE(48)] = 1866, + [SMALL_STATE(49)] = 1883, + [SMALL_STATE(50)] = 1900, + [SMALL_STATE(51)] = 1917, + [SMALL_STATE(52)] = 1934, + [SMALL_STATE(53)] = 1951, + [SMALL_STATE(54)] = 1968, + [SMALL_STATE(55)] = 1985, + [SMALL_STATE(56)] = 1997, + [SMALL_STATE(57)] = 2007, + [SMALL_STATE(58)] = 2018, + [SMALL_STATE(59)] = 2029, + [SMALL_STATE(60)] = 2040, + [SMALL_STATE(61)] = 2051, + [SMALL_STATE(62)] = 2062, + [SMALL_STATE(63)] = 2071, + [SMALL_STATE(64)] = 2082, + [SMALL_STATE(65)] = 2093, + [SMALL_STATE(66)] = 2104, + [SMALL_STATE(67)] = 2110, + [SMALL_STATE(68)] = 2116, + [SMALL_STATE(69)] = 2122, + [SMALL_STATE(70)] = 2129, + [SMALL_STATE(71)] = 2136, + [SMALL_STATE(72)] = 2143, + [SMALL_STATE(73)] = 2150, + [SMALL_STATE(74)] = 2157, + [SMALL_STATE(75)] = 2164, + [SMALL_STATE(76)] = 2171, + [SMALL_STATE(77)] = 2178, + [SMALL_STATE(78)] = 2185, + [SMALL_STATE(79)] = 2192, + [SMALL_STATE(80)] = 2199, + [SMALL_STATE(81)] = 2206, + [SMALL_STATE(82)] = 2213, + [SMALL_STATE(83)] = 2220, + [SMALL_STATE(84)] = 2227, + [SMALL_STATE(85)] = 2234, + [SMALL_STATE(86)] = 2241, + [SMALL_STATE(87)] = 2248, + [SMALL_STATE(88)] = 2255, + [SMALL_STATE(89)] = 2262, + [SMALL_STATE(90)] = 2269, + [SMALL_STATE(91)] = 2276, + [SMALL_STATE(92)] = 2283, + [SMALL_STATE(93)] = 2290, + [SMALL_STATE(94)] = 2295, + [SMALL_STATE(95)] = 2300, + [SMALL_STATE(96)] = 2305, + [SMALL_STATE(97)] = 2312, + [SMALL_STATE(98)] = 2319, + [SMALL_STATE(99)] = 2324, + [SMALL_STATE(100)] = 2331, + [SMALL_STATE(101)] = 2338, + [SMALL_STATE(102)] = 2345, + [SMALL_STATE(103)] = 2349, + [SMALL_STATE(104)] = 2353, + [SMALL_STATE(105)] = 2357, +}; + +static const TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0, 0, 0), + [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(104), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(76), + [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(81), + [37] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [39] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(88), + [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [49] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [53] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [55] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), + [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [65] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), + [67] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), + [69] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(83), + [72] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(104), + [75] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(104), + [78] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(92), + [81] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(96), + [84] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(97), + [87] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(70), + [90] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(71), + [93] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(73), + [96] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(75), + [99] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(76), + [102] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(77), + [105] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(78), + [108] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(69), + [111] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(80), + [114] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(81), + [117] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(84), + [120] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(86), + [123] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(87), + [126] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(88), + [129] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(89), + [132] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(90), + [135] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(91), + [138] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(99), + [141] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(100), + [144] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(79), + [147] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(82), + [150] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(101), + [153] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(72), + [156] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(74), + [159] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_raw_block, 3, 0, 0), + [161] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_raw_block, 3, 0, 0), + [163] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_params, 1, 0, 0), + [165] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_params, 1, 0, 0), + [167] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_auth, 1, 0, 0), + [169] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_auth, 1, 0, 0), + [171] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_meta, 2, 0, 0), + [173] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_meta, 2, 0, 0), + [175] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query, 2, 0, 0), + [177] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query, 2, 0, 0), + [179] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_headers, 2, 0, 0), + [181] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_headers, 2, 0, 0), + [183] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_authawsv4, 2, 0, 0), + [185] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_authawsv4, 2, 0, 0), + [187] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_authbasic, 2, 0, 0), + [189] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_authbasic, 2, 0, 0), + [191] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_authbearer, 2, 0, 0), + [193] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_authbearer, 2, 0, 0), + [195] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_authdigest, 2, 0, 0), + [197] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_authdigest, 2, 0, 0), + [199] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_authoauth2, 2, 0, 0), + [201] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_authoauth2, 2, 0, 0), + [203] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bodyraw, 2, 0, 0), + [205] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bodyraw, 2, 0, 0), + [207] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bodyjson, 2, 0, 0), + [209] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bodyjson, 2, 0, 0), + [211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bodytext, 2, 0, 0), + [213] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bodytext, 2, 0, 0), + [215] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bodyxml, 2, 0, 0), + [217] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bodyxml, 2, 0, 0), + [219] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bodysparql, 2, 0, 0), + [221] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bodysparql, 2, 0, 0), + [223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bodygraphql, 2, 0, 0), + [225] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bodygraphql, 2, 0, 0), + [227] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bodygraphqlvars, 2, 0, 0), + [229] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bodygraphqlvars, 2, 0, 0), + [231] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bodyformurlencoded, 2, 0, 0), + [233] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bodyformurlencoded, 2, 0, 0), + [235] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bodyformmultipart, 2, 0, 0), + [237] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bodyformmultipart, 2, 0, 0), + [239] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_vars_plain, 2, 0, 0), + [241] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_vars_plain, 2, 0, 0), + [243] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_vars_secret, 2, 0, 0), + [245] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_vars_secret, 2, 0, 0), + [247] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_section, 1, 0, 0), + [249] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_section, 1, 0, 0), + [251] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_varsres, 2, 0, 0), + [253] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_varsres, 2, 0, 0), + [255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assert, 2, 0, 0), + [257] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assert, 2, 0, 0), + [259] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_scriptreq, 2, 0, 0), + [261] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_scriptreq, 2, 0, 0), + [263] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_scriptres, 2, 0, 0), + [265] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_scriptres, 2, 0, 0), + [267] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_params_query, 2, 0, 0), + [269] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_params_query, 2, 0, 0), + [271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_params_path, 2, 0, 0), + [273] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_params_path, 2, 0, 0), + [275] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tests, 2, 0, 0), + [277] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tests, 2, 0, 0), + [279] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_docs, 2, 0, 0), + [281] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_docs, 2, 0, 0), + [283] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_http, 2, 0, 0), + [285] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_http, 2, 0, 0), + [287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_body, 1, 0, 0), + [289] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_body, 1, 0, 0), + [291] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_block, 2, 0, 0), + [293] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_block, 2, 0, 0), + [295] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_raw_block, 2, 0, 0), + [297] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_raw_block, 2, 0, 0), + [299] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_block, 2, 0, 0), + [301] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_block, 2, 0, 0), + [303] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assert_block, 2, 0, 0), + [305] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assert_block, 2, 0, 0), + [307] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_block, 3, 0, 0), + [309] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_block, 3, 0, 0), + [311] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_vars, 1, 0, 0), + [313] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_vars, 1, 0, 0), + [315] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_block, 3, 0, 0), + [317] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_block, 3, 0, 0), + [319] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_script, 1, 0, 0), + [321] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_script, 1, 0, 0), + [323] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assert_block, 3, 0, 0), + [325] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assert_block, 3, 0, 0), + [327] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_varsreq, 2, 0, 0), + [329] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_varsreq, 2, 0, 0), + [331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [333] = {.entry = {.count = 1, .reusable = false}}, SHIFT(56), + [335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [337] = {.entry = {.count = 1, .reusable = false}}, SHIFT(51), + [339] = {.entry = {.count = 1, .reusable = false}}, SHIFT(4), + [341] = {.entry = {.count = 1, .reusable = false}}, SHIFT(67), + [343] = {.entry = {.count = 1, .reusable = false}}, SHIFT(38), + [345] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_raw_block_repeat1, 2, 0, 0), SHIFT_REPEAT(51), + [348] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_raw_block_repeat1, 2, 0, 0), + [350] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_raw_block_repeat1, 2, 0, 0), SHIFT_REPEAT(67), + [353] = {.entry = {.count = 1, .reusable = false}}, SHIFT(68), + [355] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_block_repeat1, 2, 0, 0), + [357] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_array_block_repeat1, 2, 0, 0), SHIFT_REPEAT(56), + [360] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_array_block_repeat1, 2, 0, 0), SHIFT_REPEAT(56), + [363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [365] = {.entry = {.count = 1, .reusable = false}}, SHIFT(66), + [367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_block_repeat1, 1, 0, 0), + [371] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_array_block_repeat1, 1, 0, 0), + [373] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_value, 1, 0, 0), + [375] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_value, 1, 0, 0), + [377] = {.entry = {.count = 1, .reusable = false}}, SHIFT(98), + [379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [381] = {.entry = {.count = 1, .reusable = false}}, SHIFT(41), + [383] = {.entry = {.count = 1, .reusable = false}}, SHIFT(105), + [385] = {.entry = {.count = 1, .reusable = false}}, SHIFT(40), + [387] = {.entry = {.count = 1, .reusable = false}}, SHIFT(103), + [389] = {.entry = {.count = 1, .reusable = false}}, SHIFT(37), + [391] = {.entry = {.count = 1, .reusable = false}}, SHIFT(93), + [393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [395] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_array_block_repeat1, 2, 0, 0), + [397] = {.entry = {.count = 1, .reusable = false}}, SHIFT(45), + [399] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_object_block_repeat1, 2, 0, 0), + [401] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_block_repeat1, 2, 0, 0), SHIFT_REPEAT(105), + [404] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_assert_block_repeat1, 2, 0, 0), + [406] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_assert_block_repeat1, 2, 0, 0), SHIFT_REPEAT(103), + [409] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_raw_fragment, 1, 0, 0), + [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [417] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dictionary_value, 1, 0, 0), + [419] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dictionary_pair, 3, 0, 0), + [421] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assert_dictionary_pair, 3, 0, 0), + [423] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [425] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [429] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_http_verb, 1, 0, 0), + [431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), +}; + +#ifdef __cplusplus +extern "C" { +#endif +#ifdef TREE_SITTER_HIDE_SYMBOLS +#define TS_PUBLIC +#elif defined(_WIN32) +#define TS_PUBLIC __declspec(dllexport) +#else +#define TS_PUBLIC __attribute__((visibility("default"))) +#endif + +TS_PUBLIC const TSLanguage *tree_sitter_bruno(void) { + static const TSLanguage language = { + .abi_version = LANGUAGE_VERSION, + .symbol_count = SYMBOL_COUNT, + .alias_count = ALIAS_COUNT, + .token_count = TOKEN_COUNT, + .external_token_count = EXTERNAL_TOKEN_COUNT, + .state_count = STATE_COUNT, + .large_state_count = LARGE_STATE_COUNT, + .production_id_count = PRODUCTION_ID_COUNT, + .supertype_count = SUPERTYPE_COUNT, + .field_count = FIELD_COUNT, + .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH, + .parse_table = &ts_parse_table[0][0], + .small_parse_table = ts_small_parse_table, + .small_parse_table_map = ts_small_parse_table_map, + .parse_actions = ts_parse_actions, + .symbol_names = ts_symbol_names, + .symbol_metadata = ts_symbol_metadata, + .public_symbol_map = ts_symbol_map, + .alias_map = ts_non_terminal_alias_map, + .alias_sequences = &ts_alias_sequences[0][0], + .lex_modes = (const void*)ts_lex_modes, + .lex_fn = ts_lex, + .primary_state_ids = ts_primary_state_ids, + .name = "bruno", + .max_reserved_word_set_size = 0, + .metadata = { + .major_version = 0, + .minor_version = 1, + .patch_version = 0, + }, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/src/tree_sitter/alloc.h b/src/tree_sitter/alloc.h new file mode 100644 index 0000000..1abdd12 --- /dev/null +++ b/src/tree_sitter/alloc.h @@ -0,0 +1,54 @@ +#ifndef TREE_SITTER_ALLOC_H_ +#define TREE_SITTER_ALLOC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +// Allow clients to override allocation functions +#ifdef TREE_SITTER_REUSE_ALLOCATOR + +extern void *(*ts_current_malloc)(size_t size); +extern void *(*ts_current_calloc)(size_t count, size_t size); +extern void *(*ts_current_realloc)(void *ptr, size_t size); +extern void (*ts_current_free)(void *ptr); + +#ifndef ts_malloc +#define ts_malloc ts_current_malloc +#endif +#ifndef ts_calloc +#define ts_calloc ts_current_calloc +#endif +#ifndef ts_realloc +#define ts_realloc ts_current_realloc +#endif +#ifndef ts_free +#define ts_free ts_current_free +#endif + +#else + +#ifndef ts_malloc +#define ts_malloc malloc +#endif +#ifndef ts_calloc +#define ts_calloc calloc +#endif +#ifndef ts_realloc +#define ts_realloc realloc +#endif +#ifndef ts_free +#define ts_free free +#endif + +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ALLOC_H_ diff --git a/src/tree_sitter/array.h b/src/tree_sitter/array.h new file mode 100644 index 0000000..a17a574 --- /dev/null +++ b/src/tree_sitter/array.h @@ -0,0 +1,291 @@ +#ifndef TREE_SITTER_ARRAY_H_ +#define TREE_SITTER_ARRAY_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "./alloc.h" + +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4101) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-variable" +#endif + +#define Array(T) \ + struct { \ + T *contents; \ + uint32_t size; \ + uint32_t capacity; \ + } + +/// Initialize an array. +#define array_init(self) \ + ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL) + +/// Create an empty array. +#define array_new() \ + { NULL, 0, 0 } + +/// Get a pointer to the element at a given `index` in the array. +#define array_get(self, _index) \ + (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index]) + +/// Get a pointer to the first element in the array. +#define array_front(self) array_get(self, 0) + +/// Get a pointer to the last element in the array. +#define array_back(self) array_get(self, (self)->size - 1) + +/// Clear the array, setting its size to zero. Note that this does not free any +/// memory allocated for the array's contents. +#define array_clear(self) ((self)->size = 0) + +/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is +/// less than the array's current capacity, this function has no effect. +#define array_reserve(self, new_capacity) \ + _array__reserve((Array *)(self), array_elem_size(self), new_capacity) + +/// Free any memory allocated for this array. Note that this does not free any +/// memory allocated for the array's contents. +#define array_delete(self) _array__delete((Array *)(self)) + +/// Push a new `element` onto the end of the array. +#define array_push(self, element) \ + (_array__grow((Array *)(self), 1, array_elem_size(self)), \ + (self)->contents[(self)->size++] = (element)) + +/// Increase the array's size by `count` elements. +/// New elements are zero-initialized. +#define array_grow_by(self, count) \ + do { \ + if ((count) == 0) break; \ + _array__grow((Array *)(self), count, array_elem_size(self)); \ + memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \ + (self)->size += (count); \ + } while (0) + +/// Append all elements from one array to the end of another. +#define array_push_all(self, other) \ + array_extend((self), (other)->size, (other)->contents) + +/// Append `count` elements to the end of the array, reading their values from the +/// `contents` pointer. +#define array_extend(self, count, contents) \ + _array__splice( \ + (Array *)(self), array_elem_size(self), (self)->size, \ + 0, count, contents \ + ) + +/// Remove `old_count` elements from the array starting at the given `index`. At +/// the same index, insert `new_count` new elements, reading their values from the +/// `new_contents` pointer. +#define array_splice(self, _index, old_count, new_count, new_contents) \ + _array__splice( \ + (Array *)(self), array_elem_size(self), _index, \ + old_count, new_count, new_contents \ + ) + +/// Insert one `element` into the array at the given `index`. +#define array_insert(self, _index, element) \ + _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element)) + +/// Remove one element from the array at the given `index`. +#define array_erase(self, _index) \ + _array__erase((Array *)(self), array_elem_size(self), _index) + +/// Pop the last element off the array, returning the element by value. +#define array_pop(self) ((self)->contents[--(self)->size]) + +/// Assign the contents of one array to another, reallocating if necessary. +#define array_assign(self, other) \ + _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self)) + +/// Swap one array with another +#define array_swap(self, other) \ + _array__swap((Array *)(self), (Array *)(other)) + +/// Get the size of the array contents +#define array_elem_size(self) (sizeof *(self)->contents) + +/// Search a sorted array for a given `needle` value, using the given `compare` +/// callback to determine the order. +/// +/// If an existing element is found to be equal to `needle`, then the `index` +/// out-parameter is set to the existing value's index, and the `exists` +/// out-parameter is set to true. Otherwise, `index` is set to an index where +/// `needle` should be inserted in order to preserve the sorting, and `exists` +/// is set to false. +#define array_search_sorted_with(self, compare, needle, _index, _exists) \ + _array__search_sorted(self, 0, compare, , needle, _index, _exists) + +/// Search a sorted array for a given `needle` value, using integer comparisons +/// of a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_with`. +#define array_search_sorted_by(self, field, needle, _index, _exists) \ + _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists) + +/// Insert a given `value` into a sorted array, using the given `compare` +/// callback to determine the order. +#define array_insert_sorted_with(self, compare, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_with(self, compare, &(value), &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +/// Insert a given `value` into a sorted array, using integer comparisons of +/// a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_by`. +#define array_insert_sorted_by(self, field, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_by(self, field, (value) field, &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +// Private + +typedef Array(void) Array; + +/// This is not what you're looking for, see `array_delete`. +static inline void _array__delete(Array *self) { + if (self->contents) { + ts_free(self->contents); + self->contents = NULL; + self->size = 0; + self->capacity = 0; + } +} + +/// This is not what you're looking for, see `array_erase`. +static inline void _array__erase(Array *self, size_t element_size, + uint32_t index) { + assert(index < self->size); + char *contents = (char *)self->contents; + memmove(contents + index * element_size, contents + (index + 1) * element_size, + (self->size - index - 1) * element_size); + self->size--; +} + +/// This is not what you're looking for, see `array_reserve`. +static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) { + if (new_capacity > self->capacity) { + if (self->contents) { + self->contents = ts_realloc(self->contents, new_capacity * element_size); + } else { + self->contents = ts_malloc(new_capacity * element_size); + } + self->capacity = new_capacity; + } +} + +/// This is not what you're looking for, see `array_assign`. +static inline void _array__assign(Array *self, const Array *other, size_t element_size) { + _array__reserve(self, element_size, other->size); + self->size = other->size; + memcpy(self->contents, other->contents, self->size * element_size); +} + +/// This is not what you're looking for, see `array_swap`. +static inline void _array__swap(Array *self, Array *other) { + Array swap = *other; + *other = *self; + *self = swap; +} + +/// This is not what you're looking for, see `array_push` or `array_grow_by`. +static inline void _array__grow(Array *self, uint32_t count, size_t element_size) { + uint32_t new_size = self->size + count; + if (new_size > self->capacity) { + uint32_t new_capacity = self->capacity * 2; + if (new_capacity < 8) new_capacity = 8; + if (new_capacity < new_size) new_capacity = new_size; + _array__reserve(self, element_size, new_capacity); + } +} + +/// This is not what you're looking for, see `array_splice`. +static inline void _array__splice(Array *self, size_t element_size, + uint32_t index, uint32_t old_count, + uint32_t new_count, const void *elements) { + uint32_t new_size = self->size + new_count - old_count; + uint32_t old_end = index + old_count; + uint32_t new_end = index + new_count; + assert(old_end <= self->size); + + _array__reserve(self, element_size, new_size); + + char *contents = (char *)self->contents; + if (self->size > old_end) { + memmove( + contents + new_end * element_size, + contents + old_end * element_size, + (self->size - old_end) * element_size + ); + } + if (new_count > 0) { + if (elements) { + memcpy( + (contents + index * element_size), + elements, + new_count * element_size + ); + } else { + memset( + (contents + index * element_size), + 0, + new_count * element_size + ); + } + } + self->size += new_count - old_count; +} + +/// A binary search routine, based on Rust's `std::slice::binary_search_by`. +/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`. +#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \ + do { \ + *(_index) = start; \ + *(_exists) = false; \ + uint32_t size = (self)->size - *(_index); \ + if (size == 0) break; \ + int comparison; \ + while (size > 1) { \ + uint32_t half_size = size / 2; \ + uint32_t mid_index = *(_index) + half_size; \ + comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \ + if (comparison <= 0) *(_index) = mid_index; \ + size -= half_size; \ + } \ + comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \ + if (comparison == 0) *(_exists) = true; \ + else if (comparison < 0) *(_index) += 1; \ + } while (0) + +/// Helper macro for the `_sorted_by` routines below. This takes the left (existing) +/// parameter by reference in order to work with the generic sorting function above. +#define _compare_int(a, b) ((int)*(a) - (int)(b)) + +#ifdef _MSC_VER +#pragma warning(pop) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ARRAY_H_ diff --git a/src/tree_sitter/parser.h b/src/tree_sitter/parser.h new file mode 100644 index 0000000..858107d --- /dev/null +++ b/src/tree_sitter/parser.h @@ -0,0 +1,286 @@ +#ifndef TREE_SITTER_PARSER_H_ +#define TREE_SITTER_PARSER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +#define ts_builtin_sym_error ((TSSymbol)-1) +#define ts_builtin_sym_end 0 +#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 + +#ifndef TREE_SITTER_API_H_ +typedef uint16_t TSStateId; +typedef uint16_t TSSymbol; +typedef uint16_t TSFieldId; +typedef struct TSLanguage TSLanguage; +typedef struct TSLanguageMetadata { + uint8_t major_version; + uint8_t minor_version; + uint8_t patch_version; +} TSLanguageMetadata; +#endif + +typedef struct { + TSFieldId field_id; + uint8_t child_index; + bool inherited; +} TSFieldMapEntry; + +// Used to index the field and supertype maps. +typedef struct { + uint16_t index; + uint16_t length; +} TSMapSlice; + +typedef struct { + bool visible; + bool named; + bool supertype; +} TSSymbolMetadata; + +typedef struct TSLexer TSLexer; + +struct TSLexer { + int32_t lookahead; + TSSymbol result_symbol; + void (*advance)(TSLexer *, bool); + void (*mark_end)(TSLexer *); + uint32_t (*get_column)(TSLexer *); + bool (*is_at_included_range_start)(const TSLexer *); + bool (*eof)(const TSLexer *); + void (*log)(const TSLexer *, const char *, ...); +}; + +typedef enum { + TSParseActionTypeShift, + TSParseActionTypeReduce, + TSParseActionTypeAccept, + TSParseActionTypeRecover, +} TSParseActionType; + +typedef union { + struct { + uint8_t type; + TSStateId state; + bool extra; + bool repetition; + } shift; + struct { + uint8_t type; + uint8_t child_count; + TSSymbol symbol; + int16_t dynamic_precedence; + uint16_t production_id; + } reduce; + uint8_t type; +} TSParseAction; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; +} TSLexMode; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; + uint16_t reserved_word_set_id; +} TSLexerMode; + +typedef union { + TSParseAction action; + struct { + uint8_t count; + bool reusable; + } entry; +} TSParseActionEntry; + +typedef struct { + int32_t start; + int32_t end; +} TSCharacterRange; + +struct TSLanguage { + uint32_t abi_version; + uint32_t symbol_count; + uint32_t alias_count; + uint32_t token_count; + uint32_t external_token_count; + uint32_t state_count; + uint32_t large_state_count; + uint32_t production_id_count; + uint32_t field_count; + uint16_t max_alias_sequence_length; + const uint16_t *parse_table; + const uint16_t *small_parse_table; + const uint32_t *small_parse_table_map; + const TSParseActionEntry *parse_actions; + const char * const *symbol_names; + const char * const *field_names; + const TSMapSlice *field_map_slices; + const TSFieldMapEntry *field_map_entries; + const TSSymbolMetadata *symbol_metadata; + const TSSymbol *public_symbol_map; + const uint16_t *alias_map; + const TSSymbol *alias_sequences; + const TSLexerMode *lex_modes; + bool (*lex_fn)(TSLexer *, TSStateId); + bool (*keyword_lex_fn)(TSLexer *, TSStateId); + TSSymbol keyword_capture_token; + struct { + const bool *states; + const TSSymbol *symbol_map; + void *(*create)(void); + void (*destroy)(void *); + bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); + unsigned (*serialize)(void *, char *); + void (*deserialize)(void *, const char *, unsigned); + } external_scanner; + const TSStateId *primary_state_ids; + const char *name; + const TSSymbol *reserved_words; + uint16_t max_reserved_word_set_size; + uint32_t supertype_count; + const TSSymbol *supertype_symbols; + const TSMapSlice *supertype_map_slices; + const TSSymbol *supertype_map_entries; + TSLanguageMetadata metadata; +}; + +static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) { + uint32_t index = 0; + uint32_t size = len - index; + while (size > 1) { + uint32_t half_size = size / 2; + uint32_t mid_index = index + half_size; + const TSCharacterRange *range = &ranges[mid_index]; + if (lookahead >= range->start && lookahead <= range->end) { + return true; + } else if (lookahead > range->end) { + index = mid_index; + } + size -= half_size; + } + const TSCharacterRange *range = &ranges[index]; + return (lookahead >= range->start && lookahead <= range->end); +} + +/* + * Lexer Macros + */ + +#ifdef _MSC_VER +#define UNUSED __pragma(warning(suppress : 4101)) +#else +#define UNUSED __attribute__((unused)) +#endif + +#define START_LEXER() \ + bool result = false; \ + bool skip = false; \ + UNUSED \ + bool eof = false; \ + int32_t lookahead; \ + goto start; \ + next_state: \ + lexer->advance(lexer, skip); \ + start: \ + skip = false; \ + lookahead = lexer->lookahead; + +#define ADVANCE(state_value) \ + { \ + state = state_value; \ + goto next_state; \ + } + +#define ADVANCE_MAP(...) \ + { \ + static const uint16_t map[] = { __VA_ARGS__ }; \ + for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) { \ + if (map[i] == lookahead) { \ + state = map[i + 1]; \ + goto next_state; \ + } \ + } \ + } + +#define SKIP(state_value) \ + { \ + skip = true; \ + state = state_value; \ + goto next_state; \ + } + +#define ACCEPT_TOKEN(symbol_value) \ + result = true; \ + lexer->result_symbol = symbol_value; \ + lexer->mark_end(lexer); + +#define END_STATE() return result; + +/* + * Parse Table Macros + */ + +#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT) + +#define STATE(id) id + +#define ACTIONS(id) id + +#define SHIFT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value) \ + } \ + }} + +#define SHIFT_REPEAT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value), \ + .repetition = true \ + } \ + }} + +#define SHIFT_EXTRA() \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .extra = true \ + } \ + }} + +#define REDUCE(symbol_name, children, precedence, prod_id) \ + {{ \ + .reduce = { \ + .type = TSParseActionTypeReduce, \ + .symbol = symbol_name, \ + .child_count = children, \ + .dynamic_precedence = precedence, \ + .production_id = prod_id \ + }, \ + }} + +#define RECOVER() \ + {{ \ + .type = TSParseActionTypeRecover \ + }} + +#define ACCEPT_INPUT() \ + {{ \ + .type = TSParseActionTypeAccept \ + }} + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_PARSER_H_