feat(kernel): R7b Lua+Luau walker — one lua module, vendored-grammar-C lua v0.4.1, tree-sitter-luau 1.2.0 pin, both default-routed (#1384)

R7b batch 4 #2 (docs/design/lua-luau-kernel-port-checklist.md is the
authoritative quirk list). ONE walker for both dialects (ccpp precedent) —
the differences are exactly four: luau's type_definition aliases, the
`export `-slice isExported hook, the return-type signature suffix, and the
grammar handle.

Grammar prep is kernel-side only, no wasm change: lua is the SECOND
vendored-grammar-C language (the vendored wasm is the v0.4.1 tag, a revision
not on crates.io — tag artifacts compiled via build.rs, shas pinned); luau
is a plain crate pin =1.2.0 whose tarball is sha-identical to the tag (the
swift tag≠crate divergence does not recur). Grammar-parity rows replace the
bump gate entirely.

Preserved bug-for-bug (all probe-pinned): the require/visitNode-hook
ASYMMETRIES (top-level requires — including inside top-level if/for/while —
mint import nodes while the identical body-level statement emits
`calls "require"`; top-level `local x = foo()` initializers are invisible
while global `x = foo()` calls emit), the BFS string-win inside require args
(`require(script:WaitForChild("Kid"))` → import Kid) and Roblox instance
paths, receiver-QN methods (`M.sub.deep::chained`, `_G::installed`,
stack-QN nested globals like `render::leakedGlobal`), the raw-text callee
world (colon forms with `self` never stripped, bracket callees,
newline-glued chains byte-verbatim, the `(handler)` paren-conversion),
LUA_SPEC function-as-value capture with the `M.cb = cb` param-storage skip
and first-occurrence dedupe, LuaDoc `---` keeping a leading `- ` plus
`--!strict` joining docstring chains (block-comment docstrings keep interior
CRLF bytes), variable nodes at the IDENTIFIER with positional value pairing,
duplicate same-(kind,name,line) ids, and the lua↔luau isExported wire
divergence (lua functions: flag absent; luau functions: present-false;
methods: absent in both; variables: present-false in both; `export type`:
true).

Gates: parity sweeps first-run 0-diff on kong/lazy.nvim/lua-resty-core
(lua) + lune/Fusion (luau) — 1,734 clean files byte-parity, deferrals
1/0/0/3/8 matching the survey's both-arm predictions exactly (kong's 1 = a
deliberately invalid fixture; luau's = grammar-inherent generic type packs
and default type params); full-init dumps byte-identical kernel-vs-wasm ×4
(kong 157,650 dump lines); kernel-lua-parity suite (both torture fixtures +
in-memory CRLF variants + glue-chain, duplicate-id, and cross-dialect defer
pins + kernel-arm wire-flag pins); full suite 2,647 green ×2 with
CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += lua, luau (18 langs).

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

CHANGELOG.md

@@ -11,7 +11,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### New Features
 
-- Indexing TypeScript, TSX, JavaScript, JSX, Java, Python, Go, C, C++, Rust, C#, Ruby, PHP, Swift, Kotlin, and R projects is faster: parsing and symbol extraction now run in a native engine when a prebuilt binary is available for your platform (release bundles include one), producing exactly the same graph — verified byte-for-byte against the previous engine on real repositories, from small libraries up to vscode-, dubbo-, django-, git-, protobuf-, tokio-, rust-analyzer-, jellyfin-, rails-, symfony-, swift-nio-, kotlinx.coroutines-, and ggplot2-scale codebases (Lombok-generated members, C function-pointer tables, and Unreal-Engine-style macro-heavy headers included; CUDA and Metal sources ride the C++ path). The speedup is largest on resource-constrained machines like CI runners. No setup needed: platforms without the native binary, and individual files with syntax errors, automatically use the previous engine, and `CODEGRAPH_KERNEL=0` turns the native path off entirely.
+- Indexing TypeScript, TSX, JavaScript, JSX, Java, Python, Go, C, C++, Rust, C#, Ruby, PHP, Swift, Kotlin, R, Lua, and Luau projects is faster: parsing and symbol extraction now run in a native engine when a prebuilt binary is available for your platform (release bundles include one), producing exactly the same graph — verified byte-for-byte against the previous engine on real repositories, from small libraries up to vscode-, dubbo-, django-, git-, protobuf-, tokio-, rust-analyzer-, jellyfin-, rails-, symfony-, swift-nio-, kotlinx.coroutines-, ggplot2-, and Kong-scale codebases (Lombok-generated members, C function-pointer tables, and Unreal-Engine-style macro-heavy headers included; CUDA and Metal sources ride the C++ path). The speedup is largest on resource-constrained machines like CI runners. No setup needed: platforms without the native binary, and individual files with syntax errors, automatically use the previous engine, and `CODEGRAPH_KERNEL=0` turns the native path off entirely.
 - Reference resolution now runs in parallel on large projects. When a project has enough pending references to make it worthwhile (roughly 150k+, typical for big Java/Kotlin/Spring codebases), resolution fans out across worker threads while results are applied in the exact order the single-threaded path would have used — the graph comes out byte-for-byte identical, about twice as fast end-to-end on a 4,000-file Java project in our testing. Small projects keep the single-threaded path automatically (the fan-out costs more than it saves there). Set `CODEGRAPH_NO_PARALLEL_RESOLVE=1` to disable, or `CODEGRAPH_PARALLEL_RESOLVE_MIN=<count>` to tune when it engages.
 - Indexing large projects got another sizeable speedup — about a quarter less wall-clock on the same 4,000-file Java project, with the graph still byte-for-byte identical. Two changes: the database no longer interleaves expensive checkpoint housekeeping into the middle of resolution on a fresh index (it's folded once at the end instead), and while one batch's results are being written out, the worker threads are already resolving the next batch instead of sitting idle.
 - The dynamic-dispatch analysis that runs at the end of indexing (callback, event, and framework wiring) now runs its passes in parallel on large projects, cutting that stage roughly in half there — and a pass that crashes now retries safely instead of failing the whole index, which also makes very large codebases that previously died in this stage more likely to index to completion. Graphs remain byte-for-byte identical.

__tests__/fixtures/kernel-parity/torture.lua

@@ -0,0 +1,99 @@
+#!/usr/bin/env lua
+-- File-header comment run line 1
+-- line 2 of the run
+local core = require("app.core")
+local Signal = require(script.Parent.Signal)
+local quoted = require 'app.quoted'
+local bracketed = require [[app.bracketed]]
+local viaChild = require(script:WaitForChild("Child"))
+local accessed = require("app.acc").field
+local dyn = require(dynName)
+local twoA, twoB = require("two.a"), require("two.b")
+local okG, guarded = pcall(require, "app.guarded")
+
+--- LuaDoc summary for topFn.
+-- @param a number
+-- @return number
+function topFn(a)
+	return a + 1
+end
+
+--[[ Block comment doc
+spanning two lines ]]
+local function localFn(...)
+	return select("#", ...)
+end
+
+-- doc for anonAssigned (variable, initializer invisible)
+local anonAssigned = function(v)
+	return hidden(v)
+end
+
+local M = {}
+local UPPER_CONST = 42
+
+function M.create(n)
+	local inst = { n = n }
+	return setmetatable(inst, { __index = M })
+end
+
+function M:render(opts)
+	local lazy = require("app.lazy")
+	self.count = (self.count or 0) + 1
+	self:helperMethod(opts)
+	self.field.deep(1)
+	M.create(2)
+	M.registry[key](3)
+	core.util.log("msg")
+	core.run(M.create)
+	local function inner()
+		return topFn(9)
+	end
+	function M.attached(q)
+		return q
+	end
+	function leakedGlobal()
+	end
+	return inner()
+end
+
+function M.sub.deep:chained(x)
+	return x
+end
+
+function _G.installed()
+end
+
+M.assigned = function(z)
+	return topFn(z)
+end
+
+M.handlers = { on_start = topFn, on_stop = localFn, skipped = missing }
+local tbl = { cb = topFn, [1] = localFn, nested = { deep_cb = topFn } }
+
+globalAssign = topFn(10)
+M.cb = cb
+
+topFn(11)
+M.create(12)
+M:render({})
+M.sub.deep:chained(13)
+core.util.log("direct")
+t2[k2](14)
+f2()(15)
+
+function paren_conv()
+	(handler)(16)
+end
+
+local one = 1 local two = 2 print(one, two)
+
+local s1 = [[long
+string]]
+local s2 = [==[nested ]] ok]==]
+local x <const> = 99
+local préfixe = "café"
+function after_unicode() end
+do goto done end
+::done::
+return M

__tests__/fixtures/kernel-parity/torture.luau

@@ -0,0 +1,61 @@
+--!strict
+-- header comment for torture.luau
+local core = require("app.core")
+local Signal = require(script.Parent.Signal)
+
+-- doc for Point
+type Point = { x: number, y: number }
+--- doc for exported Handler
+export type Handler = (msg: string) -> ()
+export type Generic<T> = { value: T }
+type FromTypeof = typeof(require(script.Parent.Config))
+
+--- doc for typedTop
+function typedTop(a: number, b: string?): boolean
+	return a > 0 and b ~= nil
+end
+
+function genericFn<T>(v: T): T
+	return v
+end
+
+function multiRet(): (number, string)
+	return 1, "x"
+end
+
+local function emptyOneLiner() end
+
+local M = {}
+local CONST_N = 7
+
+function M.make(n: number): Point
+	return { x = n, y = n }
+end
+
+function M:update(p: Point, cb: Handler)
+	type BodyLocal = { z: number }
+	local Config = require(script.Parent.Config)
+	local msg = `point {p.x} of {Config.total()}`
+	cb(msg)
+	self:redraw()
+	self.canvas.flush()
+	M.make(3)
+	local v = if p.x > 0 then bump() else drop()
+	v += grow()
+	local narrowed = p :: any
+	for i = 1, 10 do
+		if i % 2 == 0 then
+			continue
+		end
+	end
+end
+
+M.registry = { on_make = M.make, plain = typedTop }
+
+typedTop(1, "s")
+M.make(2)
+M:update({ x = 1, y = 2 }, print)
+
+local préfixe = "café"
+function after_unicode() end
+return M

__tests__/kernel-grammar-parity.test.ts

@@ -36,7 +36,7 @@ const kernelBuilt = fs.existsSync(KERNEL_PATH);
 
 // Every kernel-capable language. `jsx` shares the javascript grammar on BOTH
 // paths (langs.rs mirrors WASM_GRAMMAR_FILES), so the distinct grammars are:
-const GRAMMAR_LANGUAGES: Language[] = ['typescript', 'tsx', 'javascript', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php', 'swift', 'kotlin', 'r'];
+const GRAMMAR_LANGUAGES: Language[] = ['typescript', 'tsx', 'javascript', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php', 'swift', 'kotlin', 'r', 'lua', 'luau'];
 
 describe.skipIf(!kernelBuilt)('kernel↔wasm grammar parity', () => {
   beforeAll(async () => {

__tests__/kernel-lua-parity.test.ts

@@ -0,0 +1,203 @@
+/**
+ * Kernel↔wasm Lua + Luau extraction parity (R7b batch 4 of the kernel
+ * migration).
+ *
+ * Asserts the native walker (codegraph-kernel/src/lua.rs — one module, two
+ * dialects) produces the SAME ExtractionResult as the wasm
+ * TreeSitterExtractor — nodes, edges, and unresolved refs compared as
+ * canonicalized multisets — over the checked-in torture fixtures
+ * (torture.lua: the require quintet incl. Roblox instance paths, the
+ * BFS-string-win and .field/dynamic silences, receiver-QN methods
+ * `M.sub.deep::chained` and `_G::installed`, the top-level
+ * local-vs-global initializer-visibility inversion, body-level
+ * `calls "require"`, table fn-ref registries with dedupe and the
+ * `M.cb = cb` param-storage skip, the raw-text callee zoo with colon/
+ * bracket/call-result callees and the `(handler)` conversion, LuaDoc
+ * `- `-keeping docstrings, `<const>` attributes, one-line duplicate-id
+ * declarations; torture.luau: `--!strict` docstring joining, `export type`
+ * isExported, verbatim `Generic<T>` alias names, the typeof(require(...))
+ * alias+import pair, typed signatures with return suffixes, interpolation/
+ * if-expression/compound-assign call shapes) and their CRLF variants
+ * (derived in-memory — #1329, pinning the block-comment `\r\n` docstring
+ * byte), plus glue-chain and defer pins.
+ *
+ * The full-repo sweeps live in scripts/kernel-parity.mjs (kong/lazy.nvim/
+ * lua-resty-core + lune/Fusion for the §5 gate); this suite keeps the
+ * invariant alive in `npm test`. Skips when no kernel binary is staged;
+ * CODEGRAPH_KERNEL_EXPECT=1 turns that into a failure.
+ */
+
+import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { extractFromSource } from '../src/extraction';
+import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
+import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
+import type { ExtractionResult, Language } from '../src/types';
+
+const KERNEL_PATH = path.join(
+  __dirname,
+  '..',
+  'codegraph-kernel',
+  'prebuilds',
+  `${process.platform}-${process.arch}`,
+  'codegraph-kernel.node'
+);
+const kernelBuilt = fs.existsSync(KERNEL_PATH);
+
+const FIXTURE_DIR = path.join(__dirname, 'fixtures', 'kernel-parity');
+
+function canon(result: ExtractionResult): { nodes: string[]; edges: string[]; refs: string[] } {
+  return {
+    nodes: result.nodes
+      .map(({ updatedAt: _u, ...n }) => JSON.stringify(n, Object.keys(n).sort()))
+      .sort(),
+    edges: result.edges.map((e) => JSON.stringify(e, Object.keys(e).sort())).sort(),
+    refs: result.unresolvedReferences
+      .map((r) => JSON.stringify(r, Object.keys(r).sort()))
+      .sort(),
+  };
+}
+
+const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
+let savedEnv: Record<string, string | undefined>;
+
+describe.skipIf(!kernelBuilt)('kernel Lua/Luau extraction parity', () => {
+  beforeAll(async () => {
+    await initGrammars();
+    await loadGrammarsForLanguages(['lua', 'luau']);
+  });
+
+  beforeEach(() => {
+    savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    resetKernelForTests();
+  });
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (savedEnv[k] === undefined) delete process.env[k];
+      else process.env[k] = savedEnv[k];
+    }
+    resetKernelForTests();
+  });
+
+  function assertParity(
+    filePath: string,
+    source: string,
+    lang: Language,
+    minNodes = 3
+  ): ExtractionResult {
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    delete process.env.CODEGRAPH_KERNEL;
+    const viaKernel = tryKernelExtract(filePath, source, lang);
+    expect(viaKernel, `kernel extraction failed for ${filePath}`).not.toBeNull();
+
+    process.env.CODEGRAPH_KERNEL = '0';
+    const viaWasm = extractFromSource(filePath, source, lang);
+    delete process.env.CODEGRAPH_KERNEL;
+
+    const k = canon(viaKernel!);
+    const w = canon(viaWasm);
+    expect(k.nodes, `${filePath}: nodes`).toEqual(w.nodes);
+    expect(k.edges, `${filePath}: edges`).toEqual(w.edges);
+    expect(k.refs, `${filePath}: refs`).toEqual(w.refs);
+    expect(viaWasm.nodes.length).toBeGreaterThanOrEqual(minNodes);
+    return viaKernel!;
+  }
+
+  it('torture.lua: requires, receiver QNs, visibility inversion, callee zoo, fn-refs', () => {
+    const file = path.join(FIXTURE_DIR, 'torture.lua');
+    const result = assertParity('fixtures/torture.lua', fs.readFileSync(file, 'utf8'), 'lua', 20);
+
+    // Kernel-arm pins so both arms drifting together can't silently lose the
+    // dialect-defining quirks (checklist §Require hook / §extractCall):
+    const refs = result.unresolvedReferences;
+    // Top-level requires became imports; the body-level require is a CALL.
+    expect(result.nodes.some((n) => n.kind === 'import' && n.name === 'app.core')).toBe(true);
+    expect(refs.some((r) => r.referenceKind === 'calls' && r.referenceName === 'require')).toBe(
+      true
+    );
+    // Roblox instance path → trailing segment; string-win beats the path.
+    expect(result.nodes.some((n) => n.kind === 'import' && n.name === 'Signal')).toBe(true);
+    expect(result.nodes.some((n) => n.kind === 'import' && n.name === 'Child')).toBe(true);
+    // Colon callees keep the colon, self never stripped.
+    expect(refs.some((r) => r.referenceName === 'self:helperMethod')).toBe(true);
+    // Receiver-qualified method QNs are verbatim dotted receivers.
+    expect(result.nodes.some((n) => n.kind === 'method' && n.qualifiedName === 'M.sub.deep::chained')).toBe(true);
+    // lua functions carry NO isExported (undefined — not false).
+    const fn = result.nodes.find((n) => n.kind === 'function' && n.name === 'topFn');
+    expect(fn?.isExported).toBeUndefined();
+    // variables DO carry isExported === false.
+    const v = result.nodes.find((n) => n.kind === 'variable' && n.name === 'core');
+    expect(v?.isExported).toBe(false);
+  });
+
+  it('torture.lua CRLF parity (block-comment docstrings keep interior \\r\\n)', () => {
+    const file = path.join(FIXTURE_DIR, 'torture.lua');
+    const crlf = fs.readFileSync(file, 'utf8').replace(/(?<!\r)\n/g, '\r\n');
+    assertParity('fixtures/torture.lua (crlf)', crlf, 'lua', 20);
+  });
+
+  it('torture.luau: type aliases, export flags, typed signatures, typeof-require', () => {
+    const file = path.join(FIXTURE_DIR, 'torture.luau');
+    const result = assertParity(
+      'fixtures/torture.luau',
+      fs.readFileSync(file, 'utf8'),
+      'luau',
+      10
+    );
+
+    // luau functions carry isExported === false (present bit); methods stay
+    // undefined — the one lua↔luau node-payload flag divergence.
+    const fn = result.nodes.find((n) => n.kind === 'function' && n.isExported === false);
+    expect(fn).toBeTruthy();
+    const method = result.nodes.find((n) => n.kind === 'method');
+    if (method) expect(method.isExported).toBeUndefined();
+    // export type → isExported true.
+    expect(result.nodes.some((n) => n.kind === 'type_alias' && n.isExported === true)).toBe(true);
+  });
+
+  it('torture.luau CRLF parity', () => {
+    const file = path.join(FIXTURE_DIR, 'torture.luau');
+    const crlf = fs.readFileSync(file, 'utf8').replace(/(?<!\r)\n/g, '\r\n');
+    assertParity('fixtures/torture.luau (crlf)', crlf, 'luau', 10);
+  });
+
+  it('newline-glue chains emit byte-verbatim multi-link refs', () => {
+    // Lua's statement ambiguity: a call statement followed by a line starting
+    // `(` parses as ONE glued chain — the middle links' "callees" are whole
+    // inner function_call texts, embedded newline/tab included.
+    const glued = 'local helper = require("app.helper")\nfunction M:go(obj)\n\tobj:foo():bar()\n\t(helper)(4)\nend\n';
+    const result = assertParity('fixtures/glue.lua', glued, 'lua', 3);
+    const names = result.unresolvedReferences
+      .filter((r) => r.referenceKind === 'calls')
+      .map((r) => r.referenceName);
+    expect(names).toContain('obj:foo():bar()\n\t(helper)');
+    expect(names).toContain('obj:foo():bar()');
+    expect(names).toContain('obj:foo():bar');
+    expect(names).toContain('obj:foo');
+  });
+
+  it('one-line duplicate declarations emit duplicate-id rows verbatim', () => {
+    const src = 'local x = 1; local x = 2\n';
+    const result = assertParity('fixtures/dup.lua', src, 'lua', 2);
+    const xs = result.nodes.filter((n) => n.kind === 'variable' && n.name === 'x');
+    expect(xs).toHaveLength(2);
+    expect(xs[0]!.id).toBe(xs[1]!.id);
+  });
+
+  it('cross-dialect syntax defers to the wasm extractor', () => {
+    // Luau syntax in a .lua file and a luau default type parameter both
+    // ERROR (grammar-inherent, both-arm) — the kernel defers per-file.
+    process.env.CODEGRAPH_KERNEL_LANGS = 'all';
+    delete process.env.CODEGRAPH_KERNEL;
+    expect(tryKernelExtract('src/compound.lua', 'x += 1\n', 'lua')).toBeNull();
+    expect(
+      tryKernelExtract('src/defaultparam.luau', 'type S<T = U> = {}\n', 'luau')
+    ).toBeNull();
+    process.env.CODEGRAPH_KERNEL = '0';
+    const viaWasm = extractFromSource('src/compound.lua', 'x += 1\n', 'lua');
+    delete process.env.CODEGRAPH_KERNEL;
+    expect(viaWasm.nodes.some((n) => n.kind === 'file')).toBe(true);
+  });
+});

codegraph-kernel/Cargo.lock

@@ -60,6 +60,7 @@ dependencies = [
  "tree-sitter-java",
  "tree-sitter-javascript",
  "tree-sitter-language",
+ "tree-sitter-luau",
  "tree-sitter-php",
  "tree-sitter-python",
  "tree-sitter-r",
@@ -558,6 +559,16 @@ version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "009994f150cc0cd50ff54917d5bc8bffe8cad10ca10d81c34da2ec421ae61782"
 
+[[package]]
+name = "tree-sitter-luau"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "871abeb427d719788bb38094facd7ff082908ef2b93c1d3d6a5f6025330120f4"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
+
 [[package]]
 name = "tree-sitter-php"
 version = "0.24.2"

codegraph-kernel/Cargo.toml

@@ -52,6 +52,11 @@ tree-sitter-swift = "=0.7.3"
 # predates the ABI-15 generator) — parity asserts same-revision, not
 # same-ABI (ruby precedent). Bump crate + wasm together.
 tree-sitter-r = "=1.2.0"
+# luau: the vendored wasm IS tree-sitter-grammars v1.2.0 and this crate's
+# tarball ships parser.c/scanner.c sha-identical to the tag (8f25bc17… /
+# a157bb52… — lua-luau checklist §Grammar prep). ABI 14. Lua itself is
+# vendored C (build.rs) — its v0.4.1 revision is not on crates.io.
+tree-sitter-luau = "=1.2.0"
 
 # tree-sitter-language: the version-agnostic LanguageFn shim for the vendored
 # kotlin grammar C (see build.rs — no kotlin crate dep is possible).

codegraph-kernel/build.rs

@@ -20,4 +20,23 @@ fn main() {
     c.flag_if_supported("-utf-8"); // msvc
     c.compile("tree-sitter-kotlin");
     println!("cargo:rerun-if-changed=grammars/kotlin");
+
+    // Lua grammar — vendored C (second vendored-grammar-C language): the
+    // vendored wasm is tree-sitter-grammars/tree-sitter-lua v0.4.1 (tag
+    // 816840c592), which is NOT on crates.io (only 0.1/0.2/0.5 exist; 0.5.0
+    // adds Lua-5.5 `global` — a future bump with its own gate). Sources are
+    // the v0.4.1 tag's checked-in generated artifacts, sha-recorded in the
+    // lua-luau checklist §Grammar prep:
+    //   parser.c  b34a362e43f0311f405721f3089e94f97f31da403b154d456d093e64609a4081
+    //   scanner.c 35bbd630b5a7421d46d2e91185eeea09bf78565d44cb676b63ca20d0f1b54bbd
+    let mut lua = cc::Build::new();
+    lua.include("grammars/lua");
+    lua.file("grammars/lua/parser.c");
+    lua.file("grammars/lua/scanner.c");
+    lua.flag_if_supported("-Wno-unused-parameter");
+    lua.flag_if_supported("-Wno-unused-but-set-variable");
+    lua.flag_if_supported("-Wno-trigraphs");
+    lua.flag_if_supported("-utf-8"); // msvc
+    lua.compile("tree-sitter-lua");
+    println!("cargo:rerun-if-changed=grammars/lua");
 }

codegraph-kernel/grammars/lua/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Munif Tanjim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

codegraph-kernel/grammars/lua/parser.c

@@ -0,0 +1,12734 @@
+/* Automatically @generated by tree-sitter */
+
+#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 262
+#define LARGE_STATE_COUNT 2
+#define SYMBOL_COUNT 137
+#define ALIAS_COUNT 0
+#define TOKEN_COUNT 72
+#define EXTERNAL_TOKEN_COUNT 6
+#define FIELD_COUNT 22
+#define MAX_ALIAS_SEQUENCE_LENGTH 7
+#define MAX_RESERVED_WORD_SET_SIZE 0
+#define PRODUCTION_ID_COUNT 59
+#define SUPERTYPE_COUNT 4
+
+enum ts_symbol_identifiers {
+  sym_identifier = 1,
+  sym_hash_bang_line = 2,
+  anon_sym_return = 3,
+  anon_sym_SEMI = 4,
+  anon_sym_EQ = 5,
+  anon_sym_COMMA = 6,
+  anon_sym_COLON_COLON = 7,
+  sym_break_statement = 8,
+  anon_sym_goto = 9,
+  anon_sym_do = 10,
+  anon_sym_end = 11,
+  anon_sym_while = 12,
+  anon_sym_repeat = 13,
+  anon_sym_until = 14,
+  anon_sym_if = 15,
+  anon_sym_then = 16,
+  anon_sym_elseif = 17,
+  anon_sym_else = 18,
+  anon_sym_for = 19,
+  anon_sym_in = 20,
+  anon_sym_function = 21,
+  anon_sym_local = 22,
+  anon_sym_DOT = 23,
+  anon_sym_COLON = 24,
+  anon_sym_LT = 25,
+  anon_sym_GT = 26,
+  sym_nil = 27,
+  sym_false = 28,
+  sym_true = 29,
+  sym_number = 30,
+  anon_sym_DQUOTE = 31,
+  anon_sym_SQUOTE = 32,
+  aux_sym__doublequote_string_content_token1 = 33,
+  aux_sym__singlequote_string_content_token1 = 34,
+  sym_escape_sequence = 35,
+  sym_vararg_expression = 36,
+  anon_sym_LPAREN = 37,
+  anon_sym_RPAREN = 38,
+  anon_sym_LBRACK = 39,
+  anon_sym_RBRACK = 40,
+  anon_sym_LBRACE = 41,
+  anon_sym_RBRACE = 42,
+  anon_sym_or = 43,
+  anon_sym_and = 44,
+  anon_sym_LT_EQ = 45,
+  anon_sym_EQ_EQ = 46,
+  anon_sym_TILDE_EQ = 47,
+  anon_sym_GT_EQ = 48,
+  anon_sym_PIPE = 49,
+  anon_sym_TILDE = 50,
+  anon_sym_AMP = 51,
+  anon_sym_LT_LT = 52,
+  anon_sym_GT_GT = 53,
+  anon_sym_PLUS = 54,
+  anon_sym_DASH = 55,
+  anon_sym_STAR = 56,
+  anon_sym_SLASH = 57,
+  anon_sym_SLASH_SLASH = 58,
+  anon_sym_PERCENT = 59,
+  anon_sym_DOT_DOT = 60,
+  anon_sym_CARET = 61,
+  anon_sym_not = 62,
+  anon_sym_POUND = 63,
+  anon_sym_DASH_DASH = 64,
+  aux_sym_comment_token1 = 65,
+  sym__block_comment_start = 66,
+  sym__block_comment_content = 67,
+  sym__block_comment_end = 68,
+  sym__block_string_start = 69,
+  sym__block_string_content = 70,
+  sym__block_string_end = 71,
+  sym_chunk = 72,
+  sym__block = 73,
+  sym_statement = 74,
+  sym_return_statement = 75,
+  sym_empty_statement = 76,
+  sym_assignment_statement = 77,
+  sym__variable_assignment_varlist = 78,
+  sym__variable_assignment_explist = 79,
+  sym_label_statement = 80,
+  sym_goto_statement = 81,
+  sym_do_statement = 82,
+  sym_while_statement = 83,
+  sym_repeat_statement = 84,
+  sym_if_statement = 85,
+  sym_elseif_statement = 86,
+  sym_else_statement = 87,
+  sym_for_statement = 88,
+  sym_for_generic_clause = 89,
+  sym_for_numeric_clause = 90,
+  sym_declaration = 91,
+  sym_function_declaration = 92,
+  sym__local_function_declaration = 93,
+  sym__function_name = 94,
+  sym__function_name_prefix_expression = 95,
+  sym__function_name_dot_index_expression = 96,
+  sym__function_name_method_index_expression = 97,
+  sym_variable_declaration = 98,
+  sym__local_variable_assignment = 99,
+  sym__name_list = 100,
+  sym__att_name_list = 101,
+  sym__attrib = 102,
+  sym__expression_list = 103,
+  sym_expression = 104,
+  sym_string = 105,
+  sym__quote_string = 106,
+  aux_sym__doublequote_string_content = 107,
+  aux_sym__singlequote_string_content = 108,
+  sym__block_string = 109,
+  sym_function_definition = 110,
+  sym__function_body = 111,
+  sym_parameters = 112,
+  sym__parameter_list = 113,
+  sym__prefix_expression = 114,
+  sym_variable = 115,
+  sym_bracket_index_expression = 116,
+  sym_dot_index_expression = 117,
+  sym_function_call = 118,
+  sym_method_index_expression = 119,
+  sym_arguments = 120,
+  sym_parenthesized_expression = 121,
+  sym_table_constructor = 122,
+  sym__field_list = 123,
+  sym__field_sep = 124,
+  sym_field = 125,
+  sym_binary_expression = 126,
+  sym_unary_expression = 127,
+  sym_comment = 128,
+  aux_sym_chunk_repeat1 = 129,
+  aux_sym__variable_assignment_varlist_repeat1 = 130,
+  aux_sym__variable_assignment_explist_repeat1 = 131,
+  aux_sym_if_statement_repeat1 = 132,
+  aux_sym__name_list_repeat1 = 133,
+  aux_sym__att_name_list_repeat1 = 134,
+  aux_sym__expression_list_repeat1 = 135,
+  aux_sym__field_list_repeat1 = 136,
+};
+
+static const char * const ts_symbol_names[] = {
+  [ts_builtin_sym_end] = "end",
+  [sym_identifier] = "identifier",
+  [sym_hash_bang_line] = "hash_bang_line",
+  [anon_sym_return] = "return",
+  [anon_sym_SEMI] = ";",
+  [anon_sym_EQ] = "=",
+  [anon_sym_COMMA] = ",",
+  [anon_sym_COLON_COLON] = "::",
+  [sym_break_statement] = "break_statement",
+  [anon_sym_goto] = "goto",
+  [anon_sym_do] = "do",
+  [anon_sym_end] = "end",
+  [anon_sym_while] = "while",
+  [anon_sym_repeat] = "repeat",
+  [anon_sym_until] = "until",
+  [anon_sym_if] = "if",
+  [anon_sym_then] = "then",
+  [anon_sym_elseif] = "elseif",
+  [anon_sym_else] = "else",
+  [anon_sym_for] = "for",
+  [anon_sym_in] = "in",
+  [anon_sym_function] = "function",
+  [anon_sym_local] = "local",
+  [anon_sym_DOT] = ".",
+  [anon_sym_COLON] = ":",
+  [anon_sym_LT] = "<",
+  [anon_sym_GT] = ">",
+  [sym_nil] = "nil",
+  [sym_false] = "false",
+  [sym_true] = "true",
+  [sym_number] = "number",
+  [anon_sym_DQUOTE] = "\"",
+  [anon_sym_SQUOTE] = "'",
+  [aux_sym__doublequote_string_content_token1] = "_doublequote_string_content_token1",
+  [aux_sym__singlequote_string_content_token1] = "_singlequote_string_content_token1",
+  [sym_escape_sequence] = "escape_sequence",
+  [sym_vararg_expression] = "vararg_expression",
+  [anon_sym_LPAREN] = "(",
+  [anon_sym_RPAREN] = ")",
+  [anon_sym_LBRACK] = "[",
+  [anon_sym_RBRACK] = "]",
+  [anon_sym_LBRACE] = "{",
+  [anon_sym_RBRACE] = "}",
+  [anon_sym_or] = "or",
+  [anon_sym_and] = "and",
+  [anon_sym_LT_EQ] = "<=",
+  [anon_sym_EQ_EQ] = "==",
+  [anon_sym_TILDE_EQ] = "~=",
+  [anon_sym_GT_EQ] = ">=",
+  [anon_sym_PIPE] = "|",
+  [anon_sym_TILDE] = "~",
+  [anon_sym_AMP] = "&",
+  [anon_sym_LT_LT] = "<<",
+  [anon_sym_GT_GT] = ">>",
+  [anon_sym_PLUS] = "+",
+  [anon_sym_DASH] = "-",
+  [anon_sym_STAR] = "*",
+  [anon_sym_SLASH] = "/",
+  [anon_sym_SLASH_SLASH] = "//",
+  [anon_sym_PERCENT] = "%",
+  [anon_sym_DOT_DOT] = "..",
+  [anon_sym_CARET] = "^",
+  [anon_sym_not] = "not",
+  [anon_sym_POUND] = "#",
+  [anon_sym_DASH_DASH] = "--",
+  [aux_sym_comment_token1] = "comment_content",
+  [sym__block_comment_start] = "[[",
+  [sym__block_comment_content] = "comment_content",
+  [sym__block_comment_end] = "]]",
+  [sym__block_string_start] = "[[",
+  [sym__block_string_content] = "string_content",
+  [sym__block_string_end] = "]]",
+  [sym_chunk] = "chunk",
+  [sym__block] = "block",
+  [sym_statement] = "statement",
+  [sym_return_statement] = "return_statement",
+  [sym_empty_statement] = "empty_statement",
+  [sym_assignment_statement] = "assignment_statement",
+  [sym__variable_assignment_varlist] = "variable_list",
+  [sym__variable_assignment_explist] = "expression_list",
+  [sym_label_statement] = "label_statement",
+  [sym_goto_statement] = "goto_statement",
+  [sym_do_statement] = "do_statement",
+  [sym_while_statement] = "while_statement",
+  [sym_repeat_statement] = "repeat_statement",
+  [sym_if_statement] = "if_statement",
+  [sym_elseif_statement] = "elseif_statement",
+  [sym_else_statement] = "else_statement",
+  [sym_for_statement] = "for_statement",
+  [sym_for_generic_clause] = "for_generic_clause",
+  [sym_for_numeric_clause] = "for_numeric_clause",
+  [sym_declaration] = "declaration",
+  [sym_function_declaration] = "function_declaration",
+  [sym__local_function_declaration] = "function_declaration",
+  [sym__function_name] = "_function_name",
+  [sym__function_name_prefix_expression] = "_function_name_prefix_expression",
+  [sym__function_name_dot_index_expression] = "dot_index_expression",
+  [sym__function_name_method_index_expression] = "method_index_expression",
+  [sym_variable_declaration] = "variable_declaration",
+  [sym__local_variable_assignment] = "assignment_statement",
+  [sym__name_list] = "variable_list",
+  [sym__att_name_list] = "variable_list",
+  [sym__attrib] = "attribute",
+  [sym__expression_list] = "expression_list",
+  [sym_expression] = "expression",
+  [sym_string] = "string",
+  [sym__quote_string] = "_quote_string",
+  [aux_sym__doublequote_string_content] = "_doublequote_string_content",
+  [aux_sym__singlequote_string_content] = "_singlequote_string_content",
+  [sym__block_string] = "_block_string",
+  [sym_function_definition] = "function_definition",
+  [sym__function_body] = "_function_body",
+  [sym_parameters] = "parameters",
+  [sym__parameter_list] = "_parameter_list",
+  [sym__prefix_expression] = "_prefix_expression",
+  [sym_variable] = "variable",
+  [sym_bracket_index_expression] = "bracket_index_expression",
+  [sym_dot_index_expression] = "dot_index_expression",
+  [sym_function_call] = "function_call",
+  [sym_method_index_expression] = "method_index_expression",
+  [sym_arguments] = "arguments",
+  [sym_parenthesized_expression] = "parenthesized_expression",
+  [sym_table_constructor] = "table_constructor",
+  [sym__field_list] = "_field_list",
+  [sym__field_sep] = "_field_sep",
+  [sym_field] = "field",
+  [sym_binary_expression] = "binary_expression",
+  [sym_unary_expression] = "unary_expression",
+  [sym_comment] = "comment",
+  [aux_sym_chunk_repeat1] = "chunk_repeat1",
+  [aux_sym__variable_assignment_varlist_repeat1] = "_variable_assignment_varlist_repeat1",
+  [aux_sym__variable_assignment_explist_repeat1] = "_variable_assignment_explist_repeat1",
+  [aux_sym_if_statement_repeat1] = "if_statement_repeat1",
+  [aux_sym__name_list_repeat1] = "_name_list_repeat1",
+  [aux_sym__att_name_list_repeat1] = "_att_name_list_repeat1",
+  [aux_sym__expression_list_repeat1] = "_expression_list_repeat1",
+  [aux_sym__field_list_repeat1] = "_field_list_repeat1",
+};
+
+static const TSSymbol ts_symbol_map[] = {
+  [ts_builtin_sym_end] = ts_builtin_sym_end,
+  [sym_identifier] = sym_identifier,
+  [sym_hash_bang_line] = sym_hash_bang_line,
+  [anon_sym_return] = anon_sym_return,
+  [anon_sym_SEMI] = anon_sym_SEMI,
+  [anon_sym_EQ] = anon_sym_EQ,
+  [anon_sym_COMMA] = anon_sym_COMMA,
+  [anon_sym_COLON_COLON] = anon_sym_COLON_COLON,
+  [sym_break_statement] = sym_break_statement,
+  [anon_sym_goto] = anon_sym_goto,
+  [anon_sym_do] = anon_sym_do,
+  [anon_sym_end] = anon_sym_end,
+  [anon_sym_while] = anon_sym_while,
+  [anon_sym_repeat] = anon_sym_repeat,
+  [anon_sym_until] = anon_sym_until,
+  [anon_sym_if] = anon_sym_if,
+  [anon_sym_then] = anon_sym_then,
+  [anon_sym_elseif] = anon_sym_elseif,
+  [anon_sym_else] = anon_sym_else,
+  [anon_sym_for] = anon_sym_for,
+  [anon_sym_in] = anon_sym_in,
+  [anon_sym_function] = anon_sym_function,
+  [anon_sym_local] = anon_sym_local,
+  [anon_sym_DOT] = anon_sym_DOT,
+  [anon_sym_COLON] = anon_sym_COLON,
+  [anon_sym_LT] = anon_sym_LT,
+  [anon_sym_GT] = anon_sym_GT,
+  [sym_nil] = sym_nil,
+  [sym_false] = sym_false,
+  [sym_true] = sym_true,
+  [sym_number] = sym_number,
+  [anon_sym_DQUOTE] = anon_sym_DQUOTE,
+  [anon_sym_SQUOTE] = anon_sym_SQUOTE,
+  [aux_sym__doublequote_string_content_token1] = aux_sym__doublequote_string_content_token1,
+  [aux_sym__singlequote_string_content_token1] = aux_sym__singlequote_string_content_token1,
+  [sym_escape_sequence] = sym_escape_sequence,
+  [sym_vararg_expression] = sym_vararg_expression,
+  [anon_sym_LPAREN] = anon_sym_LPAREN,
+  [anon_sym_RPAREN] = anon_sym_RPAREN,
+  [anon_sym_LBRACK] = anon_sym_LBRACK,
+  [anon_sym_RBRACK] = anon_sym_RBRACK,
+  [anon_sym_LBRACE] = anon_sym_LBRACE,
+  [anon_sym_RBRACE] = anon_sym_RBRACE,
+  [anon_sym_or] = anon_sym_or,
+  [anon_sym_and] = anon_sym_and,
+  [anon_sym_LT_EQ] = anon_sym_LT_EQ,
+  [anon_sym_EQ_EQ] = anon_sym_EQ_EQ,
+  [anon_sym_TILDE_EQ] = anon_sym_TILDE_EQ,
+  [anon_sym_GT_EQ] = anon_sym_GT_EQ,
+  [anon_sym_PIPE] = anon_sym_PIPE,
+  [anon_sym_TILDE] = anon_sym_TILDE,
+  [anon_sym_AMP] = anon_sym_AMP,
+  [anon_sym_LT_LT] = anon_sym_LT_LT,
+  [anon_sym_GT_GT] = anon_sym_GT_GT,
+  [anon_sym_PLUS] = anon_sym_PLUS,
+  [anon_sym_DASH] = anon_sym_DASH,
+  [anon_sym_STAR] = anon_sym_STAR,
+  [anon_sym_SLASH] = anon_sym_SLASH,
+  [anon_sym_SLASH_SLASH] = anon_sym_SLASH_SLASH,
+  [anon_sym_PERCENT] = anon_sym_PERCENT,
+  [anon_sym_DOT_DOT] = anon_sym_DOT_DOT,
+  [anon_sym_CARET] = anon_sym_CARET,
+  [anon_sym_not] = anon_sym_not,
+  [anon_sym_POUND] = anon_sym_POUND,
+  [anon_sym_DASH_DASH] = anon_sym_DASH_DASH,
+  [aux_sym_comment_token1] = sym__block_comment_content,
+  [sym__block_comment_start] = sym__block_comment_start,
+  [sym__block_comment_content] = sym__block_comment_content,
+  [sym__block_comment_end] = sym__block_comment_end,
+  [sym__block_string_start] = sym__block_comment_start,
+  [sym__block_string_content] = sym__block_string_content,
+  [sym__block_string_end] = sym__block_comment_end,
+  [sym_chunk] = sym_chunk,
+  [sym__block] = sym__block,
+  [sym_statement] = sym_statement,
+  [sym_return_statement] = sym_return_statement,
+  [sym_empty_statement] = sym_empty_statement,
+  [sym_assignment_statement] = sym_assignment_statement,
+  [sym__variable_assignment_varlist] = sym__variable_assignment_varlist,
+  [sym__variable_assignment_explist] = sym__variable_assignment_explist,
+  [sym_label_statement] = sym_label_statement,
+  [sym_goto_statement] = sym_goto_statement,
+  [sym_do_statement] = sym_do_statement,
+  [sym_while_statement] = sym_while_statement,
+  [sym_repeat_statement] = sym_repeat_statement,
+  [sym_if_statement] = sym_if_statement,
+  [sym_elseif_statement] = sym_elseif_statement,
+  [sym_else_statement] = sym_else_statement,
+  [sym_for_statement] = sym_for_statement,
+  [sym_for_generic_clause] = sym_for_generic_clause,
+  [sym_for_numeric_clause] = sym_for_numeric_clause,
+  [sym_declaration] = sym_declaration,
+  [sym_function_declaration] = sym_function_declaration,
+  [sym__local_function_declaration] = sym_function_declaration,
+  [sym__function_name] = sym__function_name,
+  [sym__function_name_prefix_expression] = sym__function_name_prefix_expression,
+  [sym__function_name_dot_index_expression] = sym_dot_index_expression,
+  [sym__function_name_method_index_expression] = sym_method_index_expression,
+  [sym_variable_declaration] = sym_variable_declaration,
+  [sym__local_variable_assignment] = sym_assignment_statement,
+  [sym__name_list] = sym__variable_assignment_varlist,
+  [sym__att_name_list] = sym__variable_assignment_varlist,
+  [sym__attrib] = sym__attrib,
+  [sym__expression_list] = sym__variable_assignment_explist,
+  [sym_expression] = sym_expression,
+  [sym_string] = sym_string,
+  [sym__quote_string] = sym__quote_string,
+  [aux_sym__doublequote_string_content] = aux_sym__doublequote_string_content,
+  [aux_sym__singlequote_string_content] = aux_sym__singlequote_string_content,
+  [sym__block_string] = sym__block_string,
+  [sym_function_definition] = sym_function_definition,
+  [sym__function_body] = sym__function_body,
+  [sym_parameters] = sym_parameters,
+  [sym__parameter_list] = sym__parameter_list,
+  [sym__prefix_expression] = sym__prefix_expression,
+  [sym_variable] = sym_variable,
+  [sym_bracket_index_expression] = sym_bracket_index_expression,
+  [sym_dot_index_expression] = sym_dot_index_expression,
+  [sym_function_call] = sym_function_call,
+  [sym_method_index_expression] = sym_method_index_expression,
+  [sym_arguments] = sym_arguments,
+  [sym_parenthesized_expression] = sym_parenthesized_expression,
+  [sym_table_constructor] = sym_table_constructor,
+  [sym__field_list] = sym__field_list,
+  [sym__field_sep] = sym__field_sep,
+  [sym_field] = sym_field,
+  [sym_binary_expression] = sym_binary_expression,
+  [sym_unary_expression] = sym_unary_expression,
+  [sym_comment] = sym_comment,
+  [aux_sym_chunk_repeat1] = aux_sym_chunk_repeat1,
+  [aux_sym__variable_assignment_varlist_repeat1] = aux_sym__variable_assignment_varlist_repeat1,
+  [aux_sym__variable_assignment_explist_repeat1] = aux_sym__variable_assignment_explist_repeat1,
+  [aux_sym_if_statement_repeat1] = aux_sym_if_statement_repeat1,
+  [aux_sym__name_list_repeat1] = aux_sym__name_list_repeat1,
+  [aux_sym__att_name_list_repeat1] = aux_sym__att_name_list_repeat1,
+  [aux_sym__expression_list_repeat1] = aux_sym__expression_list_repeat1,
+  [aux_sym__field_list_repeat1] = aux_sym__field_list_repeat1,
+};
+
+static const TSSymbolMetadata ts_symbol_metadata[] = {
+  [ts_builtin_sym_end] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym_identifier] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_hash_bang_line] = {
+    .visible = true,
+    .named = true,
+  },
+  [anon_sym_return] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_SEMI] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_EQ] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_COMMA] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_COLON_COLON] = {
+    .visible = true,
+    .named = false,
+  },
+  [sym_break_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [anon_sym_goto] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_do] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_end] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_while] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_repeat] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_until] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_if] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_then] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_elseif] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_else] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_for] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_in] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_function] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_local] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_DOT] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_COLON] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_LT] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_GT] = {
+    .visible = true,
+    .named = false,
+  },
+  [sym_nil] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_false] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_true] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_number] = {
+    .visible = true,
+    .named = true,
+  },
+  [anon_sym_DQUOTE] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_SQUOTE] = {
+    .visible = true,
+    .named = false,
+  },
+  [aux_sym__doublequote_string_content_token1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym__singlequote_string_content_token1] = {
+    .visible = false,
+    .named = false,
+  },
+  [sym_escape_sequence] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_vararg_expression] = {
+    .visible = true,
+    .named = true,
+  },
+  [anon_sym_LPAREN] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_RPAREN] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_LBRACK] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_RBRACK] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_LBRACE] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_RBRACE] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_or] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_and] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_LT_EQ] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_EQ_EQ] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_TILDE_EQ] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_GT_EQ] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_PIPE] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_TILDE] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_AMP] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_LT_LT] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_GT_GT] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_PLUS] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_DASH] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_STAR] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_SLASH] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_SLASH_SLASH] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_PERCENT] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_DOT_DOT] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_CARET] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_not] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_POUND] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_DASH_DASH] = {
+    .visible = true,
+    .named = false,
+  },
+  [aux_sym_comment_token1] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__block_comment_start] = {
+    .visible = true,
+    .named = false,
+  },
+  [sym__block_comment_content] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__block_comment_end] = {
+    .visible = true,
+    .named = false,
+  },
+  [sym__block_string_start] = {
+    .visible = true,
+    .named = false,
+  },
+  [sym__block_string_content] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__block_string_end] = {
+    .visible = true,
+    .named = false,
+  },
+  [sym_chunk] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__block] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_statement] = {
+    .visible = false,
+    .named = true,
+    .supertype = true,
+  },
+  [sym_return_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_empty_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_assignment_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__variable_assignment_varlist] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__variable_assignment_explist] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_label_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_goto_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_do_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_while_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_repeat_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_if_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_elseif_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_else_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_for_statement] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_for_generic_clause] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_for_numeric_clause] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_declaration] = {
+    .visible = false,
+    .named = true,
+    .supertype = true,
+  },
+  [sym_function_declaration] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__local_function_declaration] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__function_name] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym__function_name_prefix_expression] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym__function_name_dot_index_expression] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__function_name_method_index_expression] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_variable_declaration] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__local_variable_assignment] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__name_list] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__att_name_list] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__attrib] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__expression_list] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_expression] = {
+    .visible = false,
+    .named = true,
+    .supertype = true,
+  },
+  [sym_string] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__quote_string] = {
+    .visible = false,
+    .named = true,
+  },
+  [aux_sym__doublequote_string_content] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym__singlequote_string_content] = {
+    .visible = false,
+    .named = false,
+  },
+  [sym__block_string] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym_function_definition] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__function_body] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym_parameters] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__parameter_list] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym__prefix_expression] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym_variable] = {
+    .visible = false,
+    .named = true,
+    .supertype = true,
+  },
+  [sym_bracket_index_expression] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_dot_index_expression] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_function_call] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_method_index_expression] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_arguments] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_parenthesized_expression] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_table_constructor] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__field_list] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym__field_sep] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym_field] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_binary_expression] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_unary_expression] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_comment] = {
+    .visible = true,
+    .named = true,
+  },
+  [aux_sym_chunk_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym__variable_assignment_varlist_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym__variable_assignment_explist_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_if_statement_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym__name_list_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym__att_name_list_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym__expression_list_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym__field_list_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+};
+
+enum ts_field_identifiers {
+  field_alternative = 1,
+  field_arguments = 2,
+  field_attribute = 3,
+  field_body = 4,
+  field_clause = 5,
+  field_condition = 6,
+  field_consequence = 7,
+  field_content = 8,
+  field_end = 9,
+  field_field = 10,
+  field_left = 11,
+  field_local_declaration = 12,
+  field_method = 13,
+  field_name = 14,
+  field_operand = 15,
+  field_operator = 16,
+  field_parameters = 17,
+  field_right = 18,
+  field_start = 19,
+  field_step = 20,
+  field_table = 21,
+  field_value = 22,
+};
+
+static const char * const ts_field_names[] = {
+  [0] = NULL,
+  [field_alternative] = "alternative",
+  [field_arguments] = "arguments",
+  [field_attribute] = "attribute",
+  [field_body] = "body",
+  [field_clause] = "clause",
+  [field_condition] = "condition",
+  [field_consequence] = "consequence",
+  [field_content] = "content",
+  [field_end] = "end",
+  [field_field] = "field",
+  [field_left] = "left",
+  [field_local_declaration] = "local_declaration",
+  [field_method] = "method",
+  [field_name] = "name",
+  [field_operand] = "operand",
+  [field_operator] = "operator",
+  [field_parameters] = "parameters",
+  [field_right] = "right",
+  [field_start] = "start",
+  [field_step] = "step",
+  [field_table] = "table",
+  [field_value] = "value",
+};
+
+static const TSMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = {
+  [1] = {.index = 0, .length = 1},
+  [2] = {.index = 1, .length = 4},
+  [3] = {.index = 5, .length = 1},
+  [4] = {.index = 6, .length = 1},
+  [5] = {.index = 7, .length = 2},
+  [6] = {.index = 9, .length = 3},
+  [7] = {.index = 12, .length = 2},
+  [8] = {.index = 14, .length = 2},
+  [9] = {.index = 16, .length = 2},
+  [10] = {.index = 18, .length = 2},
+  [11] = {.index = 20, .length = 2},
+  [12] = {.index = 22, .length = 3},
+  [13] = {.index = 25, .length = 2},
+  [14] = {.index = 27, .length = 2},
+  [15] = {.index = 29, .length = 1},
+  [16] = {.index = 30, .length = 2},
+  [17] = {.index = 32, .length = 1},
+  [18] = {.index = 33, .length = 1},
+  [19] = {.index = 34, .length = 3},
+  [20] = {.index = 37, .length = 2},
+  [21] = {.index = 39, .length = 3},
+  [22] = {.index = 42, .length = 2},
+  [23] = {.index = 44, .length = 2},
+  [24] = {.index = 46, .length = 2},
+  [25] = {.index = 48, .length = 1},
+  [26] = {.index = 49, .length = 2},
+  [27] = {.index = 51, .length = 1},
+  [28] = {.index = 22, .length = 3},
+  [29] = {.index = 52, .length = 3},
+  [30] = {.index = 55, .length = 1},
+  [31] = {.index = 56, .length = 2},
+  [32] = {.index = 58, .length = 1},
+  [33] = {.index = 59, .length = 1},
+  [34] = {.index = 60, .length = 1},
+  [35] = {.index = 61, .length = 3},
+  [36] = {.index = 64, .length = 4},
+  [37] = {.index = 68, .length = 4},
+  [38] = {.index = 72, .length = 3},
+  [39] = {.index = 75, .length = 2},
+  [40] = {.index = 77, .length = 1},
+  [41] = {.index = 78, .length = 2},
+  [42] = {.index = 80, .length = 2},
+  [43] = {.index = 82, .length = 2},
+  [44] = {.index = 84, .length = 2},
+  [45] = {.index = 86, .length = 2},
+  [46] = {.index = 88, .length = 2},
+  [47] = {.index = 90, .length = 2},
+  [48] = {.index = 92, .length = 2},
+  [49] = {.index = 94, .length = 2},
+  [50] = {.index = 96, .length = 1},
+  [51] = {.index = 97, .length = 2},
+  [52] = {.index = 99, .length = 3},
+  [53] = {.index = 102, .length = 3},
+  [54] = {.index = 105, .length = 3},
+  [55] = {.index = 108, .length = 3},
+  [56] = {.index = 111, .length = 2},
+  [57] = {.index = 113, .length = 4},
+  [58] = {.index = 117, .length = 4},
+};
+
+static const TSFieldMapEntry ts_field_map_entries[] = {
+  [0] =
+    {field_local_declaration, 0, .inherited = true},
+  [1] =
+    {field_body, 0, .inherited = true},
+    {field_local_declaration, 0},
+    {field_name, 0, .inherited = true},
+    {field_parameters, 0, .inherited = true},
+  [5] =
+    {field_local_declaration, 0},
+  [6] =
+    {field_name, 0},
+  [7] =
+    {field_content, 1},
+    {field_start, 0},
+  [9] =
+    {field_content, 0, .inherited = true},
+    {field_end, 0, .inherited = true},
+    {field_start, 0, .inherited = true},
+  [12] =
+    {field_field, 0, .inherited = true},
+    {field_table, 0, .inherited = true},
+  [14] =
+    {field_method, 0, .inherited = true},
+    {field_table, 0, .inherited = true},
+  [16] =
+    {field_attribute, 1, .inherited = true},
+    {field_name, 1, .inherited = true},
+  [18] =
+    {field_arguments, 1},
+    {field_name, 0},
+  [20] =
+    {field_name, 0},
+    {field_name, 1, .inherited = true},
+  [22] =
+    {field_content, 1},
+    {field_end, 2},
+    {field_start, 0},
+  [25] =
+    {field_body, 1, .inherited = true},
+    {field_parameters, 1, .inherited = true},
+  [27] =
+    {field_end, 1},
+    {field_start, 0},
+  [29] =
+    {field_value, 0},
+  [30] =
+    {field_operand, 1},
+    {field_operator, 0},
+  [32] =
+    {field_body, 1},
+  [33] =
+    {field_condition, 2},
+  [34] =
+    {field_body, 2, .inherited = true},
+    {field_name, 1},
+    {field_parameters, 2, .inherited = true},
+  [37] =
+    {field_attribute, 1},
+    {field_name, 0},
+  [39] =
+    {field_attribute, 1, .inherited = true},
+    {field_name, 0},
+    {field_name, 1, .inherited = true},
+  [42] =
+    {field_name, 0, .inherited = true},
+    {field_value, 2, .inherited = true},
+  [44] =
+    {field_field, 2},
+    {field_table, 0},
+  [46] =
+    {field_method, 2},
+    {field_table, 0},
+  [48] =
+    {field_name, 1},
+  [49] =
+    {field_name, 0, .inherited = true},
+    {field_name, 1, .inherited = true},
+  [51] =
+    {field_parameters, 0},
+  [52] =
+    {field_left, 0},
+    {field_operator, 1},
+    {field_right, 2},
+  [55] =
+    {field_condition, 1},
+  [56] =
+    {field_body, 1},
+    {field_condition, 3},
+  [58] =
+    {field_alternative, 0},
+  [59] =
+    {field_clause, 1},
+  [60] =
+    {field_name, 0, .inherited = true},
+  [61] =
+    {field_body, 3, .inherited = true},
+    {field_name, 2},
+    {field_parameters, 3, .inherited = true},
+  [64] =
+    {field_attribute, 1},
+    {field_attribute, 2, .inherited = true},
+    {field_name, 0},
+    {field_name, 2, .inherited = true},
+  [68] =
+    {field_attribute, 0, .inherited = true},
+    {field_attribute, 1, .inherited = true},
+    {field_name, 0, .inherited = true},
+    {field_name, 1, .inherited = true},
+  [72] =
+    {field_attribute, 0, .inherited = true},
+    {field_name, 0, .inherited = true},
+    {field_value, 2, .inherited = true},
+  [75] =
+    {field_value, 0},
+    {field_value, 1, .inherited = true},
+  [77] =
+    {field_name, 1, .inherited = true},
+  [78] =
+    {field_body, 1},
+    {field_parameters, 0},
+  [80] =
+    {field_name, 0},
+    {field_value, 2},
+  [82] =
+    {field_body, 3},
+    {field_condition, 1},
+  [84] =
+    {field_condition, 1},
+    {field_consequence, 3},
+  [86] =
+    {field_alternative, 3},
+    {field_condition, 1},
+  [88] =
+    {field_alternative, 3, .inherited = true},
+    {field_condition, 1},
+  [90] =
+    {field_alternative, 0, .inherited = true},
+    {field_alternative, 1, .inherited = true},
+  [92] =
+    {field_body, 3},
+    {field_clause, 1},
+  [94] =
+    {field_attribute, 2},
+    {field_name, 1},
+  [96] =
+    {field_value, 1},
+  [97] =
+    {field_value, 0, .inherited = true},
+    {field_value, 1, .inherited = true},
+  [99] =
+    {field_alternative, 4},
+    {field_condition, 1},
+    {field_consequence, 3},
+  [102] =
+    {field_alternative, 4, .inherited = true},
+    {field_condition, 1},
+    {field_consequence, 3},
+  [105] =
+    {field_alternative, 3, .inherited = true},
+    {field_alternative, 4},
+    {field_condition, 1},
+  [108] =
+    {field_end, 4},
+    {field_name, 0},
+    {field_start, 2},
+  [111] =
+    {field_name, 1},
+    {field_value, 4},
+  [113] =
+    {field_alternative, 4, .inherited = true},
+    {field_alternative, 5},
+    {field_condition, 1},
+    {field_consequence, 3},
+  [117] =
+    {field_end, 4},
+    {field_name, 0},
+    {field_start, 2},
+    {field_step, 6},
+};
+
+static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = {
+  [0] = {0},
+  [28] = {
+    [1] = sym__block_string_content,
+  },
+};
+
+static const uint16_t ts_non_terminal_alias_map[] = {
+  aux_sym__doublequote_string_content, 2,
+    aux_sym__doublequote_string_content,
+    sym__block_string_content,
+  aux_sym__singlequote_string_content, 2,
+    aux_sym__singlequote_string_content,
+    sym__block_string_content,
+  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] = 5,
+  [20] = 15,
+  [21] = 16,
+  [22] = 22,
+  [23] = 23,
+  [24] = 24,
+  [25] = 17,
+  [26] = 26,
+  [27] = 18,
+  [28] = 28,
+  [29] = 29,
+  [30] = 30,
+  [31] = 31,
+  [32] = 32,
+  [33] = 33,
+  [34] = 34,
+  [35] = 35,
+  [36] = 36,
+  [37] = 37,
+  [38] = 13,
+  [39] = 14,
+  [40] = 40,
+  [41] = 41,
+  [42] = 42,
+  [43] = 43,
+  [44] = 44,
+  [45] = 45,
+  [46] = 46,
+  [47] = 47,
+  [48] = 48,
+  [49] = 49,
+  [50] = 50,
+  [51] = 51,
+  [52] = 52,
+  [53] = 53,
+  [54] = 54,
+  [55] = 55,
+  [56] = 56,
+  [57] = 57,
+  [58] = 58,
+  [59] = 59,
+  [60] = 60,
+  [61] = 60,
+  [62] = 62,
+  [63] = 59,
+  [64] = 64,
+  [65] = 65,
+  [66] = 66,
+  [67] = 67,
+  [68] = 68,
+  [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] = 98,
+  [99] = 99,
+  [100] = 100,
+  [101] = 101,
+  [102] = 102,
+  [103] = 103,
+  [104] = 104,
+  [105] = 105,
+  [106] = 106,
+  [107] = 107,
+  [108] = 108,
+  [109] = 109,
+  [110] = 110,
+  [111] = 111,
+  [112] = 112,
+  [113] = 113,
+  [114] = 114,
+  [115] = 115,
+  [116] = 116,
+  [117] = 117,
+  [118] = 118,
+  [119] = 119,
+  [120] = 120,
+  [121] = 121,
+  [122] = 122,
+  [123] = 123,
+  [124] = 124,
+  [125] = 125,
+  [126] = 126,
+  [127] = 127,
+  [128] = 128,
+  [129] = 129,
+  [130] = 130,
+  [131] = 131,
+  [132] = 132,
+  [133] = 133,
+  [134] = 134,
+  [135] = 135,
+  [136] = 136,
+  [137] = 137,
+  [138] = 138,
+  [139] = 139,
+  [140] = 140,
+  [141] = 141,
+  [142] = 142,
+  [143] = 143,
+  [144] = 144,
+  [145] = 145,
+  [146] = 146,
+  [147] = 147,
+  [148] = 148,
+  [149] = 149,
+  [150] = 150,
+  [151] = 151,
+  [152] = 152,
+  [153] = 153,
+  [154] = 154,
+  [155] = 155,
+  [156] = 156,
+  [157] = 157,
+  [158] = 158,
+  [159] = 159,
+  [160] = 160,
+  [161] = 161,
+  [162] = 162,
+  [163] = 163,
+  [164] = 164,
+  [165] = 165,
+  [166] = 166,
+  [167] = 167,
+  [168] = 168,
+  [169] = 169,
+  [170] = 170,
+  [171] = 171,
+  [172] = 172,
+  [173] = 173,
+  [174] = 174,
+  [175] = 175,
+  [176] = 176,
+  [177] = 177,
+  [178] = 178,
+  [179] = 179,
+  [180] = 180,
+  [181] = 181,
+  [182] = 182,
+  [183] = 183,
+  [184] = 184,
+  [185] = 185,
+  [186] = 186,
+  [187] = 187,
+  [188] = 188,
+  [189] = 182,
+  [190] = 183,
+  [191] = 180,
+  [192] = 177,
+  [193] = 193,
+  [194] = 194,
+  [195] = 195,
+  [196] = 196,
+  [197] = 197,
+  [198] = 198,
+  [199] = 199,
+  [200] = 200,
+  [201] = 201,
+  [202] = 202,
+  [203] = 203,
+  [204] = 204,
+  [205] = 205,
+  [206] = 206,
+  [207] = 207,
+  [208] = 208,
+  [209] = 209,
+  [210] = 210,
+  [211] = 211,
+  [212] = 212,
+  [213] = 213,
+  [214] = 214,
+  [215] = 215,
+  [216] = 216,
+  [217] = 217,
+  [218] = 218,
+  [219] = 219,
+  [220] = 220,
+  [221] = 221,
+  [222] = 222,
+  [223] = 223,
+  [224] = 224,
+  [225] = 225,
+  [226] = 226,
+  [227] = 227,
+  [228] = 228,
+  [229] = 229,
+  [230] = 230,
+  [231] = 231,
+  [232] = 232,
+  [233] = 233,
+  [234] = 234,
+  [235] = 235,
+  [236] = 236,
+  [237] = 237,
+  [238] = 238,
+  [239] = 239,
+  [240] = 240,
+  [241] = 241,
+  [242] = 242,
+  [243] = 243,
+  [244] = 244,
+  [245] = 245,
+  [246] = 246,
+  [247] = 247,
+  [248] = 248,
+  [249] = 249,
+  [250] = 250,
+  [251] = 251,
+  [252] = 252,
+  [253] = 253,
+  [254] = 240,
+  [255] = 255,
+  [256] = 256,
+  [257] = 252,
+  [258] = 247,
+  [259] = 259,
+  [260] = 260,
+  [261] = 261,
+};
+
+static const TSSymbol ts_supertype_symbols[SUPERTYPE_COUNT] = {
+  sym_declaration,
+  sym_expression,
+  sym_statement,
+  sym_variable,
+};
+
+static const TSMapSlice ts_supertype_map_slices[] = {
+  [sym_declaration] = {.index = 0, .length = 3},
+  [sym_expression] = {.index = 3, .length = 13},
+  [sym_statement] = {.index = 16, .length = 12},
+  [sym_variable] = {.index = 28, .length = 3},
+};
+
+static const TSSymbol ts_supertype_map_entries[] = {
+  [0] =
+    sym__local_function_declaration,
+    sym_function_declaration,
+    sym_variable_declaration,
+  [3] =
+    sym_binary_expression,
+    sym_false,
+    sym_function_call,
+    sym_function_definition,
+    sym_nil,
+    sym_number,
+    sym_parenthesized_expression,
+    sym_string,
+    sym_table_constructor,
+    sym_true,
+    sym_unary_expression,
+    sym_vararg_expression,
+    sym_variable,
+  [16] =
+    sym_assignment_statement,
+    sym_break_statement,
+    sym_declaration,
+    sym_do_statement,
+    sym_empty_statement,
+    sym_for_statement,
+    sym_function_call,
+    sym_goto_statement,
+    sym_if_statement,
+    sym_label_statement,
+    sym_repeat_statement,
+    sym_while_statement,
+  [28] =
+    sym_bracket_index_expression,
+    sym_dot_index_expression,
+    sym_identifier,
+};
+
+static const TSCharacterRange sym_escape_sequence_character_set_1[] = {
+  {'\n', '\n'}, {'"', '"'}, {'\'', '\''}, {'0', '9'}, {'\\', '\\'}, {'a', 'b'}, {'f', 'f'}, {'n', 'n'},
+  {'r', 'r'}, {'t', 'v'}, {'x', 'x'}, {'z', 'z'},
+};
+
+static bool ts_lex(TSLexer *lexer, TSStateId state) {
+  START_LEXER();
+  eof = lexer->eof(lexer);
+  switch (state) {
+    case 0:
+      if (eof) ADVANCE(21);
+      ADVANCE_MAP(
+        '"', 41,
+        '#', 78,
+        '%', 75,
+        '&', 67,
+        '\'', 42,
+        '(', 54,
+        ')', 55,
+        '*', 72,
+        '+', 70,
+        ',', 25,
+        '-', 71,
+        '.', 28,
+        '/', 73,
+        '0', 34,
+        ':', 29,
+        ';', 23,
+        '<', 30,
+        '=', 24,
+        '>', 32,
+        '[', 56,
+        '\\', 6,
+        ']', 57,
+        '^', 77,
+        '{', 58,
+        '|', 64,
+        '}', 59,
+        '~', 66,
+      );
+      if (('\t' <= lookahead && lookahead <= '\r') ||
+          lookahead == ' ') SKIP(18);
+      if (('1' <= lookahead && lookahead <= '9')) ADVANCE(35);
+      if (lookahead > ' ' &&
+          (lookahead < '{' || 0x9f < lookahead)) ADVANCE(79);
+      END_STATE();
+    case 1:
+      if (lookahead == '"') ADVANCE(41);
+      if (lookahead == '-') ADVANCE(44);
+      if (lookahead == '\\') ADVANCE(6);
+      if (('\t' <= lookahead && lookahead <= '\r') ||
+          lookahead == ' ') ADVANCE(43);
+      if (lookahead != 0) ADVANCE(45);
+      END_STATE();
+    case 2:
+      if (lookahead == '\'') ADVANCE(42);
+      if (lookahead == '-') ADVANCE(47);
+      if (lookahead == '\\') ADVANCE(6);
+      if (('\t' <= lookahead && lookahead <= '\r') ||
+          lookahead == ' ') ADVANCE(46);
+      if (lookahead != 0) ADVANCE(48);
+      END_STATE();
+    case 3:
+      if (lookahead == '.') ADVANCE(4);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(37);
+      END_STATE();
+    case 4:
+      if (lookahead == '.') ADVANCE(53);
+      END_STATE();
+    case 5:
+      if (lookahead == '.') ADVANCE(15);
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(36);
+      END_STATE();
+    case 6:
+      if (lookahead == 'u') ADVANCE(7);
+      if (lookahead == 'x') ADVANCE(17);
+      if (lookahead == 'z') ADVANCE(50);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(52);
+      if (set_contains(sym_escape_sequence_character_set_1, 12, lookahead)) ADVANCE(49);
+      END_STATE();
+    case 7:
+      if (lookahead == '{') ADVANCE(16);
+      END_STATE();
+    case 8:
+      if (lookahead == '}') ADVANCE(49);
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(8);
+      END_STATE();
+    case 9:
+      if (lookahead == '+' ||
+          lookahead == '-') ADVANCE(13);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(40);
+      END_STATE();
+    case 10:
+      if (lookahead == 'L' ||
+          lookahead == 'l') ADVANCE(33);
+      END_STATE();
+    case 11:
+      if (lookahead == 'L' ||
+          lookahead == 'l') ADVANCE(10);
+      END_STATE();
+    case 12:
+      if (lookahead == '0' ||
+          lookahead == '1') ADVANCE(38);
+      END_STATE();
+    case 13:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(40);
+      END_STATE();
+    case 14:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(49);
+      END_STATE();
+    case 15:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(39);
+      END_STATE();
+    case 16:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(8);
+      END_STATE();
+    case 17:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(14);
+      END_STATE();
+    case 18:
+      if (eof) ADVANCE(21);
+      ADVANCE_MAP(
+        '"', 41,
+        '#', 78,
+        '%', 75,
+        '&', 67,
+        '\'', 42,
+        '(', 54,
+        ')', 55,
+        '*', 72,
+        '+', 70,
+        ',', 25,
+        '-', 71,
+        '.', 28,
+        '/', 73,
+        '0', 34,
+        ':', 29,
+        ';', 23,
+        '<', 30,
+        '=', 24,
+        '>', 32,
+        '[', 56,
+        ']', 57,
+        '^', 77,
+        '{', 58,
+        '|', 64,
+        '}', 59,
+        '~', 66,
+      );
+      if (('\t' <= lookahead && lookahead <= '\r') ||
+          lookahead == ' ') SKIP(18);
+      if (('1' <= lookahead && lookahead <= '9')) ADVANCE(35);
+      if (lookahead > ' ' &&
+          (lookahead < '[' || '^' < lookahead) &&
+          (lookahead < '{' || 0x9f < lookahead)) ADVANCE(79);
+      END_STATE();
+    case 19:
+      if (eof) ADVANCE(21);
+      ADVANCE_MAP(
+        '"', 41,
+        '#', 78,
+        '\'', 42,
+        '(', 54,
+        ')', 55,
+        '-', 71,
+        '.', 3,
+        '0', 34,
+        ';', 23,
+        '>', 31,
+        '[', 56,
+        '{', 58,
+        '}', 59,
+        '~', 65,
+      );
+      if (('\t' <= lookahead && lookahead <= '\r') ||
+          lookahead == ' ') SKIP(19);
+      if (('1' <= lookahead && lookahead <= '9')) ADVANCE(35);
+      if (lookahead > ' ' &&
+          (lookahead < '%' || '>' < lookahead) &&
+          (lookahead < '[' || '^' < lookahead) &&
+          (lookahead < '{' || 0x9f < lookahead)) ADVANCE(79);
+      END_STATE();
+    case 20:
+      if (eof) ADVANCE(21);
+      ADVANCE_MAP(
+        '"', 41,
+        '#', 22,
+        '%', 75,
+        '&', 67,
+        '\'', 42,
+        '(', 54,
+        ')', 55,
+        '*', 72,
+        '+', 70,
+        ',', 25,
+        '-', 71,
+        '.', 27,
+        '/', 73,
+        ':', 29,
+        ';', 23,
+        '<', 30,
+        '=', 24,
+        '>', 32,
+        '[', 56,
+        ']', 57,
+        '^', 77,
+        '{', 58,
+        '|', 64,
+        '}', 59,
+        '~', 66,
+      );
+      if (('\t' <= lookahead && lookahead <= '\r') ||
+          lookahead == ' ') SKIP(20);
+      if (lookahead > ' ' &&
+          (lookahead < '%' || '>' < lookahead) &&
+          (lookahead < '[' || '^' < lookahead) &&
+          (lookahead < '{' || 0x9f < lookahead)) ADVANCE(79);
+      END_STATE();
+    case 21:
+      ACCEPT_TOKEN(ts_builtin_sym_end);
+      END_STATE();
+    case 22:
+      ACCEPT_TOKEN(sym_hash_bang_line);
+      if (lookahead != 0 &&
+          lookahead != '\n') ADVANCE(22);
+      END_STATE();
+    case 23:
+      ACCEPT_TOKEN(anon_sym_SEMI);
+      END_STATE();
+    case 24:
+      ACCEPT_TOKEN(anon_sym_EQ);
+      if (lookahead == '=') ADVANCE(61);
+      END_STATE();
+    case 25:
+      ACCEPT_TOKEN(anon_sym_COMMA);
+      END_STATE();
+    case 26:
+      ACCEPT_TOKEN(anon_sym_COLON_COLON);
+      END_STATE();
+    case 27:
+      ACCEPT_TOKEN(anon_sym_DOT);
+      if (lookahead == '.') ADVANCE(76);
+      END_STATE();
+    case 28:
+      ACCEPT_TOKEN(anon_sym_DOT);
+      if (lookahead == '.') ADVANCE(76);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(37);
+      END_STATE();
+    case 29:
+      ACCEPT_TOKEN(anon_sym_COLON);
+      if (lookahead == ':') ADVANCE(26);
+      END_STATE();
+    case 30:
+      ACCEPT_TOKEN(anon_sym_LT);
+      if (lookahead == '<') ADVANCE(68);
+      if (lookahead == '=') ADVANCE(60);
+      END_STATE();
+    case 31:
+      ACCEPT_TOKEN(anon_sym_GT);
+      END_STATE();
+    case 32:
+      ACCEPT_TOKEN(anon_sym_GT);
+      if (lookahead == '=') ADVANCE(63);
+      if (lookahead == '>') ADVANCE(69);
+      END_STATE();
+    case 33:
+      ACCEPT_TOKEN(sym_number);
+      END_STATE();
+    case 34:
+      ACCEPT_TOKEN(sym_number);
+      ADVANCE_MAP(
+        '.', 37,
+        'B', 12,
+        'b', 12,
+        'E', 9,
+        'e', 9,
+        'I', 33,
+        'i', 33,
+        'L', 10,
+        'l', 10,
+        'U', 11,
+        'u', 11,
+        'X', 5,
+        'x', 5,
+      );
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(35);
+      END_STATE();
+    case 35:
+      ACCEPT_TOKEN(sym_number);
+      ADVANCE_MAP(
+        '.', 37,
+        'E', 9,
+        'e', 9,
+        'I', 33,
+        'i', 33,
+        'L', 10,
+        'l', 10,
+        'U', 11,
+        'u', 11,
+      );
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(35);
+      END_STATE();
+    case 36:
+      ACCEPT_TOKEN(sym_number);
+      ADVANCE_MAP(
+        '.', 39,
+        'I', 33,
+        'i', 33,
+        'L', 10,
+        'l', 10,
+        'P', 9,
+        'p', 9,
+        'U', 11,
+        'u', 11,
+      );
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(36);
+      END_STATE();
+    case 37:
+      ACCEPT_TOKEN(sym_number);
+      if (lookahead == 'E' ||
+          lookahead == 'e') ADVANCE(9);
+      if (lookahead == 'I' ||
+          lookahead == 'i') ADVANCE(33);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(37);
+      END_STATE();
+    case 38:
+      ACCEPT_TOKEN(sym_number);
+      if (lookahead == 'I' ||
+          lookahead == 'i') ADVANCE(33);
+      if (lookahead == 'L' ||
+          lookahead == 'l') ADVANCE(10);
+      if (lookahead == 'U' ||
+          lookahead == 'u') ADVANCE(11);
+      if (lookahead == '0' ||
+          lookahead == '1') ADVANCE(38);
+      END_STATE();
+    case 39:
+      ACCEPT_TOKEN(sym_number);
+      if (lookahead == 'I' ||
+          lookahead == 'i') ADVANCE(33);
+      if (lookahead == 'P' ||
+          lookahead == 'p') ADVANCE(9);
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(39);
+      END_STATE();
+    case 40:
+      ACCEPT_TOKEN(sym_number);
+      if (lookahead == 'I' ||
+          lookahead == 'i') ADVANCE(33);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(40);
+      END_STATE();
+    case 41:
+      ACCEPT_TOKEN(anon_sym_DQUOTE);
+      END_STATE();
+    case 42:
+      ACCEPT_TOKEN(anon_sym_SQUOTE);
+      END_STATE();
+    case 43:
+      ACCEPT_TOKEN(aux_sym__doublequote_string_content_token1);
+      if (lookahead == '-') ADVANCE(44);
+      if (('\t' <= lookahead && lookahead <= '\r') ||
+          lookahead == ' ') ADVANCE(43);
+      if (lookahead != 0 &&
+          lookahead != '"' &&
+          lookahead != '\\') ADVANCE(45);
+      END_STATE();
+    case 44:
+      ACCEPT_TOKEN(aux_sym__doublequote_string_content_token1);
+      if (lookahead == '-') ADVANCE(45);
+      if (lookahead != 0 &&
+          lookahead != '"' &&
+          lookahead != '\\') ADVANCE(45);
+      END_STATE();
+    case 45:
+      ACCEPT_TOKEN(aux_sym__doublequote_string_content_token1);
+      if (lookahead != 0 &&
+          lookahead != '"' &&
+          lookahead != '\\') ADVANCE(45);
+      END_STATE();
+    case 46:
+      ACCEPT_TOKEN(aux_sym__singlequote_string_content_token1);
+      if (lookahead == '-') ADVANCE(47);
+      if (('\t' <= lookahead && lookahead <= '\r') ||
+          lookahead == ' ') ADVANCE(46);
+      if (lookahead != 0 &&
+          lookahead != '\'' &&
+          lookahead != '\\') ADVANCE(48);
+      END_STATE();
+    case 47:
+      ACCEPT_TOKEN(aux_sym__singlequote_string_content_token1);
+      if (lookahead == '-') ADVANCE(48);
+      if (lookahead != 0 &&
+          lookahead != '\'' &&
+          lookahead != '\\') ADVANCE(48);
+      END_STATE();
+    case 48:
+      ACCEPT_TOKEN(aux_sym__singlequote_string_content_token1);
+      if (lookahead != 0 &&
+          lookahead != '\'' &&
+          lookahead != '\\') ADVANCE(48);
+      END_STATE();
+    case 49:
+      ACCEPT_TOKEN(sym_escape_sequence);
+      END_STATE();
+    case 50:
+      ACCEPT_TOKEN(sym_escape_sequence);
+      if (('\t' <= lookahead && lookahead <= '\r') ||
+          lookahead == ' ') ADVANCE(50);
+      END_STATE();
+    case 51:
+      ACCEPT_TOKEN(sym_escape_sequence);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
+      END_STATE();
+    case 52:
+      ACCEPT_TOKEN(sym_escape_sequence);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(51);
+      END_STATE();
+    case 53:
+      ACCEPT_TOKEN(sym_vararg_expression);
+      END_STATE();
+    case 54:
+      ACCEPT_TOKEN(anon_sym_LPAREN);
+      END_STATE();
+    case 55:
+      ACCEPT_TOKEN(anon_sym_RPAREN);
+      END_STATE();
+    case 56:
+      ACCEPT_TOKEN(anon_sym_LBRACK);
+      END_STATE();
+    case 57:
+      ACCEPT_TOKEN(anon_sym_RBRACK);
+      END_STATE();
+    case 58:
+      ACCEPT_TOKEN(anon_sym_LBRACE);
+      END_STATE();
+    case 59:
+      ACCEPT_TOKEN(anon_sym_RBRACE);
+      END_STATE();
+    case 60:
+      ACCEPT_TOKEN(anon_sym_LT_EQ);
+      END_STATE();
+    case 61:
+      ACCEPT_TOKEN(anon_sym_EQ_EQ);
+      END_STATE();
+    case 62:
+      ACCEPT_TOKEN(anon_sym_TILDE_EQ);
+      END_STATE();
+    case 63:
+      ACCEPT_TOKEN(anon_sym_GT_EQ);
+      END_STATE();
+    case 64:
+      ACCEPT_TOKEN(anon_sym_PIPE);
+      END_STATE();
+    case 65:
+      ACCEPT_TOKEN(anon_sym_TILDE);
+      END_STATE();
+    case 66:
+      ACCEPT_TOKEN(anon_sym_TILDE);
+      if (lookahead == '=') ADVANCE(62);
+      END_STATE();
+    case 67:
+      ACCEPT_TOKEN(anon_sym_AMP);
+      END_STATE();
+    case 68:
+      ACCEPT_TOKEN(anon_sym_LT_LT);
+      END_STATE();
+    case 69:
+      ACCEPT_TOKEN(anon_sym_GT_GT);
+      END_STATE();
+    case 70:
+      ACCEPT_TOKEN(anon_sym_PLUS);
+      END_STATE();
+    case 71:
+      ACCEPT_TOKEN(anon_sym_DASH);
+      if (lookahead == '-') ADVANCE(80);
+      END_STATE();
+    case 72:
+      ACCEPT_TOKEN(anon_sym_STAR);
+      END_STATE();
+    case 73:
+      ACCEPT_TOKEN(anon_sym_SLASH);
+      if (lookahead == '/') ADVANCE(74);
+      END_STATE();
+    case 74:
+      ACCEPT_TOKEN(anon_sym_SLASH_SLASH);
+      END_STATE();
+    case 75:
+      ACCEPT_TOKEN(anon_sym_PERCENT);
+      END_STATE();
+    case 76:
+      ACCEPT_TOKEN(anon_sym_DOT_DOT);
+      END_STATE();
+    case 77:
+      ACCEPT_TOKEN(anon_sym_CARET);
+      END_STATE();
+    case 78:
+      ACCEPT_TOKEN(anon_sym_POUND);
+      END_STATE();
+    case 79:
+      ACCEPT_TOKEN(sym_identifier);
+      if (lookahead > ' ' &&
+          lookahead != '"' &&
+          lookahead != '#' &&
+          (lookahead < '%' || '/' < lookahead) &&
+          (lookahead < ':' || '>' < lookahead) &&
+          (lookahead < '[' || '^' < lookahead) &&
+          (lookahead < '{' || 0x9f < lookahead)) ADVANCE(79);
+      END_STATE();
+    case 80:
+      ACCEPT_TOKEN(anon_sym_DASH_DASH);
+      END_STATE();
+    case 81:
+      ACCEPT_TOKEN(anon_sym_DASH_DASH);
+      if (lookahead != 0 &&
+          lookahead != '\n' &&
+          lookahead != '\r') ADVANCE(84);
+      END_STATE();
+    case 82:
+      ACCEPT_TOKEN(aux_sym_comment_token1);
+      if (lookahead == '-') ADVANCE(83);
+      if (lookahead == '\t' ||
+          lookahead == 0x0b ||
+          lookahead == '\f' ||
+          lookahead == ' ') ADVANCE(82);
+      if (lookahead != 0 &&
+          (lookahead < '\t' || '\r' < lookahead)) ADVANCE(84);
+      END_STATE();
+    case 83:
+      ACCEPT_TOKEN(aux_sym_comment_token1);
+      if (lookahead == '-') ADVANCE(81);
+      if (lookahead != 0 &&
+          lookahead != '\n' &&
+          lookahead != '\r') ADVANCE(84);
+      END_STATE();
+    case 84:
+      ACCEPT_TOKEN(aux_sym_comment_token1);
+      if (lookahead != 0 &&
+          lookahead != '\n' &&
+          lookahead != '\r') ADVANCE(84);
+      END_STATE();
+    default:
+      return false;
+  }
+}
+
+static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) {
+  START_LEXER();
+  eof = lexer->eof(lexer);
+  switch (state) {
+    case 0:
+      ADVANCE_MAP(
+        'a', 1,
+        'b', 2,
+        'd', 3,
+        'e', 4,
+        'f', 5,
+        'g', 6,
+        'i', 7,
+        'l', 8,
+        'n', 9,
+        'o', 10,
+        'r', 11,
+        't', 12,
+        'u', 13,
+        'w', 14,
+      );
+      if (('\t' <= lookahead && lookahead <= '\r') ||
+          lookahead == ' ') SKIP(0);
+      END_STATE();
+    case 1:
+      if (lookahead == 'n') ADVANCE(15);
+      END_STATE();
+    case 2:
+      if (lookahead == 'r') ADVANCE(16);
+      END_STATE();
+    case 3:
+      if (lookahead == 'o') ADVANCE(17);
+      END_STATE();
+    case 4:
+      if (lookahead == 'l') ADVANCE(18);
+      if (lookahead == 'n') ADVANCE(19);
+      END_STATE();
+    case 5:
+      if (lookahead == 'a') ADVANCE(20);
+      if (lookahead == 'o') ADVANCE(21);
+      if (lookahead == 'u') ADVANCE(22);
+      END_STATE();
+    case 6:
+      if (lookahead == 'o') ADVANCE(23);
+      END_STATE();
+    case 7:
+      if (lookahead == 'f') ADVANCE(24);
+      if (lookahead == 'n') ADVANCE(25);
+      END_STATE();
+    case 8:
+      if (lookahead == 'o') ADVANCE(26);
+      END_STATE();
+    case 9:
+      if (lookahead == 'i') ADVANCE(27);
+      if (lookahead == 'o') ADVANCE(28);
+      END_STATE();
+    case 10:
+      if (lookahead == 'r') ADVANCE(29);
+      END_STATE();
+    case 11:
+      if (lookahead == 'e') ADVANCE(30);
+      END_STATE();
+    case 12:
+      if (lookahead == 'h') ADVANCE(31);
+      if (lookahead == 'r') ADVANCE(32);
+      END_STATE();
+    case 13:
+      if (lookahead == 'n') ADVANCE(33);
+      END_STATE();
+    case 14:
+      if (lookahead == 'h') ADVANCE(34);
+      END_STATE();
+    case 15:
+      if (lookahead == 'd') ADVANCE(35);
+      END_STATE();
+    case 16:
+      if (lookahead == 'e') ADVANCE(36);
+      END_STATE();
+    case 17:
+      ACCEPT_TOKEN(anon_sym_do);
+      END_STATE();
+    case 18:
+      if (lookahead == 's') ADVANCE(37);
+      END_STATE();
+    case 19:
+      if (lookahead == 'd') ADVANCE(38);
+      END_STATE();
+    case 20:
+      if (lookahead == 'l') ADVANCE(39);
+      END_STATE();
+    case 21:
+      if (lookahead == 'r') ADVANCE(40);
+      END_STATE();
+    case 22:
+      if (lookahead == 'n') ADVANCE(41);
+      END_STATE();
+    case 23:
+      if (lookahead == 't') ADVANCE(42);
+      END_STATE();
+    case 24:
+      ACCEPT_TOKEN(anon_sym_if);
+      END_STATE();
+    case 25:
+      ACCEPT_TOKEN(anon_sym_in);
+      END_STATE();
+    case 26:
+      if (lookahead == 'c') ADVANCE(43);
+      END_STATE();
+    case 27:
+      if (lookahead == 'l') ADVANCE(44);
+      END_STATE();
+    case 28:
+      if (lookahead == 't') ADVANCE(45);
+      END_STATE();
+    case 29:
+      ACCEPT_TOKEN(anon_sym_or);
+      END_STATE();
+    case 30:
+      if (lookahead == 'p') ADVANCE(46);
+      if (lookahead == 't') ADVANCE(47);
+      END_STATE();
+    case 31:
+      if (lookahead == 'e') ADVANCE(48);
+      END_STATE();
+    case 32:
+      if (lookahead == 'u') ADVANCE(49);
+      END_STATE();
+    case 33:
+      if (lookahead == 't') ADVANCE(50);
+      END_STATE();
+    case 34:
+      if (lookahead == 'i') ADVANCE(51);
+      END_STATE();
+    case 35:
+      ACCEPT_TOKEN(anon_sym_and);
+      END_STATE();
+    case 36:
+      if (lookahead == 'a') ADVANCE(52);
+      END_STATE();
+    case 37:
+      if (lookahead == 'e') ADVANCE(53);
+      END_STATE();
+    case 38:
+      ACCEPT_TOKEN(anon_sym_end);
+      END_STATE();
+    case 39:
+      if (lookahead == 's') ADVANCE(54);
+      END_STATE();
+    case 40:
+      ACCEPT_TOKEN(anon_sym_for);
+      END_STATE();
+    case 41:
+      if (lookahead == 'c') ADVANCE(55);
+      END_STATE();
+    case 42:
+      if (lookahead == 'o') ADVANCE(56);
+      END_STATE();
+    case 43:
+      if (lookahead == 'a') ADVANCE(57);
+      END_STATE();
+    case 44:
+      ACCEPT_TOKEN(sym_nil);
+      END_STATE();
+    case 45:
+      ACCEPT_TOKEN(anon_sym_not);
+      END_STATE();
+    case 46:
+      if (lookahead == 'e') ADVANCE(58);
+      END_STATE();
+    case 47:
+      if (lookahead == 'u') ADVANCE(59);
+      END_STATE();
+    case 48:
+      if (lookahead == 'n') ADVANCE(60);
+      END_STATE();
+    case 49:
+      if (lookahead == 'e') ADVANCE(61);
+      END_STATE();
+    case 50:
+      if (lookahead == 'i') ADVANCE(62);
+      END_STATE();
+    case 51:
+      if (lookahead == 'l') ADVANCE(63);
+      END_STATE();
+    case 52:
+      if (lookahead == 'k') ADVANCE(64);
+      END_STATE();
+    case 53:
+      ACCEPT_TOKEN(anon_sym_else);
+      if (lookahead == 'i') ADVANCE(65);
+      END_STATE();
+    case 54:
+      if (lookahead == 'e') ADVANCE(66);
+      END_STATE();
+    case 55:
+      if (lookahead == 't') ADVANCE(67);
+      END_STATE();
+    case 56:
+      ACCEPT_TOKEN(anon_sym_goto);
+      END_STATE();
+    case 57:
+      if (lookahead == 'l') ADVANCE(68);
+      END_STATE();
+    case 58:
+      if (lookahead == 'a') ADVANCE(69);
+      END_STATE();
+    case 59:
+      if (lookahead == 'r') ADVANCE(70);
+      END_STATE();
+    case 60:
+      ACCEPT_TOKEN(anon_sym_then);
+      END_STATE();
+    case 61:
+      ACCEPT_TOKEN(sym_true);
+      END_STATE();
+    case 62:
+      if (lookahead == 'l') ADVANCE(71);
+      END_STATE();
+    case 63:
+      if (lookahead == 'e') ADVANCE(72);
+      END_STATE();
+    case 64:
+      ACCEPT_TOKEN(sym_break_statement);
+      END_STATE();
+    case 65:
+      if (lookahead == 'f') ADVANCE(73);
+      END_STATE();
+    case 66:
+      ACCEPT_TOKEN(sym_false);
+      END_STATE();
+    case 67:
+      if (lookahead == 'i') ADVANCE(74);
+      END_STATE();
+    case 68:
+      ACCEPT_TOKEN(anon_sym_local);
+      END_STATE();
+    case 69:
+      if (lookahead == 't') ADVANCE(75);
+      END_STATE();
+    case 70:
+      if (lookahead == 'n') ADVANCE(76);
+      END_STATE();
+    case 71:
+      ACCEPT_TOKEN(anon_sym_until);
+      END_STATE();
+    case 72:
+      ACCEPT_TOKEN(anon_sym_while);
+      END_STATE();
+    case 73:
+      ACCEPT_TOKEN(anon_sym_elseif);
+      END_STATE();
+    case 74:
+      if (lookahead == 'o') ADVANCE(77);
+      END_STATE();
+    case 75:
+      ACCEPT_TOKEN(anon_sym_repeat);
+      END_STATE();
+    case 76:
+      ACCEPT_TOKEN(anon_sym_return);
+      END_STATE();
+    case 77:
+      if (lookahead == 'n') ADVANCE(78);
+      END_STATE();
+    case 78:
+      ACCEPT_TOKEN(anon_sym_function);
+      END_STATE();
+    default:
+      return false;
+  }
+}
+
+static const TSLexerMode ts_lex_modes[STATE_COUNT] = {
+  [0] = {.lex_state = 0, .external_lex_state = 1},
+  [1] = {.lex_state = 20, .external_lex_state = 2},
+  [2] = {.lex_state = 20, .external_lex_state = 3},
+  [3] = {.lex_state = 20, .external_lex_state = 3},
+  [4] = {.lex_state = 20, .external_lex_state = 3},
+  [5] = {.lex_state = 20, .external_lex_state = 3},
+  [6] = {.lex_state = 20, .external_lex_state = 3},
+  [7] = {.lex_state = 20, .external_lex_state = 3},
+  [8] = {.lex_state = 20, .external_lex_state = 3},
+  [9] = {.lex_state = 20, .external_lex_state = 3},
+  [10] = {.lex_state = 20, .external_lex_state = 3},
+  [11] = {.lex_state = 20, .external_lex_state = 3},
+  [12] = {.lex_state = 20, .external_lex_state = 3},
+  [13] = {.lex_state = 20, .external_lex_state = 3},
+  [14] = {.lex_state = 20, .external_lex_state = 3},
+  [15] = {.lex_state = 20, .external_lex_state = 3},
+  [16] = {.lex_state = 20, .external_lex_state = 3},
+  [17] = {.lex_state = 20, .external_lex_state = 3},
+  [18] = {.lex_state = 20, .external_lex_state = 3},
+  [19] = {.lex_state = 0, .external_lex_state = 2},
+  [20] = {.lex_state = 0, .external_lex_state = 2},
+  [21] = {.lex_state = 0, .external_lex_state = 2},
+  [22] = {.lex_state = 0, .external_lex_state = 2},
+  [23] = {.lex_state = 0, .external_lex_state = 2},
+  [24] = {.lex_state = 0, .external_lex_state = 2},
+  [25] = {.lex_state = 0, .external_lex_state = 2},
+  [26] = {.lex_state = 0, .external_lex_state = 2},
+  [27] = {.lex_state = 0, .external_lex_state = 2},
+  [28] = {.lex_state = 0, .external_lex_state = 2},
+  [29] = {.lex_state = 0, .external_lex_state = 2},
+  [30] = {.lex_state = 0, .external_lex_state = 2},
+  [31] = {.lex_state = 0, .external_lex_state = 2},
+  [32] = {.lex_state = 0, .external_lex_state = 2},
+  [33] = {.lex_state = 0, .external_lex_state = 2},
+  [34] = {.lex_state = 0, .external_lex_state = 2},
+  [35] = {.lex_state = 0, .external_lex_state = 2},
+  [36] = {.lex_state = 0, .external_lex_state = 2},
+  [37] = {.lex_state = 0, .external_lex_state = 2},
+  [38] = {.lex_state = 0, .external_lex_state = 2},
+  [39] = {.lex_state = 0, .external_lex_state = 2},
+  [40] = {.lex_state = 0, .external_lex_state = 2},
+  [41] = {.lex_state = 0, .external_lex_state = 2},
+  [42] = {.lex_state = 0, .external_lex_state = 2},
+  [43] = {.lex_state = 0, .external_lex_state = 2},
+  [44] = {.lex_state = 0, .external_lex_state = 2},
+  [45] = {.lex_state = 0, .external_lex_state = 2},
+  [46] = {.lex_state = 0, .external_lex_state = 2},
+  [47] = {.lex_state = 0, .external_lex_state = 2},
+  [48] = {.lex_state = 0, .external_lex_state = 2},
+  [49] = {.lex_state = 0, .external_lex_state = 2},
+  [50] = {.lex_state = 0, .external_lex_state = 2},
+  [51] = {.lex_state = 0, .external_lex_state = 2},
+  [52] = {.lex_state = 0, .external_lex_state = 2},
+  [53] = {.lex_state = 0, .external_lex_state = 2},
+  [54] = {.lex_state = 0, .external_lex_state = 2},
+  [55] = {.lex_state = 0, .external_lex_state = 2},
+  [56] = {.lex_state = 0, .external_lex_state = 2},
+  [57] = {.lex_state = 0, .external_lex_state = 2},
+  [58] = {.lex_state = 0, .external_lex_state = 2},
+  [59] = {.lex_state = 19, .external_lex_state = 3},
+  [60] = {.lex_state = 19, .external_lex_state = 3},
+  [61] = {.lex_state = 19, .external_lex_state = 3},
+  [62] = {.lex_state = 19, .external_lex_state = 3},
+  [63] = {.lex_state = 19, .external_lex_state = 3},
+  [64] = {.lex_state = 19, .external_lex_state = 3},
+  [65] = {.lex_state = 20, .external_lex_state = 3},
+  [66] = {.lex_state = 19, .external_lex_state = 3},
+  [67] = {.lex_state = 19, .external_lex_state = 3},
+  [68] = {.lex_state = 19, .external_lex_state = 3},
+  [69] = {.lex_state = 19, .external_lex_state = 3},
+  [70] = {.lex_state = 19, .external_lex_state = 3},
+  [71] = {.lex_state = 19, .external_lex_state = 3},
+  [72] = {.lex_state = 19, .external_lex_state = 3},
+  [73] = {.lex_state = 19, .external_lex_state = 3},
+  [74] = {.lex_state = 19, .external_lex_state = 3},
+  [75] = {.lex_state = 19, .external_lex_state = 3},
+  [76] = {.lex_state = 19, .external_lex_state = 3},
+  [77] = {.lex_state = 19, .external_lex_state = 3},
+  [78] = {.lex_state = 19, .external_lex_state = 3},
+  [79] = {.lex_state = 19, .external_lex_state = 3},
+  [80] = {.lex_state = 19, .external_lex_state = 3},
+  [81] = {.lex_state = 19, .external_lex_state = 3},
+  [82] = {.lex_state = 19, .external_lex_state = 3},
+  [83] = {.lex_state = 19, .external_lex_state = 3},
+  [84] = {.lex_state = 19, .external_lex_state = 3},
+  [85] = {.lex_state = 19, .external_lex_state = 3},
+  [86] = {.lex_state = 19, .external_lex_state = 3},
+  [87] = {.lex_state = 19, .external_lex_state = 3},
+  [88] = {.lex_state = 19, .external_lex_state = 3},
+  [89] = {.lex_state = 19, .external_lex_state = 3},
+  [90] = {.lex_state = 19, .external_lex_state = 3},
+  [91] = {.lex_state = 19, .external_lex_state = 3},
+  [92] = {.lex_state = 19, .external_lex_state = 3},
+  [93] = {.lex_state = 19, .external_lex_state = 3},
+  [94] = {.lex_state = 19, .external_lex_state = 3},
+  [95] = {.lex_state = 19, .external_lex_state = 3},
+  [96] = {.lex_state = 19, .external_lex_state = 3},
+  [97] = {.lex_state = 19, .external_lex_state = 3},
+  [98] = {.lex_state = 0, .external_lex_state = 2},
+  [99] = {.lex_state = 0, .external_lex_state = 2},
+  [100] = {.lex_state = 20, .external_lex_state = 3},
+  [101] = {.lex_state = 0, .external_lex_state = 2},
+  [102] = {.lex_state = 0, .external_lex_state = 2},
+  [103] = {.lex_state = 0, .external_lex_state = 2},
+  [104] = {.lex_state = 0, .external_lex_state = 2},
+  [105] = {.lex_state = 0, .external_lex_state = 2},
+  [106] = {.lex_state = 0, .external_lex_state = 2},
+  [107] = {.lex_state = 0, .external_lex_state = 2},
+  [108] = {.lex_state = 0, .external_lex_state = 2},
+  [109] = {.lex_state = 0, .external_lex_state = 2},
+  [110] = {.lex_state = 0, .external_lex_state = 2},
+  [111] = {.lex_state = 0, .external_lex_state = 2},
+  [112] = {.lex_state = 0, .external_lex_state = 2},
+  [113] = {.lex_state = 0, .external_lex_state = 2},
+  [114] = {.lex_state = 0, .external_lex_state = 2},
+  [115] = {.lex_state = 0, .external_lex_state = 2},
+  [116] = {.lex_state = 0, .external_lex_state = 2},
+  [117] = {.lex_state = 0, .external_lex_state = 2},
+  [118] = {.lex_state = 0, .external_lex_state = 2},
+  [119] = {.lex_state = 0, .external_lex_state = 2},
+  [120] = {.lex_state = 0, .external_lex_state = 2},
+  [121] = {.lex_state = 0, .external_lex_state = 2},
+  [122] = {.lex_state = 0, .external_lex_state = 2},
+  [123] = {.lex_state = 0, .external_lex_state = 2},
+  [124] = {.lex_state = 0, .external_lex_state = 2},
+  [125] = {.lex_state = 0, .external_lex_state = 2},
+  [126] = {.lex_state = 0, .external_lex_state = 2},
+  [127] = {.lex_state = 0, .external_lex_state = 2},
+  [128] = {.lex_state = 0, .external_lex_state = 2},
+  [129] = {.lex_state = 0, .external_lex_state = 2},
+  [130] = {.lex_state = 0, .external_lex_state = 2},
+  [131] = {.lex_state = 0, .external_lex_state = 2},
+  [132] = {.lex_state = 0, .external_lex_state = 2},
+  [133] = {.lex_state = 0, .external_lex_state = 2},
+  [134] = {.lex_state = 0, .external_lex_state = 2},
+  [135] = {.lex_state = 0, .external_lex_state = 2},
+  [136] = {.lex_state = 0, .external_lex_state = 2},
+  [137] = {.lex_state = 0, .external_lex_state = 2},
+  [138] = {.lex_state = 0, .external_lex_state = 2},
+  [139] = {.lex_state = 0, .external_lex_state = 2},
+  [140] = {.lex_state = 0, .external_lex_state = 2},
+  [141] = {.lex_state = 0, .external_lex_state = 2},
+  [142] = {.lex_state = 0, .external_lex_state = 2},
+  [143] = {.lex_state = 0, .external_lex_state = 2},
+  [144] = {.lex_state = 0, .external_lex_state = 2},
+  [145] = {.lex_state = 0, .external_lex_state = 2},
+  [146] = {.lex_state = 0, .external_lex_state = 2},
+  [147] = {.lex_state = 0, .external_lex_state = 2},
+  [148] = {.lex_state = 0, .external_lex_state = 2},
+  [149] = {.lex_state = 0, .external_lex_state = 2},
+  [150] = {.lex_state = 0, .external_lex_state = 2},
+  [151] = {.lex_state = 0, .external_lex_state = 2},
+  [152] = {.lex_state = 0, .external_lex_state = 2},
+  [153] = {.lex_state = 19, .external_lex_state = 3},
+  [154] = {.lex_state = 0, .external_lex_state = 2},
+  [155] = {.lex_state = 0, .external_lex_state = 2},
+  [156] = {.lex_state = 20, .external_lex_state = 3},
+  [157] = {.lex_state = 20, .external_lex_state = 3},
+  [158] = {.lex_state = 0, .external_lex_state = 3},
+  [159] = {.lex_state = 0, .external_lex_state = 2},
+  [160] = {.lex_state = 20, .external_lex_state = 3},
+  [161] = {.lex_state = 0, .external_lex_state = 2},
+  [162] = {.lex_state = 0, .external_lex_state = 2},
+  [163] = {.lex_state = 20, .external_lex_state = 3},
+  [164] = {.lex_state = 0, .external_lex_state = 2},
+  [165] = {.lex_state = 0, .external_lex_state = 2},
+  [166] = {.lex_state = 0, .external_lex_state = 2},
+  [167] = {.lex_state = 0, .external_lex_state = 2},
+  [168] = {.lex_state = 0, .external_lex_state = 2},
+  [169] = {.lex_state = 0, .external_lex_state = 2},
+  [170] = {.lex_state = 0, .external_lex_state = 2},
+  [171] = {.lex_state = 0, .external_lex_state = 2},
+  [172] = {.lex_state = 0, .external_lex_state = 2},
+  [173] = {.lex_state = 0, .external_lex_state = 3},
+  [174] = {.lex_state = 0, .external_lex_state = 2},
+  [175] = {.lex_state = 0, .external_lex_state = 2},
+  [176] = {.lex_state = 2, .external_lex_state = 2},
+  [177] = {.lex_state = 2, .external_lex_state = 2},
+  [178] = {.lex_state = 0, .external_lex_state = 2},
+  [179] = {.lex_state = 0, .external_lex_state = 2},
+  [180] = {.lex_state = 1, .external_lex_state = 2},
+  [181] = {.lex_state = 0, .external_lex_state = 2},
+  [182] = {.lex_state = 1, .external_lex_state = 2},
+  [183] = {.lex_state = 2, .external_lex_state = 2},
+  [184] = {.lex_state = 0, .external_lex_state = 2},
+  [185] = {.lex_state = 19, .external_lex_state = 2},
+  [186] = {.lex_state = 0, .external_lex_state = 2},
+  [187] = {.lex_state = 1, .external_lex_state = 2},
+  [188] = {.lex_state = 0, .external_lex_state = 2},
+  [189] = {.lex_state = 1, .external_lex_state = 2},
+  [190] = {.lex_state = 2, .external_lex_state = 2},
+  [191] = {.lex_state = 1, .external_lex_state = 2},
+  [192] = {.lex_state = 2, .external_lex_state = 2},
+  [193] = {.lex_state = 20, .external_lex_state = 2},
+  [194] = {.lex_state = 0, .external_lex_state = 2},
+  [195] = {.lex_state = 20, .external_lex_state = 2},
+  [196] = {.lex_state = 0, .external_lex_state = 2},
+  [197] = {.lex_state = 20, .external_lex_state = 2},
+  [198] = {.lex_state = 0, .external_lex_state = 2},
+  [199] = {.lex_state = 0, .external_lex_state = 2},
+  [200] = {.lex_state = 0, .external_lex_state = 2},
+  [201] = {.lex_state = 0, .external_lex_state = 2},
+  [202] = {.lex_state = 0, .external_lex_state = 2},
+  [203] = {.lex_state = 0, .external_lex_state = 2},
+  [204] = {.lex_state = 20, .external_lex_state = 2},
+  [205] = {.lex_state = 1, .external_lex_state = 2},
+  [206] = {.lex_state = 2, .external_lex_state = 2},
+  [207] = {.lex_state = 0, .external_lex_state = 2},
+  [208] = {.lex_state = 0, .external_lex_state = 2},
+  [209] = {.lex_state = 0, .external_lex_state = 2},
+  [210] = {.lex_state = 0, .external_lex_state = 2},
+  [211] = {.lex_state = 0, .external_lex_state = 2},
+  [212] = {.lex_state = 19, .external_lex_state = 2},
+  [213] = {.lex_state = 19, .external_lex_state = 2},
+  [214] = {.lex_state = 0, .external_lex_state = 2},
+  [215] = {.lex_state = 0, .external_lex_state = 2},
+  [216] = {.lex_state = 0, .external_lex_state = 2},
+  [217] = {.lex_state = 0, .external_lex_state = 2},
+  [218] = {.lex_state = 0, .external_lex_state = 2},
+  [219] = {.lex_state = 0, .external_lex_state = 4},
+  [220] = {.lex_state = 0, .external_lex_state = 2},
+  [221] = {.lex_state = 0, .external_lex_state = 2},
+  [222] = {.lex_state = 0, .external_lex_state = 2},
+  [223] = {.lex_state = 0, .external_lex_state = 2},
+  [224] = {.lex_state = 0, .external_lex_state = 2},
+  [225] = {.lex_state = 0, .external_lex_state = 2},
+  [226] = {.lex_state = 0, .external_lex_state = 2},
+  [227] = {.lex_state = 0, .external_lex_state = 2},
+  [228] = {.lex_state = 0, .external_lex_state = 2},
+  [229] = {.lex_state = 0, .external_lex_state = 2},
+  [230] = {.lex_state = 19, .external_lex_state = 2},
+  [231] = {.lex_state = 0, .external_lex_state = 2},
+  [232] = {.lex_state = 0, .external_lex_state = 2},
+  [233] = {.lex_state = 0, .external_lex_state = 2},
+  [234] = {.lex_state = 0, .external_lex_state = 2},
+  [235] = {.lex_state = 0, .external_lex_state = 2},
+  [236] = {.lex_state = 0, .external_lex_state = 2},
+  [237] = {.lex_state = 0, .external_lex_state = 2},
+  [238] = {.lex_state = 0, .external_lex_state = 2},
+  [239] = {.lex_state = 0, .external_lex_state = 2},
+  [240] = {.lex_state = 0, .external_lex_state = 5},
+  [241] = {.lex_state = 0, .external_lex_state = 2},
+  [242] = {.lex_state = 0, .external_lex_state = 2},
+  [243] = {.lex_state = 0, .external_lex_state = 2},
+  [244] = {.lex_state = 0, .external_lex_state = 2},
+  [245] = {.lex_state = 0, .external_lex_state = 2},
+  [246] = {.lex_state = 0, .external_lex_state = 2},
+  [247] = {.lex_state = 0, .external_lex_state = 6},
+  [248] = {.lex_state = 0, .external_lex_state = 2},
+  [249] = {.lex_state = 0, .external_lex_state = 2},
+  [250] = {.lex_state = 0, .external_lex_state = 2},
+  [251] = {.lex_state = 0, .external_lex_state = 2},
+  [252] = {.lex_state = 0, .external_lex_state = 2},
+  [253] = {.lex_state = 82, .external_lex_state = 2},
+  [254] = {.lex_state = 0, .external_lex_state = 5},
+  [255] = {.lex_state = 0, .external_lex_state = 7},
+  [256] = {.lex_state = 0, .external_lex_state = 2},
+  [257] = {.lex_state = 0, .external_lex_state = 2},
+  [258] = {.lex_state = 0, .external_lex_state = 6},
+  [259] = {.lex_state = 0, .external_lex_state = 2},
+  [260] = {(TSStateId)(-1),},
+  [261] = {(TSStateId)(-1),},
+};
+
+static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
+  [STATE(0)] = {
+    [sym_comment] = STATE(0),
+    [ts_builtin_sym_end] = ACTIONS(1),
+    [sym_identifier] = ACTIONS(1),
+    [anon_sym_return] = ACTIONS(1),
+    [anon_sym_SEMI] = ACTIONS(1),
+    [anon_sym_EQ] = ACTIONS(1),
+    [anon_sym_COMMA] = ACTIONS(1),
+    [anon_sym_COLON_COLON] = ACTIONS(1),
+    [sym_break_statement] = ACTIONS(1),
+    [anon_sym_goto] = ACTIONS(1),
+    [anon_sym_do] = ACTIONS(1),
+    [anon_sym_end] = ACTIONS(1),
+    [anon_sym_while] = ACTIONS(1),
+    [anon_sym_repeat] = ACTIONS(1),
+    [anon_sym_until] = ACTIONS(1),
+    [anon_sym_if] = ACTIONS(1),
+    [anon_sym_then] = ACTIONS(1),
+    [anon_sym_elseif] = ACTIONS(1),
+    [anon_sym_else] = ACTIONS(1),
+    [anon_sym_for] = ACTIONS(1),
+    [anon_sym_in] = ACTIONS(1),
+    [anon_sym_function] = ACTIONS(1),
+    [anon_sym_local] = ACTIONS(1),
+    [anon_sym_DOT] = ACTIONS(1),
+    [anon_sym_COLON] = ACTIONS(1),
+    [anon_sym_LT] = ACTIONS(1),
+    [anon_sym_GT] = ACTIONS(1),
+    [sym_nil] = ACTIONS(1),
+    [sym_false] = ACTIONS(1),
+    [sym_true] = ACTIONS(1),
+    [sym_number] = ACTIONS(1),
+    [anon_sym_DQUOTE] = ACTIONS(1),
+    [anon_sym_SQUOTE] = ACTIONS(1),
+    [sym_escape_sequence] = ACTIONS(1),
+    [anon_sym_LPAREN] = ACTIONS(1),
+    [anon_sym_RPAREN] = ACTIONS(1),
+    [anon_sym_LBRACK] = ACTIONS(1),
+    [anon_sym_RBRACK] = ACTIONS(1),
+    [anon_sym_LBRACE] = ACTIONS(1),
+    [anon_sym_RBRACE] = ACTIONS(1),
+    [anon_sym_or] = ACTIONS(1),
+    [anon_sym_and] = ACTIONS(1),
+    [anon_sym_LT_EQ] = ACTIONS(1),
+    [anon_sym_EQ_EQ] = ACTIONS(1),
+    [anon_sym_TILDE_EQ] = ACTIONS(1),
+    [anon_sym_GT_EQ] = ACTIONS(1),
+    [anon_sym_PIPE] = ACTIONS(1),
+    [anon_sym_TILDE] = ACTIONS(1),
+    [anon_sym_AMP] = ACTIONS(1),
+    [anon_sym_LT_LT] = ACTIONS(1),
+    [anon_sym_GT_GT] = ACTIONS(1),
+    [anon_sym_PLUS] = ACTIONS(1),
+    [anon_sym_DASH] = ACTIONS(1),
+    [anon_sym_STAR] = ACTIONS(1),
+    [anon_sym_SLASH] = ACTIONS(1),
+    [anon_sym_SLASH_SLASH] = ACTIONS(1),
+    [anon_sym_PERCENT] = ACTIONS(1),
+    [anon_sym_DOT_DOT] = ACTIONS(1),
+    [anon_sym_CARET] = ACTIONS(1),
+    [anon_sym_not] = ACTIONS(1),
+    [anon_sym_POUND] = ACTIONS(1),
+    [anon_sym_DASH_DASH] = ACTIONS(3),
+    [sym__block_comment_start] = ACTIONS(5),
+    [sym__block_comment_content] = ACTIONS(1),
+    [sym__block_comment_end] = ACTIONS(1),
+    [sym__block_string_start] = ACTIONS(1),
+    [sym__block_string_content] = ACTIONS(1),
+    [sym__block_string_end] = ACTIONS(1),
+  },
+  [STATE(1)] = {
+    [sym_chunk] = STATE(250),
+    [sym_statement] = STATE(151),
+    [sym_return_statement] = STATE(242),
+    [sym_empty_statement] = STATE(135),
+    [sym_assignment_statement] = STATE(135),
+    [sym__variable_assignment_varlist] = STATE(225),
+    [sym_label_statement] = STATE(135),
+    [sym_goto_statement] = STATE(135),
+    [sym_do_statement] = STATE(135),
+    [sym_while_statement] = STATE(135),
+    [sym_repeat_statement] = STATE(135),
+    [sym_if_statement] = STATE(135),
+    [sym_for_statement] = STATE(135),
+    [sym_declaration] = STATE(134),
+    [sym_function_declaration] = STATE(136),
+    [sym__local_function_declaration] = STATE(148),
+    [sym_variable_declaration] = STATE(152),
+    [sym__prefix_expression] = STATE(156),
+    [sym_variable] = STATE(157),
+    [sym_bracket_index_expression] = STATE(2),
+    [sym_dot_index_expression] = STATE(2),
+    [sym_function_call] = STATE(100),
+    [sym_method_index_expression] = STATE(158),
+    [sym_parenthesized_expression] = STATE(163),
+    [sym_comment] = STATE(1),
+    [aux_sym_chunk_repeat1] = STATE(58),
+    [ts_builtin_sym_end] = ACTIONS(7),
+    [sym_identifier] = ACTIONS(9),
+    [sym_hash_bang_line] = ACTIONS(11),
+    [anon_sym_return] = ACTIONS(13),
+    [anon_sym_SEMI] = ACTIONS(15),
+    [anon_sym_COLON_COLON] = ACTIONS(17),
+    [sym_break_statement] = ACTIONS(19),
+    [anon_sym_goto] = ACTIONS(21),
+    [anon_sym_do] = ACTIONS(23),
+    [anon_sym_while] = ACTIONS(25),
+    [anon_sym_repeat] = ACTIONS(27),
+    [anon_sym_if] = ACTIONS(29),
+    [anon_sym_for] = ACTIONS(31),
+    [anon_sym_function] = ACTIONS(33),
+    [anon_sym_local] = ACTIONS(35),
+    [anon_sym_LPAREN] = ACTIONS(37),
+    [anon_sym_DASH_DASH] = ACTIONS(3),
+    [sym__block_comment_start] = ACTIONS(5),
+  },
+};
+
+static const uint16_t ts_small_parse_table[] = {
+  [0] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(2), 1,
+      sym_comment,
+    ACTIONS(41), 26,
+      anon_sym_return,
+      anon_sym_EQ,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(39), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [67] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(3), 1,
+      sym_comment,
+    ACTIONS(45), 26,
+      anon_sym_return,
+      anon_sym_EQ,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(43), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [134] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(4), 1,
+      sym_comment,
+    ACTIONS(49), 26,
+      anon_sym_return,
+      anon_sym_EQ,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(47), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [201] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(5), 1,
+      sym_comment,
+    ACTIONS(53), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(51), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [267] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(6), 1,
+      sym_comment,
+    ACTIONS(57), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(55), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [333] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(7), 1,
+      sym_comment,
+    ACTIONS(61), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(59), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [399] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(8), 1,
+      sym_comment,
+    ACTIONS(65), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(63), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [465] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(9), 1,
+      sym_comment,
+    ACTIONS(71), 2,
+      anon_sym_DOT,
+      anon_sym_COLON,
+    ACTIONS(73), 6,
+      sym__block_string_start,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_LBRACK,
+      anon_sym_LBRACE,
+    ACTIONS(67), 21,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(69), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [535] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(10), 1,
+      sym_comment,
+    ACTIONS(77), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(75), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [601] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(11), 1,
+      sym_comment,
+    ACTIONS(81), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(79), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [667] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(12), 1,
+      sym_comment,
+    ACTIONS(85), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(83), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [733] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(13), 1,
+      sym_comment,
+    ACTIONS(89), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(87), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [799] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(14), 1,
+      sym_comment,
+    ACTIONS(89), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(87), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [865] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(15), 1,
+      sym_comment,
+    ACTIONS(93), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(91), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [931] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(16), 1,
+      sym_comment,
+    ACTIONS(97), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(95), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [997] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(17), 1,
+      sym_comment,
+    ACTIONS(101), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(99), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [1063] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(18), 1,
+      sym_comment,
+    ACTIONS(105), 25,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+    ACTIONS(103), 27,
+      sym__block_string_start,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [1129] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(19), 1,
+      sym_comment,
+    ACTIONS(51), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(53), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [1188] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(20), 1,
+      sym_comment,
+    ACTIONS(91), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(93), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [1247] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(21), 1,
+      sym_comment,
+    ACTIONS(95), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(97), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [1306] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    STATE(22), 1,
+      sym_comment,
+    ACTIONS(107), 21,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+    ACTIONS(109), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [1367] = 39,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(113), 1,
+      anon_sym_return,
+    ACTIONS(115), 1,
+      anon_sym_end,
+    ACTIONS(117), 1,
+      anon_sym_elseif,
+    ACTIONS(119), 1,
+      anon_sym_else,
+    STATE(23), 1,
+      sym_comment,
+    STATE(43), 1,
+      aux_sym_chunk_repeat1,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(164), 1,
+      aux_sym_if_statement_repeat1,
+    STATE(165), 1,
+      sym__block,
+    STATE(186), 1,
+      sym_return_statement,
+    STATE(198), 1,
+      sym_elseif_statement,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(245), 1,
+      sym_else_statement,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [1494] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(24), 1,
+      sym_comment,
+    ACTIONS(67), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(69), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [1553] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(25), 1,
+      sym_comment,
+    ACTIONS(99), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(101), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [1612] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(26), 1,
+      sym_comment,
+    ACTIONS(121), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(123), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [1671] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(27), 1,
+      sym_comment,
+    ACTIONS(103), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(105), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [1730] = 15,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    STATE(28), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(125), 12,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+    ACTIONS(127), 20,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      sym_identifier,
+  [1809] = 17,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    STATE(29), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+    ACTIONS(125), 8,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+    ACTIONS(127), 18,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_or,
+      anon_sym_and,
+      sym_identifier,
+  [1892] = 14,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    STATE(30), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(125), 13,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+    ACTIONS(127), 20,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      sym_identifier,
+  [1969] = 13,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    STATE(31), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(125), 13,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+    ACTIONS(127), 21,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      sym_identifier,
+  [2044] = 12,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    STATE(32), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(125), 14,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+    ACTIONS(127), 21,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      sym_identifier,
+  [2117] = 11,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    STATE(33), 1,
+      sym_comment,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(125), 16,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(127), 21,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      sym_identifier,
+  [2188] = 8,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    STATE(34), 1,
+      sym_comment,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(125), 18,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_DOT_DOT,
+    ACTIONS(127), 22,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      sym_identifier,
+  [2253] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    STATE(35), 1,
+      sym_comment,
+    ACTIONS(125), 21,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+    ACTIONS(127), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [2314] = 11,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    STATE(36), 1,
+      sym_comment,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(125), 16,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(127), 21,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      sym_identifier,
+  [2385] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    STATE(37), 1,
+      sym_comment,
+    ACTIONS(125), 21,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+    ACTIONS(127), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [2446] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(38), 1,
+      sym_comment,
+    ACTIONS(87), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(89), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [2505] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(39), 1,
+      sym_comment,
+    ACTIONS(87), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(89), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [2564] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(40), 1,
+      sym_comment,
+    ACTIONS(151), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(153), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [2623] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(41), 1,
+      sym_comment,
+    ACTIONS(155), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+    ACTIONS(157), 23,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+      sym_identifier,
+  [2682] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(159), 1,
+      anon_sym_and,
+    STATE(42), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+    ACTIONS(125), 8,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_RBRACK,
+      anon_sym_RBRACE,
+    ACTIONS(127), 17,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_then,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      anon_sym_or,
+      sym_identifier,
+  [2767] = 33,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(113), 1,
+      anon_sym_return,
+    STATE(43), 1,
+      sym_comment,
+    STATE(45), 1,
+      aux_sym_chunk_repeat1,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(178), 1,
+      sym_return_statement,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(161), 4,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+      anon_sym_else,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [2879] = 34,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(113), 1,
+      anon_sym_return,
+    STATE(43), 1,
+      aux_sym_chunk_repeat1,
+    STATE(44), 1,
+      sym_comment,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(186), 1,
+      sym_return_statement,
+    STATE(200), 1,
+      sym__block,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(163), 3,
+      anon_sym_end,
+      anon_sym_elseif,
+      anon_sym_else,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [2993] = 31,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(165), 1,
+      ts_builtin_sym_end,
+    ACTIONS(167), 1,
+      sym_identifier,
+    ACTIONS(172), 1,
+      anon_sym_SEMI,
+    ACTIONS(175), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(178), 1,
+      sym_break_statement,
+    ACTIONS(181), 1,
+      anon_sym_goto,
+    ACTIONS(184), 1,
+      anon_sym_do,
+    ACTIONS(187), 1,
+      anon_sym_while,
+    ACTIONS(190), 1,
+      anon_sym_repeat,
+    ACTIONS(193), 1,
+      anon_sym_if,
+    ACTIONS(196), 1,
+      anon_sym_for,
+    ACTIONS(199), 1,
+      anon_sym_function,
+    ACTIONS(202), 1,
+      anon_sym_local,
+    ACTIONS(205), 1,
+      anon_sym_LPAREN,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(45), 2,
+      sym_comment,
+      aux_sym_chunk_repeat1,
+    ACTIONS(170), 5,
+      anon_sym_return,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+      anon_sym_else,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [3101] = 21,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(159), 1,
+      anon_sym_and,
+    ACTIONS(212), 1,
+      anon_sym_COMMA,
+    ACTIONS(214), 1,
+      anon_sym_or,
+    STATE(46), 1,
+      sym_comment,
+    STATE(121), 1,
+      aux_sym__variable_assignment_explist_repeat1,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+    ACTIONS(208), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(210), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [3189] = 19,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(159), 1,
+      anon_sym_and,
+    ACTIONS(214), 1,
+      anon_sym_or,
+    STATE(47), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+    ACTIONS(216), 5,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(218), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [3272] = 34,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(113), 1,
+      anon_sym_return,
+    ACTIONS(220), 1,
+      anon_sym_end,
+    STATE(43), 1,
+      aux_sym_chunk_repeat1,
+    STATE(48), 1,
+      sym_comment,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(186), 1,
+      sym_return_statement,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(226), 1,
+      sym__block,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [3384] = 34,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(113), 1,
+      anon_sym_return,
+    ACTIONS(222), 1,
+      anon_sym_end,
+    STATE(43), 1,
+      aux_sym_chunk_repeat1,
+    STATE(49), 1,
+      sym_comment,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(186), 1,
+      sym_return_statement,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(233), 1,
+      sym__block,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [3496] = 34,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(113), 1,
+      anon_sym_return,
+    ACTIONS(224), 1,
+      anon_sym_end,
+    STATE(43), 1,
+      aux_sym_chunk_repeat1,
+    STATE(50), 1,
+      sym_comment,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(186), 1,
+      sym_return_statement,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(246), 1,
+      sym__block,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [3608] = 19,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(159), 1,
+      anon_sym_and,
+    ACTIONS(214), 1,
+      anon_sym_or,
+    STATE(51), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+    ACTIONS(226), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(228), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [3690] = 34,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(113), 1,
+      anon_sym_return,
+    ACTIONS(230), 1,
+      anon_sym_until,
+    STATE(43), 1,
+      aux_sym_chunk_repeat1,
+    STATE(52), 1,
+      sym_comment,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(186), 1,
+      sym_return_statement,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(227), 1,
+      sym__block,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [3802] = 19,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(159), 1,
+      anon_sym_and,
+    ACTIONS(214), 1,
+      anon_sym_or,
+    STATE(53), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+    ACTIONS(232), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(234), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [3884] = 34,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(113), 1,
+      anon_sym_return,
+    ACTIONS(236), 1,
+      anon_sym_end,
+    STATE(43), 1,
+      aux_sym_chunk_repeat1,
+    STATE(54), 1,
+      sym_comment,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(186), 1,
+      sym_return_statement,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(243), 1,
+      sym__block,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [3996] = 34,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(113), 1,
+      anon_sym_return,
+    ACTIONS(238), 1,
+      anon_sym_end,
+    STATE(43), 1,
+      aux_sym_chunk_repeat1,
+    STATE(55), 1,
+      sym_comment,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(186), 1,
+      sym_return_statement,
+    STATE(216), 1,
+      sym__block,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [4108] = 33,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(13), 1,
+      anon_sym_return,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(240), 1,
+      ts_builtin_sym_end,
+    STATE(56), 1,
+      sym_comment,
+    STATE(57), 1,
+      aux_sym_chunk_repeat1,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(238), 1,
+      sym_return_statement,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [4217] = 33,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(13), 1,
+      anon_sym_return,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(242), 1,
+      ts_builtin_sym_end,
+    STATE(45), 1,
+      aux_sym_chunk_repeat1,
+    STATE(57), 1,
+      sym_comment,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(235), 1,
+      sym_return_statement,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [4326] = 33,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(13), 1,
+      anon_sym_return,
+    ACTIONS(15), 1,
+      anon_sym_SEMI,
+    ACTIONS(17), 1,
+      anon_sym_COLON_COLON,
+    ACTIONS(19), 1,
+      sym_break_statement,
+    ACTIONS(21), 1,
+      anon_sym_goto,
+    ACTIONS(23), 1,
+      anon_sym_do,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_repeat,
+    ACTIONS(29), 1,
+      anon_sym_if,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_function,
+    ACTIONS(35), 1,
+      anon_sym_local,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(240), 1,
+      ts_builtin_sym_end,
+    STATE(45), 1,
+      aux_sym_chunk_repeat1,
+    STATE(58), 1,
+      sym_comment,
+    STATE(100), 1,
+      sym_function_call,
+    STATE(134), 1,
+      sym_declaration,
+    STATE(136), 1,
+      sym_function_declaration,
+    STATE(148), 1,
+      sym__local_function_declaration,
+    STATE(151), 1,
+      sym_statement,
+    STATE(152), 1,
+      sym_variable_declaration,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(157), 1,
+      sym_variable,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(163), 1,
+      sym_parenthesized_expression,
+    STATE(225), 1,
+      sym__variable_assignment_varlist,
+    STATE(238), 1,
+      sym_return_statement,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(135), 9,
+      sym_empty_statement,
+      sym_assignment_statement,
+      sym_label_statement,
+      sym_goto_statement,
+      sym_do_statement,
+      sym_while_statement,
+      sym_repeat_statement,
+      sym_if_statement,
+      sym_for_statement,
+  [4435] = 25,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(244), 1,
+      anon_sym_SEMI,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(59), 1,
+      sym_comment,
+    STATE(99), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(167), 1,
+      sym__expression_list,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    ACTIONS(246), 4,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+      anon_sym_else,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [4526] = 26,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    ACTIONS(266), 1,
+      sym_identifier,
+    ACTIONS(268), 1,
+      anon_sym_LBRACK,
+    ACTIONS(270), 1,
+      anon_sym_RBRACE,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(60), 1,
+      sym_comment,
+    STATE(105), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(169), 1,
+      sym_field,
+    STATE(252), 1,
+      sym__field_list,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [4617] = 26,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    ACTIONS(266), 1,
+      sym_identifier,
+    ACTIONS(268), 1,
+      anon_sym_LBRACK,
+    ACTIONS(272), 1,
+      anon_sym_RBRACE,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(61), 1,
+      sym_comment,
+    STATE(105), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(169), 1,
+      sym_field,
+    STATE(257), 1,
+      sym__field_list,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [4708] = 25,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    ACTIONS(266), 1,
+      sym_identifier,
+    ACTIONS(268), 1,
+      anon_sym_LBRACK,
+    ACTIONS(274), 1,
+      anon_sym_RBRACE,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(62), 1,
+      sym_comment,
+    STATE(105), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(211), 1,
+      sym_field,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [4796] = 25,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(244), 1,
+      anon_sym_SEMI,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    ACTIONS(276), 1,
+      ts_builtin_sym_end,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(63), 1,
+      sym_comment,
+    STATE(99), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(167), 1,
+      sym__expression_list,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [4884] = 25,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    ACTIONS(266), 1,
+      sym_identifier,
+    ACTIONS(268), 1,
+      anon_sym_LBRACK,
+    ACTIONS(278), 1,
+      anon_sym_RBRACE,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(64), 1,
+      sym_comment,
+    STATE(105), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(211), 1,
+      sym_field,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [4972] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(280), 1,
+      anon_sym_EQ,
+    STATE(65), 1,
+      sym_comment,
+    ACTIONS(41), 6,
+      anon_sym_DOT,
+      anon_sym_LT,
+      anon_sym_GT,
+      anon_sym_TILDE,
+      anon_sym_DASH,
+      anon_sym_SLASH,
+    ACTIONS(39), 26,
+      sym__block_string_start,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_LBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_or,
+      anon_sym_and,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+      anon_sym_PIPE,
+      anon_sym_AMP,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_DOT_DOT,
+      anon_sym_CARET,
+  [5021] = 24,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    ACTIONS(266), 1,
+      sym_identifier,
+    ACTIONS(268), 1,
+      anon_sym_LBRACK,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(66), 1,
+      sym_comment,
+    STATE(105), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(211), 1,
+      sym_field,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5106] = 23,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    ACTIONS(282), 1,
+      anon_sym_RPAREN,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(67), 1,
+      sym_comment,
+    STATE(102), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5188] = 23,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(46), 1,
+      sym_expression,
+    STATE(68), 1,
+      sym_comment,
+    STATE(144), 1,
+      sym__variable_assignment_explist,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5270] = 23,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(69), 1,
+      sym_comment,
+    STATE(99), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(217), 1,
+      sym__expression_list,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5352] = 23,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(46), 1,
+      sym_expression,
+    STATE(70), 1,
+      sym_comment,
+    STATE(130), 1,
+      sym__variable_assignment_explist,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5434] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(71), 1,
+      sym_comment,
+    STATE(115), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5513] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(51), 1,
+      sym_expression,
+    STATE(72), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5592] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(53), 1,
+      sym_expression,
+    STATE(73), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5671] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(74), 1,
+      sym_comment,
+    STATE(103), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5750] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(75), 1,
+      sym_comment,
+    STATE(110), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5829] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(76), 1,
+      sym_comment,
+    STATE(116), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5908] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(77), 1,
+      sym_comment,
+    STATE(113), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [5987] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(22), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(78), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6066] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(79), 1,
+      sym_comment,
+    STATE(114), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6145] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(80), 1,
+      sym_comment,
+    STATE(98), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6224] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(28), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(81), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6303] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(82), 1,
+      sym_comment,
+    STATE(112), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6382] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(83), 1,
+      sym_comment,
+    STATE(119), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6461] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(47), 1,
+      sym_expression,
+    STATE(84), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6540] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(29), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(85), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6619] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(30), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(86), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6698] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(31), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(87), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6777] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(32), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(88), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6856] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(89), 1,
+      sym_comment,
+    STATE(106), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [6935] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(33), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(90), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [7014] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(34), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(91), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [7093] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(92), 1,
+      sym_comment,
+    STATE(104), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [7172] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(35), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(93), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [7251] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(36), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(94), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [7330] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(95), 1,
+      sym_comment,
+    STATE(118), 1,
+      sym_expression,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [7409] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(37), 1,
+      sym_expression,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(96), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [7488] = 22,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(9), 1,
+      sym_identifier,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(248), 1,
+      anon_sym_function,
+    ACTIONS(254), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(256), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(258), 1,
+      anon_sym_LBRACE,
+    ACTIONS(264), 1,
+      sym__block_string_start,
+    STATE(38), 1,
+      sym__quote_string,
+    STATE(39), 1,
+      sym__block_string,
+    STATE(42), 1,
+      sym_expression,
+    STATE(97), 1,
+      sym_comment,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    ACTIONS(252), 2,
+      sym_number,
+      sym_vararg_expression,
+    ACTIONS(260), 2,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+    ACTIONS(262), 2,
+      anon_sym_DASH,
+      anon_sym_not,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    ACTIONS(250), 3,
+      sym_nil,
+      sym_false,
+      sym_true,
+    STATE(9), 3,
+      sym_variable,
+      sym_function_call,
+      sym_parenthesized_expression,
+    STATE(24), 5,
+      sym_string,
+      sym_function_definition,
+      sym_table_constructor,
+      sym_binary_expression,
+      sym_unary_expression,
+  [7567] = 19,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(286), 1,
+      anon_sym_else,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    STATE(98), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+    ACTIONS(284), 8,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+      anon_sym_RPAREN,
+  [7639] = 21,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(294), 1,
+      anon_sym_COMMA,
+    ACTIONS(296), 1,
+      anon_sym_else,
+    STATE(99), 1,
+      sym_comment,
+    STATE(161), 1,
+      aux_sym__expression_list_repeat1,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+    ACTIONS(292), 6,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+  [7715] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(71), 1,
+      anon_sym_COLON,
+    STATE(100), 1,
+      sym_comment,
+    ACTIONS(298), 3,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+    ACTIONS(73), 7,
+      sym__block_string_start,
+      anon_sym_DOT,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_LBRACK,
+      anon_sym_LBRACE,
+    ACTIONS(300), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [7759] = 9,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(306), 1,
+      anon_sym_COMMA,
+    ACTIONS(308), 1,
+      anon_sym_LT,
+    STATE(101), 1,
+      sym_comment,
+    STATE(108), 1,
+      sym__attrib,
+    STATE(117), 1,
+      aux_sym__att_name_list_repeat1,
+    ACTIONS(302), 5,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_EQ,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(304), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [7805] = 20,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(294), 1,
+      anon_sym_COMMA,
+    ACTIONS(310), 1,
+      anon_sym_RPAREN,
+    STATE(102), 1,
+      sym_comment,
+    STATE(201), 1,
+      aux_sym__expression_list_repeat1,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [7873] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    STATE(103), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(312), 3,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [7937] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    STATE(104), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(314), 3,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8001] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    STATE(105), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(316), 3,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8065] = 19,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(318), 1,
+      anon_sym_COMMA,
+    ACTIONS(320), 1,
+      anon_sym_do,
+    STATE(106), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8130] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(308), 1,
+      anon_sym_LT,
+    STATE(107), 1,
+      sym_comment,
+    STATE(120), 1,
+      sym__attrib,
+    ACTIONS(322), 6,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_EQ,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(324), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [8171] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(306), 1,
+      anon_sym_COMMA,
+    STATE(108), 1,
+      sym_comment,
+    STATE(109), 1,
+      aux_sym__att_name_list_repeat1,
+    ACTIONS(326), 5,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_EQ,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(328), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [8211] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(306), 1,
+      anon_sym_COMMA,
+    STATE(109), 1,
+      sym_comment,
+    STATE(111), 1,
+      aux_sym__att_name_list_repeat1,
+    ACTIONS(330), 5,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_EQ,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(332), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [8251] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(334), 1,
+      anon_sym_RBRACK,
+    STATE(110), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8313] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(340), 1,
+      anon_sym_COMMA,
+    STATE(111), 2,
+      sym_comment,
+      aux_sym__att_name_list_repeat1,
+    ACTIONS(336), 5,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_EQ,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(338), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [8351] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(343), 1,
+      anon_sym_then,
+    STATE(112), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8413] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(345), 1,
+      anon_sym_do,
+    STATE(113), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8475] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(347), 1,
+      anon_sym_RBRACK,
+    STATE(114), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8537] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(349), 1,
+      anon_sym_then,
+    STATE(115), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8599] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(351), 1,
+      anon_sym_RPAREN,
+    STATE(116), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8661] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(306), 1,
+      anon_sym_COMMA,
+    STATE(111), 1,
+      aux_sym__att_name_list_repeat1,
+    STATE(117), 1,
+      sym_comment,
+    ACTIONS(353), 5,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_EQ,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(355), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [8701] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(357), 1,
+      anon_sym_do,
+    STATE(118), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8763] = 18,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(111), 1,
+      anon_sym_CARET,
+    ACTIONS(129), 1,
+      anon_sym_PIPE,
+    ACTIONS(131), 1,
+      anon_sym_TILDE,
+    ACTIONS(133), 1,
+      anon_sym_AMP,
+    ACTIONS(137), 1,
+      anon_sym_PLUS,
+    ACTIONS(139), 1,
+      anon_sym_DASH,
+    ACTIONS(143), 1,
+      anon_sym_SLASH,
+    ACTIONS(145), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(288), 1,
+      anon_sym_or,
+    ACTIONS(290), 1,
+      anon_sym_and,
+    ACTIONS(359), 1,
+      anon_sym_COMMA,
+    STATE(119), 1,
+      sym_comment,
+    ACTIONS(135), 2,
+      anon_sym_LT_LT,
+      anon_sym_GT_GT,
+    ACTIONS(147), 2,
+      anon_sym_LT,
+      anon_sym_GT,
+    ACTIONS(141), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(149), 4,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_EQ,
+      anon_sym_TILDE_EQ,
+      anon_sym_GT_EQ,
+  [8825] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(120), 1,
+      sym_comment,
+    ACTIONS(361), 6,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_EQ,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(363), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [8860] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(212), 1,
+      anon_sym_COMMA,
+    STATE(121), 1,
+      sym_comment,
+    STATE(122), 1,
+      aux_sym__variable_assignment_explist_repeat1,
+    ACTIONS(365), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(367), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [8899] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(373), 1,
+      anon_sym_COMMA,
+    STATE(122), 2,
+      sym_comment,
+      aux_sym__variable_assignment_explist_repeat1,
+    ACTIONS(369), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(371), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [8936] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(123), 1,
+      sym_comment,
+    ACTIONS(376), 6,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_EQ,
+      anon_sym_COMMA,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(378), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [8971] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(384), 1,
+      anon_sym_EQ,
+    STATE(124), 1,
+      sym_comment,
+    ACTIONS(380), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(382), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9007] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(125), 1,
+      sym_comment,
+    ACTIONS(386), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(388), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9040] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(126), 1,
+      sym_comment,
+    ACTIONS(390), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(392), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9073] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(127), 1,
+      sym_comment,
+    ACTIONS(394), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(396), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9106] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(128), 1,
+      sym_comment,
+    ACTIONS(398), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(400), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9139] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(129), 1,
+      sym_comment,
+    ACTIONS(402), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(404), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9172] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(130), 1,
+      sym_comment,
+    ACTIONS(406), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(408), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9205] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(131), 1,
+      sym_comment,
+    ACTIONS(410), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(412), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9238] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(132), 1,
+      sym_comment,
+    ACTIONS(414), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(416), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9271] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(133), 1,
+      sym_comment,
+    ACTIONS(418), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(420), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9304] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(134), 1,
+      sym_comment,
+    ACTIONS(422), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(424), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9337] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(135), 1,
+      sym_comment,
+    ACTIONS(298), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(300), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9370] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(136), 1,
+      sym_comment,
+    ACTIONS(426), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(428), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9403] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(137), 1,
+      sym_comment,
+    ACTIONS(430), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(432), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9436] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(138), 1,
+      sym_comment,
+    ACTIONS(434), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(436), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9469] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(139), 1,
+      sym_comment,
+    ACTIONS(438), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(440), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9502] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(140), 1,
+      sym_comment,
+    ACTIONS(442), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(444), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9535] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(141), 1,
+      sym_comment,
+    ACTIONS(446), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(448), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9568] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(142), 1,
+      sym_comment,
+    ACTIONS(450), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(452), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9601] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(143), 1,
+      sym_comment,
+    ACTIONS(454), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(456), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9634] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(144), 1,
+      sym_comment,
+    ACTIONS(458), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(460), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9667] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(145), 1,
+      sym_comment,
+    ACTIONS(462), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(464), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9700] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(146), 1,
+      sym_comment,
+    ACTIONS(466), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(468), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9733] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(147), 1,
+      sym_comment,
+    ACTIONS(470), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(472), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9766] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(148), 1,
+      sym_comment,
+    ACTIONS(474), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(476), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9799] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(149), 1,
+      sym_comment,
+    ACTIONS(478), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(480), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9832] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(150), 1,
+      sym_comment,
+    ACTIONS(482), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(484), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9865] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(151), 1,
+      sym_comment,
+    ACTIONS(486), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(488), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9898] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(152), 1,
+      sym_comment,
+    ACTIONS(490), 4,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(492), 15,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_until,
+      anon_sym_if,
+      anon_sym_elseif,
+      anon_sym_else,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9931] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(153), 1,
+      sym_comment,
+    ACTIONS(494), 7,
+      anon_sym_function,
+      sym_nil,
+      sym_false,
+      sym_true,
+      anon_sym_DASH,
+      anon_sym_not,
+      sym_identifier,
+    ACTIONS(496), 11,
+      sym__block_string_start,
+      sym_number,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      sym_vararg_expression,
+      anon_sym_LPAREN,
+      anon_sym_LBRACK,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_TILDE,
+      anon_sym_POUND,
+  [9963] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(154), 1,
+      sym_comment,
+    ACTIONS(500), 3,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(498), 12,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_if,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [9992] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(155), 1,
+      sym_comment,
+    ACTIONS(504), 3,
+      anon_sym_SEMI,
+      anon_sym_COLON_COLON,
+      anon_sym_LPAREN,
+    ACTIONS(502), 12,
+      anon_sym_return,
+      sym_break_statement,
+      anon_sym_goto,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_while,
+      anon_sym_repeat,
+      anon_sym_if,
+      anon_sym_for,
+      anon_sym_function,
+      anon_sym_local,
+      sym_identifier,
+  [10021] = 15,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(506), 1,
+      anon_sym_DOT,
+    ACTIONS(508), 1,
+      anon_sym_COLON,
+    ACTIONS(510), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(512), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(514), 1,
+      anon_sym_LPAREN,
+    ACTIONS(516), 1,
+      anon_sym_LBRACK,
+    ACTIONS(518), 1,
+      anon_sym_LBRACE,
+    ACTIONS(520), 1,
+      sym__block_string_start,
+    STATE(7), 1,
+      sym_arguments,
+    STATE(13), 1,
+      sym__quote_string,
+    STATE(14), 1,
+      sym__block_string,
+    STATE(156), 1,
+      sym_comment,
+    STATE(6), 2,
+      sym_string,
+      sym_table_constructor,
+  [10068] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(522), 1,
+      anon_sym_EQ,
+    ACTIONS(524), 1,
+      anon_sym_COMMA,
+    STATE(157), 1,
+      sym_comment,
+    STATE(196), 1,
+      aux_sym__variable_assignment_varlist_repeat1,
+    ACTIONS(73), 8,
+      sym__block_string_start,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_LBRACK,
+      anon_sym_LBRACE,
+  [10097] = 12,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(510), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(512), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(514), 1,
+      anon_sym_LPAREN,
+    ACTIONS(518), 1,
+      anon_sym_LBRACE,
+    ACTIONS(520), 1,
+      sym__block_string_start,
+    STATE(7), 1,
+      sym_arguments,
+    STATE(13), 1,
+      sym__quote_string,
+    STATE(14), 1,
+      sym__block_string,
+    STATE(158), 1,
+      sym_comment,
+    STATE(6), 2,
+      sym_string,
+      sym_table_constructor,
+  [10135] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(286), 1,
+      anon_sym_else,
+    ACTIONS(526), 1,
+      anon_sym_COMMA,
+    STATE(159), 2,
+      sym_comment,
+      aux_sym__expression_list_repeat1,
+    ACTIONS(284), 7,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+      anon_sym_RPAREN,
+  [10161] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(160), 1,
+      sym_comment,
+    ACTIONS(529), 2,
+      anon_sym_EQ,
+      anon_sym_COMMA,
+    ACTIONS(73), 8,
+      sym__block_string_start,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_LBRACK,
+      anon_sym_LBRACE,
+  [10185] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(294), 1,
+      anon_sym_COMMA,
+    ACTIONS(533), 1,
+      anon_sym_else,
+    STATE(159), 1,
+      aux_sym__expression_list_repeat1,
+    STATE(161), 1,
+      sym_comment,
+    ACTIONS(531), 6,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_do,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+  [10212] = 10,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(37), 1,
+      anon_sym_LPAREN,
+    ACTIONS(535), 1,
+      sym_identifier,
+    STATE(156), 1,
+      sym__prefix_expression,
+    STATE(158), 1,
+      sym_method_index_expression,
+    STATE(160), 1,
+      sym_variable,
+    STATE(162), 1,
+      sym_comment,
+    STATE(2), 2,
+      sym_bracket_index_expression,
+      sym_dot_index_expression,
+    STATE(163), 2,
+      sym_function_call,
+      sym_parenthesized_expression,
+  [10245] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(163), 1,
+      sym_comment,
+    ACTIONS(73), 8,
+      sym__block_string_start,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_LBRACK,
+      anon_sym_LBRACE,
+  [10265] = 9,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(119), 1,
+      anon_sym_else,
+    ACTIONS(537), 1,
+      anon_sym_end,
+    ACTIONS(539), 1,
+      anon_sym_elseif,
+    STATE(164), 1,
+      sym_comment,
+    STATE(175), 1,
+      aux_sym_if_statement_repeat1,
+    STATE(198), 1,
+      sym_elseif_statement,
+    STATE(220), 1,
+      sym_else_statement,
+  [10293] = 9,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(119), 1,
+      anon_sym_else,
+    ACTIONS(539), 1,
+      anon_sym_elseif,
+    ACTIONS(541), 1,
+      anon_sym_end,
+    STATE(165), 1,
+      sym_comment,
+    STATE(166), 1,
+      aux_sym_if_statement_repeat1,
+    STATE(198), 1,
+      sym_elseif_statement,
+    STATE(214), 1,
+      sym_else_statement,
+  [10321] = 9,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(119), 1,
+      anon_sym_else,
+    ACTIONS(539), 1,
+      anon_sym_elseif,
+    ACTIONS(543), 1,
+      anon_sym_end,
+    STATE(166), 1,
+      sym_comment,
+    STATE(175), 1,
+      aux_sym_if_statement_repeat1,
+    STATE(198), 1,
+      sym_elseif_statement,
+    STATE(234), 1,
+      sym_else_statement,
+  [10349] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(547), 1,
+      anon_sym_SEMI,
+    ACTIONS(549), 1,
+      anon_sym_else,
+    STATE(167), 1,
+      sym_comment,
+    ACTIONS(545), 4,
+      ts_builtin_sym_end,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+  [10371] = 8,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(551), 1,
+      sym_identifier,
+    STATE(168), 1,
+      sym_comment,
+    STATE(193), 1,
+      sym__function_name_dot_index_expression,
+    STATE(199), 1,
+      sym__function_name,
+    STATE(204), 1,
+      sym__function_name_prefix_expression,
+    STATE(259), 1,
+      sym__function_name_method_index_expression,
+  [10396] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(555), 1,
+      anon_sym_RBRACE,
+    STATE(62), 1,
+      sym__field_sep,
+    STATE(169), 1,
+      sym_comment,
+    STATE(170), 1,
+      aux_sym__field_list_repeat1,
+    ACTIONS(553), 2,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+  [10419] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(274), 1,
+      anon_sym_RBRACE,
+    STATE(64), 1,
+      sym__field_sep,
+    STATE(170), 1,
+      sym_comment,
+    STATE(172), 1,
+      aux_sym__field_list_repeat1,
+    ACTIONS(553), 2,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+  [10442] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(559), 1,
+      anon_sym_else,
+    STATE(171), 1,
+      sym_comment,
+    ACTIONS(557), 4,
+      ts_builtin_sym_end,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+  [10461] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(564), 1,
+      anon_sym_RBRACE,
+    STATE(66), 1,
+      sym__field_sep,
+    ACTIONS(561), 2,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+    STATE(172), 2,
+      sym_comment,
+      aux_sym__field_list_repeat1,
+  [10482] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(173), 1,
+      sym_comment,
+    ACTIONS(566), 5,
+      sym__block_string_start,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+  [10499] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(549), 1,
+      anon_sym_else,
+    STATE(174), 1,
+      sym_comment,
+    ACTIONS(545), 4,
+      ts_builtin_sym_end,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+  [10518] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(568), 1,
+      anon_sym_end,
+    ACTIONS(570), 1,
+      anon_sym_elseif,
+    ACTIONS(573), 1,
+      anon_sym_else,
+    STATE(198), 1,
+      sym_elseif_statement,
+    STATE(175), 2,
+      sym_comment,
+      aux_sym_if_statement_repeat1,
+  [10541] = 5,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(575), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(577), 2,
+      aux_sym__singlequote_string_content_token1,
+      sym_escape_sequence,
+    STATE(176), 2,
+      aux_sym__singlequote_string_content,
+      sym_comment,
+  [10559] = 6,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(582), 1,
+      anon_sym_SQUOTE,
+    STATE(176), 1,
+      aux_sym__singlequote_string_content,
+    STATE(177), 1,
+      sym_comment,
+    ACTIONS(584), 2,
+      aux_sym__singlequote_string_content_token1,
+      sym_escape_sequence,
+  [10579] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(588), 1,
+      anon_sym_else,
+    STATE(178), 1,
+      sym_comment,
+    ACTIONS(586), 3,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+  [10597] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(590), 1,
+      anon_sym_EQ,
+    ACTIONS(592), 1,
+      anon_sym_COMMA,
+    ACTIONS(594), 1,
+      anon_sym_in,
+    STATE(179), 1,
+      sym_comment,
+    STATE(210), 1,
+      aux_sym__name_list_repeat1,
+  [10619] = 6,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(596), 1,
+      anon_sym_DQUOTE,
+    STATE(180), 1,
+      sym_comment,
+    STATE(187), 1,
+      aux_sym__doublequote_string_content,
+    ACTIONS(598), 2,
+      aux_sym__doublequote_string_content_token1,
+      sym_escape_sequence,
+  [10639] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(600), 1,
+      anon_sym_COMMA,
+    ACTIONS(603), 2,
+      anon_sym_in,
+      anon_sym_RPAREN,
+    STATE(181), 2,
+      sym_comment,
+      aux_sym__name_list_repeat1,
+  [10657] = 6,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(605), 1,
+      anon_sym_DQUOTE,
+    STATE(180), 1,
+      aux_sym__doublequote_string_content,
+    STATE(182), 1,
+      sym_comment,
+    ACTIONS(598), 2,
+      aux_sym__doublequote_string_content_token1,
+      sym_escape_sequence,
+  [10677] = 6,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(605), 1,
+      anon_sym_SQUOTE,
+    STATE(183), 1,
+      sym_comment,
+    STATE(192), 1,
+      aux_sym__singlequote_string_content,
+    ACTIONS(584), 2,
+      aux_sym__singlequote_string_content_token1,
+      sym_escape_sequence,
+  [10697] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(607), 1,
+      sym_identifier,
+    STATE(184), 1,
+      sym_comment,
+    STATE(251), 1,
+      sym__name_list,
+    STATE(232), 2,
+      sym_for_generic_clause,
+      sym_for_numeric_clause,
+  [10717] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(609), 1,
+      sym_identifier,
+    ACTIONS(611), 1,
+      sym_vararg_expression,
+    ACTIONS(613), 1,
+      anon_sym_RPAREN,
+    STATE(185), 1,
+      sym_comment,
+    STATE(244), 1,
+      sym__parameter_list,
+  [10739] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(161), 1,
+      anon_sym_else,
+    STATE(186), 1,
+      sym_comment,
+    ACTIONS(615), 3,
+      anon_sym_end,
+      anon_sym_until,
+      anon_sym_elseif,
+  [10757] = 5,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(617), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(619), 2,
+      aux_sym__doublequote_string_content_token1,
+      sym_escape_sequence,
+    STATE(187), 2,
+      aux_sym__doublequote_string_content,
+      sym_comment,
+  [10775] = 7,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(622), 1,
+      sym_identifier,
+    ACTIONS(624), 1,
+      anon_sym_function,
+    STATE(124), 1,
+      sym__att_name_list,
+    STATE(146), 1,
+      sym__local_variable_assignment,
+    STATE(188), 1,
+      sym_comment,
+  [10797] = 6,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(626), 1,
+      anon_sym_DQUOTE,
+    STATE(189), 1,
+      sym_comment,
+    STATE(191), 1,
+      aux_sym__doublequote_string_content,
+    ACTIONS(598), 2,
+      aux_sym__doublequote_string_content_token1,
+      sym_escape_sequence,
+  [10817] = 6,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(626), 1,
+      anon_sym_SQUOTE,
+    STATE(177), 1,
+      aux_sym__singlequote_string_content,
+    STATE(190), 1,
+      sym_comment,
+    ACTIONS(584), 2,
+      aux_sym__singlequote_string_content_token1,
+      sym_escape_sequence,
+  [10837] = 6,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(582), 1,
+      anon_sym_DQUOTE,
+    STATE(187), 1,
+      aux_sym__doublequote_string_content,
+    STATE(191), 1,
+      sym_comment,
+    ACTIONS(598), 2,
+      aux_sym__doublequote_string_content_token1,
+      sym_escape_sequence,
+  [10857] = 6,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(596), 1,
+      anon_sym_SQUOTE,
+    STATE(176), 1,
+      aux_sym__singlequote_string_content,
+    STATE(192), 1,
+      sym_comment,
+    ACTIONS(584), 2,
+      aux_sym__singlequote_string_content_token1,
+      sym_escape_sequence,
+  [10877] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(193), 1,
+      sym_comment,
+    ACTIONS(628), 3,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LPAREN,
+  [10892] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(630), 1,
+      anon_sym_EQ,
+    ACTIONS(632), 1,
+      anon_sym_COMMA,
+    STATE(194), 2,
+      sym_comment,
+      aux_sym__variable_assignment_varlist_repeat1,
+  [10909] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(195), 1,
+      sym_comment,
+    ACTIONS(635), 3,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LPAREN,
+  [10924] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(524), 1,
+      anon_sym_COMMA,
+    ACTIONS(637), 1,
+      anon_sym_EQ,
+    STATE(194), 1,
+      aux_sym__variable_assignment_varlist_repeat1,
+    STATE(196), 1,
+      sym_comment,
+  [10943] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(197), 1,
+      sym_comment,
+    ACTIONS(639), 3,
+      anon_sym_DOT,
+      anon_sym_COLON,
+      anon_sym_LPAREN,
+  [10958] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(643), 1,
+      anon_sym_else,
+    STATE(198), 1,
+      sym_comment,
+    ACTIONS(641), 2,
+      anon_sym_end,
+      anon_sym_elseif,
+  [10975] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(645), 1,
+      anon_sym_LPAREN,
+    STATE(50), 1,
+      sym_parameters,
+    STATE(126), 1,
+      sym__function_body,
+    STATE(199), 1,
+      sym_comment,
+  [10994] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(649), 1,
+      anon_sym_else,
+    STATE(200), 1,
+      sym_comment,
+    ACTIONS(647), 2,
+      anon_sym_end,
+      anon_sym_elseif,
+  [11011] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(294), 1,
+      anon_sym_COMMA,
+    ACTIONS(651), 1,
+      anon_sym_RPAREN,
+    STATE(159), 1,
+      aux_sym__expression_list_repeat1,
+    STATE(201), 1,
+      sym_comment,
+  [11030] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(653), 1,
+      anon_sym_COMMA,
+    ACTIONS(655), 1,
+      anon_sym_RPAREN,
+    STATE(202), 1,
+      sym_comment,
+    STATE(209), 1,
+      aux_sym__name_list_repeat1,
+  [11049] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(645), 1,
+      anon_sym_LPAREN,
+    STATE(41), 1,
+      sym__function_body,
+    STATE(50), 1,
+      sym_parameters,
+    STATE(203), 1,
+      sym_comment,
+  [11068] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(657), 1,
+      anon_sym_DOT,
+    ACTIONS(659), 1,
+      anon_sym_COLON,
+    ACTIONS(661), 1,
+      anon_sym_LPAREN,
+    STATE(204), 1,
+      sym_comment,
+  [11087] = 5,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(663), 1,
+      anon_sym_DQUOTE,
+    STATE(205), 1,
+      sym_comment,
+    ACTIONS(665), 2,
+      aux_sym__doublequote_string_content_token1,
+      sym_escape_sequence,
+  [11104] = 5,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(667), 1,
+      anon_sym_SQUOTE,
+    STATE(206), 1,
+      sym_comment,
+    ACTIONS(669), 2,
+      aux_sym__singlequote_string_content_token1,
+      sym_escape_sequence,
+  [11121] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(207), 1,
+      sym_comment,
+    ACTIONS(671), 3,
+      anon_sym_COMMA,
+      anon_sym_in,
+      anon_sym_RPAREN,
+  [11136] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(645), 1,
+      anon_sym_LPAREN,
+    STATE(50), 1,
+      sym_parameters,
+    STATE(133), 1,
+      sym__function_body,
+    STATE(208), 1,
+      sym_comment,
+  [11155] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(673), 1,
+      anon_sym_COMMA,
+    ACTIONS(675), 1,
+      anon_sym_RPAREN,
+    STATE(181), 1,
+      aux_sym__name_list_repeat1,
+    STATE(209), 1,
+      sym_comment,
+  [11174] = 6,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(592), 1,
+      anon_sym_COMMA,
+    ACTIONS(677), 1,
+      anon_sym_in,
+    STATE(181), 1,
+      aux_sym__name_list_repeat1,
+    STATE(210), 1,
+      sym_comment,
+  [11193] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    STATE(211), 1,
+      sym_comment,
+    ACTIONS(564), 3,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [11208] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(679), 1,
+      sym_identifier,
+    ACTIONS(681), 1,
+      sym_vararg_expression,
+    STATE(212), 1,
+      sym_comment,
+  [11224] = 5,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(679), 1,
+      sym_identifier,
+    ACTIONS(683), 1,
+      sym_vararg_expression,
+    STATE(213), 1,
+      sym_comment,
+  [11240] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(685), 1,
+      anon_sym_end,
+    STATE(214), 1,
+      sym_comment,
+  [11253] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(687), 1,
+      sym_identifier,
+    STATE(215), 1,
+      sym_comment,
+  [11266] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(689), 1,
+      anon_sym_end,
+    STATE(216), 1,
+      sym_comment,
+  [11279] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(691), 1,
+      anon_sym_do,
+    STATE(217), 1,
+      sym_comment,
+  [11292] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(693), 1,
+      sym_identifier,
+    STATE(218), 1,
+      sym_comment,
+  [11305] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(695), 1,
+      sym__block_comment_end,
+    STATE(219), 1,
+      sym_comment,
+  [11318] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(697), 1,
+      anon_sym_end,
+    STATE(220), 1,
+      sym_comment,
+  [11331] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(699), 1,
+      anon_sym_LPAREN,
+    STATE(221), 1,
+      sym_comment,
+  [11344] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(701), 1,
+      sym_identifier,
+    STATE(222), 1,
+      sym_comment,
+  [11357] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(703), 1,
+      sym_identifier,
+    STATE(223), 1,
+      sym_comment,
+  [11370] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(705), 1,
+      sym_identifier,
+    STATE(224), 1,
+      sym_comment,
+  [11383] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(707), 1,
+      anon_sym_EQ,
+    STATE(225), 1,
+      sym_comment,
+  [11396] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(709), 1,
+      anon_sym_end,
+    STATE(226), 1,
+      sym_comment,
+  [11409] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(711), 1,
+      anon_sym_until,
+    STATE(227), 1,
+      sym_comment,
+  [11422] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(713), 1,
+      sym_identifier,
+    STATE(228), 1,
+      sym_comment,
+  [11435] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(715), 1,
+      anon_sym_RPAREN,
+    STATE(229), 1,
+      sym_comment,
+  [11448] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(717), 1,
+      anon_sym_GT,
+    STATE(230), 1,
+      sym_comment,
+  [11461] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(719), 1,
+      sym_identifier,
+    STATE(231), 1,
+      sym_comment,
+  [11474] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(721), 1,
+      anon_sym_do,
+    STATE(232), 1,
+      sym_comment,
+  [11487] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(723), 1,
+      anon_sym_end,
+    STATE(233), 1,
+      sym_comment,
+  [11500] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(725), 1,
+      anon_sym_end,
+    STATE(234), 1,
+      sym_comment,
+  [11513] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(727), 1,
+      ts_builtin_sym_end,
+    STATE(235), 1,
+      sym_comment,
+  [11526] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(729), 1,
+      sym_identifier,
+    STATE(236), 1,
+      sym_comment,
+  [11539] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(731), 1,
+      anon_sym_RPAREN,
+    STATE(237), 1,
+      sym_comment,
+  [11552] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(242), 1,
+      ts_builtin_sym_end,
+    STATE(238), 1,
+      sym_comment,
+  [11565] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(733), 1,
+      anon_sym_COLON_COLON,
+    STATE(239), 1,
+      sym_comment,
+  [11578] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(735), 1,
+      sym__block_string_end,
+    STATE(240), 1,
+      sym_comment,
+  [11591] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(737), 1,
+      anon_sym_RPAREN,
+    STATE(241), 1,
+      sym_comment,
+  [11604] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(240), 1,
+      ts_builtin_sym_end,
+    STATE(242), 1,
+      sym_comment,
+  [11617] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(739), 1,
+      anon_sym_end,
+    STATE(243), 1,
+      sym_comment,
+  [11630] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(741), 1,
+      anon_sym_RPAREN,
+    STATE(244), 1,
+      sym_comment,
+  [11643] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(743), 1,
+      anon_sym_end,
+    STATE(245), 1,
+      sym_comment,
+  [11656] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(745), 1,
+      anon_sym_end,
+    STATE(246), 1,
+      sym_comment,
+  [11669] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(747), 1,
+      sym__block_string_content,
+    STATE(247), 1,
+      sym_comment,
+  [11682] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(679), 1,
+      sym_identifier,
+    STATE(248), 1,
+      sym_comment,
+  [11695] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(749), 1,
+      anon_sym_EQ,
+    STATE(249), 1,
+      sym_comment,
+  [11708] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(751), 1,
+      ts_builtin_sym_end,
+    STATE(250), 1,
+      sym_comment,
+  [11721] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(753), 1,
+      anon_sym_in,
+    STATE(251), 1,
+      sym_comment,
+  [11734] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(755), 1,
+      anon_sym_RBRACE,
+    STATE(252), 1,
+      sym_comment,
+  [11747] = 4,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(580), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(757), 1,
+      aux_sym_comment_token1,
+    STATE(253), 1,
+      sym_comment,
+  [11760] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(759), 1,
+      sym__block_string_end,
+    STATE(254), 1,
+      sym_comment,
+  [11773] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(761), 1,
+      sym__block_comment_content,
+    STATE(255), 1,
+      sym_comment,
+  [11786] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(763), 1,
+      sym_identifier,
+    STATE(256), 1,
+      sym_comment,
+  [11799] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(765), 1,
+      anon_sym_RBRACE,
+    STATE(257), 1,
+      sym_comment,
+  [11812] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(767), 1,
+      sym__block_string_content,
+    STATE(258), 1,
+      sym_comment,
+  [11825] = 4,
+    ACTIONS(3), 1,
+      anon_sym_DASH_DASH,
+    ACTIONS(5), 1,
+      sym__block_comment_start,
+    ACTIONS(769), 1,
+      anon_sym_LPAREN,
+    STATE(259), 1,
+      sym_comment,
+  [11838] = 1,
+    ACTIONS(771), 1,
+      ts_builtin_sym_end,
+  [11842] = 1,
+    ACTIONS(773), 1,
+      ts_builtin_sym_end,
+};
+
+static const uint32_t ts_small_parse_table_map[] = {
+  [SMALL_STATE(2)] = 0,
+  [SMALL_STATE(3)] = 67,
+  [SMALL_STATE(4)] = 134,
+  [SMALL_STATE(5)] = 201,
+  [SMALL_STATE(6)] = 267,
+  [SMALL_STATE(7)] = 333,
+  [SMALL_STATE(8)] = 399,
+  [SMALL_STATE(9)] = 465,
+  [SMALL_STATE(10)] = 535,
+  [SMALL_STATE(11)] = 601,
+  [SMALL_STATE(12)] = 667,
+  [SMALL_STATE(13)] = 733,
+  [SMALL_STATE(14)] = 799,
+  [SMALL_STATE(15)] = 865,
+  [SMALL_STATE(16)] = 931,
+  [SMALL_STATE(17)] = 997,
+  [SMALL_STATE(18)] = 1063,
+  [SMALL_STATE(19)] = 1129,
+  [SMALL_STATE(20)] = 1188,
+  [SMALL_STATE(21)] = 1247,
+  [SMALL_STATE(22)] = 1306,
+  [SMALL_STATE(23)] = 1367,
+  [SMALL_STATE(24)] = 1494,
+  [SMALL_STATE(25)] = 1553,
+  [SMALL_STATE(26)] = 1612,
+  [SMALL_STATE(27)] = 1671,
+  [SMALL_STATE(28)] = 1730,
+  [SMALL_STATE(29)] = 1809,
+  [SMALL_STATE(30)] = 1892,
+  [SMALL_STATE(31)] = 1969,
+  [SMALL_STATE(32)] = 2044,
+  [SMALL_STATE(33)] = 2117,
+  [SMALL_STATE(34)] = 2188,
+  [SMALL_STATE(35)] = 2253,
+  [SMALL_STATE(36)] = 2314,
+  [SMALL_STATE(37)] = 2385,
+  [SMALL_STATE(38)] = 2446,
+  [SMALL_STATE(39)] = 2505,
+  [SMALL_STATE(40)] = 2564,
+  [SMALL_STATE(41)] = 2623,
+  [SMALL_STATE(42)] = 2682,
+  [SMALL_STATE(43)] = 2767,
+  [SMALL_STATE(44)] = 2879,
+  [SMALL_STATE(45)] = 2993,
+  [SMALL_STATE(46)] = 3101,
+  [SMALL_STATE(47)] = 3189,
+  [SMALL_STATE(48)] = 3272,
+  [SMALL_STATE(49)] = 3384,
+  [SMALL_STATE(50)] = 3496,
+  [SMALL_STATE(51)] = 3608,
+  [SMALL_STATE(52)] = 3690,
+  [SMALL_STATE(53)] = 3802,
+  [SMALL_STATE(54)] = 3884,
+  [SMALL_STATE(55)] = 3996,
+  [SMALL_STATE(56)] = 4108,
+  [SMALL_STATE(57)] = 4217,
+  [SMALL_STATE(58)] = 4326,
+  [SMALL_STATE(59)] = 4435,
+  [SMALL_STATE(60)] = 4526,
+  [SMALL_STATE(61)] = 4617,
+  [SMALL_STATE(62)] = 4708,
+  [SMALL_STATE(63)] = 4796,
+  [SMALL_STATE(64)] = 4884,
+  [SMALL_STATE(65)] = 4972,
+  [SMALL_STATE(66)] = 5021,
+  [SMALL_STATE(67)] = 5106,
+  [SMALL_STATE(68)] = 5188,
+  [SMALL_STATE(69)] = 5270,
+  [SMALL_STATE(70)] = 5352,
+  [SMALL_STATE(71)] = 5434,
+  [SMALL_STATE(72)] = 5513,
+  [SMALL_STATE(73)] = 5592,
+  [SMALL_STATE(74)] = 5671,
+  [SMALL_STATE(75)] = 5750,
+  [SMALL_STATE(76)] = 5829,
+  [SMALL_STATE(77)] = 5908,
+  [SMALL_STATE(78)] = 5987,
+  [SMALL_STATE(79)] = 6066,
+  [SMALL_STATE(80)] = 6145,
+  [SMALL_STATE(81)] = 6224,
+  [SMALL_STATE(82)] = 6303,
+  [SMALL_STATE(83)] = 6382,
+  [SMALL_STATE(84)] = 6461,
+  [SMALL_STATE(85)] = 6540,
+  [SMALL_STATE(86)] = 6619,
+  [SMALL_STATE(87)] = 6698,
+  [SMALL_STATE(88)] = 6777,
+  [SMALL_STATE(89)] = 6856,
+  [SMALL_STATE(90)] = 6935,
+  [SMALL_STATE(91)] = 7014,
+  [SMALL_STATE(92)] = 7093,
+  [SMALL_STATE(93)] = 7172,
+  [SMALL_STATE(94)] = 7251,
+  [SMALL_STATE(95)] = 7330,
+  [SMALL_STATE(96)] = 7409,
+  [SMALL_STATE(97)] = 7488,
+  [SMALL_STATE(98)] = 7567,
+  [SMALL_STATE(99)] = 7639,
+  [SMALL_STATE(100)] = 7715,
+  [SMALL_STATE(101)] = 7759,
+  [SMALL_STATE(102)] = 7805,
+  [SMALL_STATE(103)] = 7873,
+  [SMALL_STATE(104)] = 7937,
+  [SMALL_STATE(105)] = 8001,
+  [SMALL_STATE(106)] = 8065,
+  [SMALL_STATE(107)] = 8130,
+  [SMALL_STATE(108)] = 8171,
+  [SMALL_STATE(109)] = 8211,
+  [SMALL_STATE(110)] = 8251,
+  [SMALL_STATE(111)] = 8313,
+  [SMALL_STATE(112)] = 8351,
+  [SMALL_STATE(113)] = 8413,
+  [SMALL_STATE(114)] = 8475,
+  [SMALL_STATE(115)] = 8537,
+  [SMALL_STATE(116)] = 8599,
+  [SMALL_STATE(117)] = 8661,
+  [SMALL_STATE(118)] = 8701,
+  [SMALL_STATE(119)] = 8763,
+  [SMALL_STATE(120)] = 8825,
+  [SMALL_STATE(121)] = 8860,
+  [SMALL_STATE(122)] = 8899,
+  [SMALL_STATE(123)] = 8936,
+  [SMALL_STATE(124)] = 8971,
+  [SMALL_STATE(125)] = 9007,
+  [SMALL_STATE(126)] = 9040,
+  [SMALL_STATE(127)] = 9073,
+  [SMALL_STATE(128)] = 9106,
+  [SMALL_STATE(129)] = 9139,
+  [SMALL_STATE(130)] = 9172,
+  [SMALL_STATE(131)] = 9205,
+  [SMALL_STATE(132)] = 9238,
+  [SMALL_STATE(133)] = 9271,
+  [SMALL_STATE(134)] = 9304,
+  [SMALL_STATE(135)] = 9337,
+  [SMALL_STATE(136)] = 9370,
+  [SMALL_STATE(137)] = 9403,
+  [SMALL_STATE(138)] = 9436,
+  [SMALL_STATE(139)] = 9469,
+  [SMALL_STATE(140)] = 9502,
+  [SMALL_STATE(141)] = 9535,
+  [SMALL_STATE(142)] = 9568,
+  [SMALL_STATE(143)] = 9601,
+  [SMALL_STATE(144)] = 9634,
+  [SMALL_STATE(145)] = 9667,
+  [SMALL_STATE(146)] = 9700,
+  [SMALL_STATE(147)] = 9733,
+  [SMALL_STATE(148)] = 9766,
+  [SMALL_STATE(149)] = 9799,
+  [SMALL_STATE(150)] = 9832,
+  [SMALL_STATE(151)] = 9865,
+  [SMALL_STATE(152)] = 9898,
+  [SMALL_STATE(153)] = 9931,
+  [SMALL_STATE(154)] = 9963,
+  [SMALL_STATE(155)] = 9992,
+  [SMALL_STATE(156)] = 10021,
+  [SMALL_STATE(157)] = 10068,
+  [SMALL_STATE(158)] = 10097,
+  [SMALL_STATE(159)] = 10135,
+  [SMALL_STATE(160)] = 10161,
+  [SMALL_STATE(161)] = 10185,
+  [SMALL_STATE(162)] = 10212,
+  [SMALL_STATE(163)] = 10245,
+  [SMALL_STATE(164)] = 10265,
+  [SMALL_STATE(165)] = 10293,
+  [SMALL_STATE(166)] = 10321,
+  [SMALL_STATE(167)] = 10349,
+  [SMALL_STATE(168)] = 10371,
+  [SMALL_STATE(169)] = 10396,
+  [SMALL_STATE(170)] = 10419,
+  [SMALL_STATE(171)] = 10442,
+  [SMALL_STATE(172)] = 10461,
+  [SMALL_STATE(173)] = 10482,
+  [SMALL_STATE(174)] = 10499,
+  [SMALL_STATE(175)] = 10518,
+  [SMALL_STATE(176)] = 10541,
+  [SMALL_STATE(177)] = 10559,
+  [SMALL_STATE(178)] = 10579,
+  [SMALL_STATE(179)] = 10597,
+  [SMALL_STATE(180)] = 10619,
+  [SMALL_STATE(181)] = 10639,
+  [SMALL_STATE(182)] = 10657,
+  [SMALL_STATE(183)] = 10677,
+  [SMALL_STATE(184)] = 10697,
+  [SMALL_STATE(185)] = 10717,
+  [SMALL_STATE(186)] = 10739,
+  [SMALL_STATE(187)] = 10757,
+  [SMALL_STATE(188)] = 10775,
+  [SMALL_STATE(189)] = 10797,
+  [SMALL_STATE(190)] = 10817,
+  [SMALL_STATE(191)] = 10837,
+  [SMALL_STATE(192)] = 10857,
+  [SMALL_STATE(193)] = 10877,
+  [SMALL_STATE(194)] = 10892,
+  [SMALL_STATE(195)] = 10909,
+  [SMALL_STATE(196)] = 10924,
+  [SMALL_STATE(197)] = 10943,
+  [SMALL_STATE(198)] = 10958,
+  [SMALL_STATE(199)] = 10975,
+  [SMALL_STATE(200)] = 10994,
+  [SMALL_STATE(201)] = 11011,
+  [SMALL_STATE(202)] = 11030,
+  [SMALL_STATE(203)] = 11049,
+  [SMALL_STATE(204)] = 11068,
+  [SMALL_STATE(205)] = 11087,
+  [SMALL_STATE(206)] = 11104,
+  [SMALL_STATE(207)] = 11121,
+  [SMALL_STATE(208)] = 11136,
+  [SMALL_STATE(209)] = 11155,
+  [SMALL_STATE(210)] = 11174,
+  [SMALL_STATE(211)] = 11193,
+  [SMALL_STATE(212)] = 11208,
+  [SMALL_STATE(213)] = 11224,
+  [SMALL_STATE(214)] = 11240,
+  [SMALL_STATE(215)] = 11253,
+  [SMALL_STATE(216)] = 11266,
+  [SMALL_STATE(217)] = 11279,
+  [SMALL_STATE(218)] = 11292,
+  [SMALL_STATE(219)] = 11305,
+  [SMALL_STATE(220)] = 11318,
+  [SMALL_STATE(221)] = 11331,
+  [SMALL_STATE(222)] = 11344,
+  [SMALL_STATE(223)] = 11357,
+  [SMALL_STATE(224)] = 11370,
+  [SMALL_STATE(225)] = 11383,
+  [SMALL_STATE(226)] = 11396,
+  [SMALL_STATE(227)] = 11409,
+  [SMALL_STATE(228)] = 11422,
+  [SMALL_STATE(229)] = 11435,
+  [SMALL_STATE(230)] = 11448,
+  [SMALL_STATE(231)] = 11461,
+  [SMALL_STATE(232)] = 11474,
+  [SMALL_STATE(233)] = 11487,
+  [SMALL_STATE(234)] = 11500,
+  [SMALL_STATE(235)] = 11513,
+  [SMALL_STATE(236)] = 11526,
+  [SMALL_STATE(237)] = 11539,
+  [SMALL_STATE(238)] = 11552,
+  [SMALL_STATE(239)] = 11565,
+  [SMALL_STATE(240)] = 11578,
+  [SMALL_STATE(241)] = 11591,
+  [SMALL_STATE(242)] = 11604,
+  [SMALL_STATE(243)] = 11617,
+  [SMALL_STATE(244)] = 11630,
+  [SMALL_STATE(245)] = 11643,
+  [SMALL_STATE(246)] = 11656,
+  [SMALL_STATE(247)] = 11669,
+  [SMALL_STATE(248)] = 11682,
+  [SMALL_STATE(249)] = 11695,
+  [SMALL_STATE(250)] = 11708,
+  [SMALL_STATE(251)] = 11721,
+  [SMALL_STATE(252)] = 11734,
+  [SMALL_STATE(253)] = 11747,
+  [SMALL_STATE(254)] = 11760,
+  [SMALL_STATE(255)] = 11773,
+  [SMALL_STATE(256)] = 11786,
+  [SMALL_STATE(257)] = 11799,
+  [SMALL_STATE(258)] = 11812,
+  [SMALL_STATE(259)] = 11825,
+  [SMALL_STATE(260)] = 11838,
+  [SMALL_STATE(261)] = 11842,
+};
+
+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}}, SHIFT(253),
+  [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255),
+  [7] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_chunk, 0, 0, 0),
+  [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2),
+  [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56),
+  [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(63),
+  [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140),
+  [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231),
+  [19] = {.entry = {.count = 1, .reusable = false}}, SHIFT(135),
+  [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(228),
+  [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(54),
+  [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(77),
+  [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(52),
+  [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(71),
+  [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(184),
+  [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(168),
+  [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(188),
+  [37] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76),
+  [39] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable, 1, 0, 0),
+  [41] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable, 1, 0, 0),
+  [43] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dot_index_expression, 3, 0, 23),
+  [45] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dot_index_expression, 3, 0, 23),
+  [47] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bracket_index_expression, 4, 0, 23),
+  [49] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bracket_index_expression, 4, 0, 23),
+  [51] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_constructor, 3, 0, 0),
+  [53] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_constructor, 3, 0, 0),
+  [55] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_arguments, 1, 0, 0),
+  [57] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_arguments, 1, 0, 0),
+  [59] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 2, 0, 10),
+  [61] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 2, 0, 10),
+  [63] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3, 0, 0),
+  [65] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 0),
+  [67] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0),
+  [69] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0),
+  [71] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__prefix_expression, 1, 0, 0),
+  [73] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__prefix_expression, 1, 0, 0),
+  [75] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_arguments, 3, 0, 0),
+  [77] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_arguments, 3, 0, 0),
+  [79] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_arguments, 2, 0, 0),
+  [81] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_arguments, 2, 0, 0),
+  [83] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_arguments, 4, 0, 0),
+  [85] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_arguments, 4, 0, 0),
+  [87] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string, 1, 0, 6),
+  [89] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string, 1, 0, 6),
+  [91] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__quote_string, 2, 0, 14),
+  [93] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__quote_string, 2, 0, 14),
+  [95] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_constructor, 2, 0, 0),
+  [97] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_constructor, 2, 0, 0),
+  [99] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_string, 3, 0, 12),
+  [101] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_string, 3, 0, 12),
+  [103] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__quote_string, 3, 0, 28),
+  [105] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__quote_string, 3, 0, 28),
+  [107] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 16),
+  [109] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 16),
+  [111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96),
+  [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59),
+  [115] = {.entry = {.count = 1, .reusable = false}}, SHIFT(145),
+  [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(82),
+  [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(49),
+  [121] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_body, 2, 0, 27),
+  [123] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_body, 2, 0, 27),
+  [125] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 29),
+  [127] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 29),
+  [129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86),
+  [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(87),
+  [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88),
+  [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90),
+  [137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91),
+  [139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(91),
+  [141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93),
+  [143] = {.entry = {.count = 1, .reusable = false}}, SHIFT(93),
+  [145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94),
+  [147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(81),
+  [149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81),
+  [151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_body, 3, 0, 41),
+  [153] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_body, 3, 0, 41),
+  [155] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_definition, 2, 0, 13),
+  [157] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_definition, 2, 0, 13),
+  [159] = {.entry = {.count = 1, .reusable = false}}, SHIFT(85),
+  [161] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block, 1, 0, 0),
+  [163] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_elseif_statement, 3, 0, 30),
+  [165] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0),
+  [167] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(2),
+  [170] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0),
+  [172] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(140),
+  [175] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(231),
+  [178] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(135),
+  [181] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(228),
+  [184] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(54),
+  [187] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(77),
+  [190] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(52),
+  [193] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(71),
+  [196] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(184),
+  [199] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(168),
+  [202] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(188),
+  [205] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 2, 0, 0), SHIFT_REPEAT(76),
+  [208] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__variable_assignment_explist, 1, 0, 15),
+  [210] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__variable_assignment_explist, 1, 0, 15),
+  [212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84),
+  [214] = {.entry = {.count = 1, .reusable = false}}, SHIFT(97),
+  [216] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 50),
+  [218] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 50),
+  [220] = {.entry = {.count = 1, .reusable = false}}, SHIFT(141),
+  [222] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_statement, 1, 0, 0),
+  [224] = {.entry = {.count = 1, .reusable = false}}, SHIFT(26),
+  [226] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 4, 0, 31),
+  [228] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 4, 0, 31),
+  [230] = {.entry = {.count = 1, .reusable = false}}, SHIFT(73),
+  [232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 3, 0, 18),
+  [234] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 3, 0, 18),
+  [236] = {.entry = {.count = 1, .reusable = false}}, SHIFT(150),
+  [238] = {.entry = {.count = 1, .reusable = false}}, SHIFT(132),
+  [240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_chunk, 1, 0, 0),
+  [242] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_chunk, 2, 0, 0),
+  [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174),
+  [246] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 1, 0, 0),
+  [248] = {.entry = {.count = 1, .reusable = false}}, SHIFT(203),
+  [250] = {.entry = {.count = 1, .reusable = false}}, SHIFT(24),
+  [252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24),
+  [254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182),
+  [256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183),
+  [258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60),
+  [260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78),
+  [262] = {.entry = {.count = 1, .reusable = false}}, SHIFT(78),
+  [264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247),
+  [266] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65),
+  [268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79),
+  [270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21),
+  [272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16),
+  [274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__field_list, 2, 0, 0),
+  [276] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 1, 0, 0),
+  [278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__field_list, 3, 0, 0),
+  [280] = {.entry = {.count = 1, .reusable = false}}, SHIFT(74),
+  [282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11),
+  [284] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_list_repeat1, 2, 0, 0),
+  [286] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list_repeat1, 2, 0, 0),
+  [288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97),
+  [290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85),
+  [292] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression_list, 1, 0, 0),
+  [294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80),
+  [296] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression_list, 1, 0, 0),
+  [298] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1, 0, 0),
+  [300] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1, 0, 0),
+  [302] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 1, 0, 4),
+  [304] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 1, 0, 4),
+  [306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222),
+  [308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223),
+  [310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10),
+  [312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 3, 0, 42),
+  [314] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 5, 0, 56),
+  [316] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field, 1, 0, 15),
+  [318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95),
+  [320] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_numeric_clause, 5, 0, 55),
+  [322] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 25),
+  [324] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 25),
+  [326] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 2, 0, 20),
+  [328] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 2, 0, 20),
+  [330] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 3, 0, 36),
+  [332] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 3, 0, 36),
+  [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4),
+  [336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 37),
+  [338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 37),
+  [340] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__att_name_list_repeat1, 2, 0, 37), SHIFT_REPEAT(222),
+  [343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44),
+  [345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48),
+  [347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249),
+  [349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23),
+  [351] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8),
+  [353] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__att_name_list, 2, 0, 21),
+  [355] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__att_name_list, 2, 0, 21),
+  [357] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_numeric_clause, 7, 0, 58),
+  [359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89),
+  [361] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__att_name_list_repeat1, 3, 0, 49),
+  [363] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__att_name_list_repeat1, 3, 0, 49),
+  [365] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__variable_assignment_explist, 2, 0, 39),
+  [367] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__variable_assignment_explist, 2, 0, 39),
+  [369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 51),
+  [371] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 51),
+  [373] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__variable_assignment_explist_repeat1, 2, 0, 51), SHIFT_REPEAT(84),
+  [376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__attrib, 3, 0, 0),
+  [378] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__attrib, 3, 0, 0),
+  [380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_declaration, 2, 0, 9),
+  [382] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_declaration, 2, 0, 9),
+  [384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70),
+  [386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_label_statement, 3, 0, 0),
+  [388] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_label_statement, 3, 0, 0),
+  [390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 3, 0, 19),
+  [392] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 3, 0, 19),
+  [394] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, 0, 44),
+  [396] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, 0, 44),
+  [398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, 0, 45),
+  [400] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, 0, 45),
+  [402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, 0, 46),
+  [404] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, 0, 46),
+  [406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__local_variable_assignment, 3, 0, 38),
+  [408] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__local_variable_assignment, 3, 0, 38),
+  [410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 5, 0, 48),
+  [412] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 5, 0, 48),
+  [414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 4, 0, 33),
+  [416] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 4, 0, 33),
+  [418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__local_function_declaration, 4, 0, 35),
+  [420] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__local_function_declaration, 4, 0, 35),
+  [422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1, 0, 1),
+  [424] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1, 0, 1),
+  [426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1, 0, 0),
+  [428] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_declaration, 1, 0, 0),
+  [430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 6, 0, 52),
+  [432] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 6, 0, 52),
+  [434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 6, 0, 53),
+  [436] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 6, 0, 53),
+  [438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 6, 0, 54),
+  [440] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 6, 0, 54),
+  [442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_empty_statement, 1, 0, 0),
+  [444] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_empty_statement, 1, 0, 0),
+  [446] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while_statement, 4, 0, 30),
+  [448] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while_statement, 4, 0, 30),
+  [450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 7, 0, 57),
+  [452] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 7, 0, 57),
+  [454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_goto_statement, 2, 0, 0),
+  [456] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_goto_statement, 2, 0, 0),
+  [458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_statement, 3, 0, 22),
+  [460] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_statement, 3, 0, 22),
+  [462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 4, 0, 30),
+  [464] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 4, 0, 30),
+  [466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_declaration, 2, 0, 0),
+  [468] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_declaration, 2, 0, 0),
+  [470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_statement, 3, 0, 17),
+  [472] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_statement, 3, 0, 17),
+  [474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1, 0, 2),
+  [476] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_declaration, 1, 0, 2),
+  [478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while_statement, 5, 0, 43),
+  [480] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while_statement, 5, 0, 43),
+  [482] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_statement, 2, 0, 0),
+  [484] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_statement, 2, 0, 0),
+  [486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_chunk_repeat1, 1, 0, 0),
+  [488] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_chunk_repeat1, 1, 0, 0),
+  [490] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1, 0, 3),
+  [492] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_declaration, 1, 0, 3),
+  [494] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__field_sep, 1, 0, 0),
+  [496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__field_sep, 1, 0, 0),
+  [498] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameters, 2, 0, 0),
+  [500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameters, 2, 0, 0),
+  [502] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameters, 3, 0, 40),
+  [504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameters, 3, 0, 40),
+  [506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256),
+  [508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224),
+  [510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189),
+  [512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190),
+  [514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67),
+  [516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75),
+  [518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61),
+  [520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258),
+  [522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__variable_assignment_varlist, 1, 0, 4),
+  [524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162),
+  [526] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list_repeat1, 2, 0, 0), SHIFT_REPEAT(80),
+  [529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__variable_assignment_varlist_repeat1, 2, 0, 25),
+  [531] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression_list, 2, 0, 0),
+  [533] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression_list, 2, 0, 0),
+  [535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2),
+  [537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129),
+  [539] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82),
+  [541] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127),
+  [543] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138),
+  [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 2, 0, 0),
+  [547] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171),
+  [549] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 2, 0, 0),
+  [551] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195),
+  [553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153),
+  [555] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__field_list, 1, 0, 0),
+  [557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 3, 0, 0),
+  [559] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 3, 0, 0),
+  [561] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__field_list_repeat1, 2, 0, 0), SHIFT_REPEAT(153),
+  [564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__field_list_repeat1, 2, 0, 0),
+  [566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_method_index_expression, 3, 0, 24),
+  [568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 2, 0, 47),
+  [570] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 2, 0, 47), SHIFT_REPEAT(82),
+  [573] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 2, 0, 47),
+  [575] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__singlequote_string_content, 2, 0, 0),
+  [577] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__singlequote_string_content, 2, 0, 0), SHIFT_REPEAT(206),
+  [580] = {.entry = {.count = 1, .reusable = false}}, SHIFT(253),
+  [582] = {.entry = {.count = 1, .reusable = false}}, SHIFT(18),
+  [584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206),
+  [586] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block, 2, 0, 0),
+  [588] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block, 2, 0, 0),
+  [590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83),
+  [592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248),
+  [594] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__name_list, 1, 0, 4),
+  [596] = {.entry = {.count = 1, .reusable = false}}, SHIFT(27),
+  [598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205),
+  [600] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__name_list_repeat1, 2, 0, 26), SHIFT_REPEAT(248),
+  [603] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__name_list_repeat1, 2, 0, 26),
+  [605] = {.entry = {.count = 1, .reusable = false}}, SHIFT(20),
+  [607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179),
+  [609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202),
+  [611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241),
+  [613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154),
+  [615] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block, 1, 0, 0),
+  [617] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__doublequote_string_content, 2, 0, 0),
+  [619] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__doublequote_string_content, 2, 0, 0), SHIFT_REPEAT(205),
+  [622] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101),
+  [624] = {.entry = {.count = 1, .reusable = false}}, SHIFT(236),
+  [626] = {.entry = {.count = 1, .reusable = false}}, SHIFT(15),
+  [628] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name_prefix_expression, 1, 0, 7),
+  [630] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__variable_assignment_varlist_repeat1, 2, 0, 26),
+  [632] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__variable_assignment_varlist_repeat1, 2, 0, 26), SHIFT_REPEAT(162),
+  [635] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name_prefix_expression, 1, 0, 0),
+  [637] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__variable_assignment_varlist, 2, 0, 11),
+  [639] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name_dot_index_expression, 3, 0, 23),
+  [641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 1, 0, 32),
+  [643] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 1, 0, 32),
+  [645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185),
+  [647] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_elseif_statement, 4, 0, 44),
+  [649] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_elseif_statement, 4, 0, 44),
+  [651] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12),
+  [653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213),
+  [655] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parameter_list, 1, 0, 4),
+  [657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215),
+  [659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218),
+  [661] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name, 1, 0, 0),
+  [663] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__doublequote_string_content, 1, 0, 0),
+  [665] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__doublequote_string_content, 1, 0, 0),
+  [667] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__singlequote_string_content, 1, 0, 0),
+  [669] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__singlequote_string_content, 1, 0, 0),
+  [671] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__name_list_repeat1, 2, 0, 25),
+  [673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212),
+  [675] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parameter_list, 2, 0, 11),
+  [677] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__name_list, 2, 0, 11),
+  [679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207),
+  [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237),
+  [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229),
+  [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137),
+  [687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197),
+  [689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131),
+  [691] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_generic_clause, 3, 0, 34),
+  [693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221),
+  [695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260),
+  [697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139),
+  [699] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name_method_index_expression, 3, 0, 24),
+  [701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107),
+  [703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230),
+  [705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173),
+  [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68),
+  [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149),
+  [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72),
+  [713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143),
+  [715] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parameter_list, 3, 0, 4),
+  [717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123),
+  [719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239),
+  [721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55),
+  [723] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_statement, 2, 0, 17),
+  [725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142),
+  [727] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_chunk, 3, 0, 0),
+  [729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208),
+  [731] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parameter_list, 4, 0, 11),
+  [733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125),
+  [735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25),
+  [737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parameter_list, 1, 0, 0),
+  [739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147),
+  [741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155),
+  [743] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128),
+  [745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40),
+  [747] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240),
+  [749] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92),
+  [751] = {.entry = {.count = 1, .reusable = true}},  ACCEPT_INPUT(),
+  [753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69),
+  [755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19),
+  [757] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261),
+  [759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17),
+  [761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219),
+  [763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3),
+  [765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5),
+  [767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254),
+  [769] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_name, 1, 0, 8),
+  [771] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 3, 0, 12),
+  [773] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 2, 0, 5),
+};
+
+enum ts_external_scanner_symbol_identifiers {
+  ts_external_token__block_comment_start = 0,
+  ts_external_token__block_comment_content = 1,
+  ts_external_token__block_comment_end = 2,
+  ts_external_token__block_string_start = 3,
+  ts_external_token__block_string_content = 4,
+  ts_external_token__block_string_end = 5,
+};
+
+static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = {
+  [ts_external_token__block_comment_start] = sym__block_comment_start,
+  [ts_external_token__block_comment_content] = sym__block_comment_content,
+  [ts_external_token__block_comment_end] = sym__block_comment_end,
+  [ts_external_token__block_string_start] = sym__block_string_start,
+  [ts_external_token__block_string_content] = sym__block_string_content,
+  [ts_external_token__block_string_end] = sym__block_string_end,
+};
+
+static const bool ts_external_scanner_states[8][EXTERNAL_TOKEN_COUNT] = {
+  [1] = {
+    [ts_external_token__block_comment_start] = true,
+    [ts_external_token__block_comment_content] = true,
+    [ts_external_token__block_comment_end] = true,
+    [ts_external_token__block_string_start] = true,
+    [ts_external_token__block_string_content] = true,
+    [ts_external_token__block_string_end] = true,
+  },
+  [2] = {
+    [ts_external_token__block_comment_start] = true,
+  },
+  [3] = {
+    [ts_external_token__block_comment_start] = true,
+    [ts_external_token__block_string_start] = true,
+  },
+  [4] = {
+    [ts_external_token__block_comment_start] = true,
+    [ts_external_token__block_comment_end] = true,
+  },
+  [5] = {
+    [ts_external_token__block_comment_start] = true,
+    [ts_external_token__block_string_end] = true,
+  },
+  [6] = {
+    [ts_external_token__block_comment_start] = true,
+    [ts_external_token__block_string_content] = true,
+  },
+  [7] = {
+    [ts_external_token__block_comment_start] = true,
+    [ts_external_token__block_comment_content] = true,
+  },
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void *tree_sitter_lua_external_scanner_create(void);
+void tree_sitter_lua_external_scanner_destroy(void *);
+bool tree_sitter_lua_external_scanner_scan(void *, TSLexer *, const bool *);
+unsigned tree_sitter_lua_external_scanner_serialize(void *, char *);
+void tree_sitter_lua_external_scanner_deserialize(void *, const char *, unsigned);
+
+#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_lua(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,
+    .field_names = ts_field_names,
+    .field_map_slices = ts_field_map_slices,
+    .field_map_entries = ts_field_map_entries,
+    .supertype_map_slices = ts_supertype_map_slices,
+    .supertype_map_entries = ts_supertype_map_entries,
+    .supertype_symbols = ts_supertype_symbols,
+    .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,
+    .keyword_lex_fn = ts_lex_keywords,
+    .keyword_capture_token = sym_identifier,
+    .external_scanner = {
+      &ts_external_scanner_states[0][0],
+      ts_external_scanner_symbol_map,
+      tree_sitter_lua_external_scanner_create,
+      tree_sitter_lua_external_scanner_destroy,
+      tree_sitter_lua_external_scanner_scan,
+      tree_sitter_lua_external_scanner_serialize,
+      tree_sitter_lua_external_scanner_deserialize,
+    },
+    .primary_state_ids = ts_primary_state_ids,
+    .name = "lua",
+    .max_reserved_word_set_size = 0,
+    .metadata = {
+      .major_version = 0,
+      .minor_version = 4,
+      .patch_version = 1,
+    },
+  };
+  return &language;
+}
+#ifdef __cplusplus
+}
+#endif

codegraph-kernel/grammars/lua/scanner.c

@@ -0,0 +1,195 @@
+#include <stdio.h>
+#include "tree_sitter/alloc.h"
+#include "tree_sitter/parser.h"
+#include <wctype.h>
+
+enum TokenType {
+  BLOCK_COMMENT_START,
+  BLOCK_COMMENT_CONTENT,
+  BLOCK_COMMENT_END,
+
+  BLOCK_STRING_START,
+  BLOCK_STRING_CONTENT,
+  BLOCK_STRING_END,
+};
+
+static inline void consume(TSLexer *lexer) { lexer->advance(lexer, false); }
+
+static inline void skip(TSLexer *lexer) { lexer->advance(lexer, true); }
+
+static inline bool consume_char(char c, TSLexer *lexer) {
+  if (lexer->lookahead != c) {
+    return false;
+  }
+
+  consume(lexer);
+  return true;
+}
+
+static inline uint8_t consume_and_count_char(char c, TSLexer *lexer) {
+  uint8_t count = 0;
+  while (lexer->lookahead == c) {
+    ++count;
+    consume(lexer);
+  }
+  return count;
+}
+
+static inline void skip_whitespaces(TSLexer *lexer) {
+  while (iswspace(lexer->lookahead)) {
+    skip(lexer);
+  }
+}
+
+typedef struct {
+  char ending_char;
+  uint8_t level_count;
+} Scanner;
+
+static inline void reset_state(Scanner *scanner) {
+  scanner->ending_char = 0;
+  scanner->level_count = 0;
+}
+
+void *tree_sitter_lua_external_scanner_create() {
+  Scanner *scanner = ts_calloc(1, sizeof(Scanner));
+  return scanner;
+}
+
+void tree_sitter_lua_external_scanner_destroy(void *payload) {
+  Scanner *scanner = (Scanner *)payload;
+  ts_free(scanner);
+}
+
+unsigned tree_sitter_lua_external_scanner_serialize(void *payload, char *buffer) {
+  Scanner *scanner = (Scanner *)payload;
+  buffer[0] = scanner->ending_char;
+  buffer[1] = (char)scanner->level_count;
+  return 2;
+}
+
+void tree_sitter_lua_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
+  Scanner *scanner = (Scanner *)payload;
+  if (length == 0) return;
+  scanner->ending_char = buffer[0];
+  if (length == 1) return;
+  scanner->level_count = buffer[1];
+}
+
+static bool scan_block_start(Scanner *scanner, TSLexer *lexer) {
+  if (consume_char('[', lexer)) {
+    uint8_t level = consume_and_count_char('=', lexer);
+
+    if (consume_char('[', lexer)) {
+      scanner->level_count = level;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+static bool scan_block_end(Scanner *scanner, TSLexer *lexer) {
+  if (consume_char(']', lexer)) {
+    uint8_t level = consume_and_count_char('=', lexer);
+
+    if (scanner->level_count == level && consume_char(']', lexer)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+static bool scan_block_content(Scanner *scanner, TSLexer *lexer) {
+  while (lexer->lookahead != 0) {
+    if (lexer->lookahead == ']') {
+      lexer->mark_end(lexer);
+
+      if (scan_block_end(scanner, lexer)) {
+        return true;
+      }
+    } else {
+      consume(lexer);
+    }
+  }
+
+  return false;
+}
+
+static bool scan_comment_start(Scanner *scanner, TSLexer *lexer) {
+  if (consume_char('-', lexer) && consume_char('-', lexer)) {
+    lexer->mark_end(lexer);
+
+    if (scan_block_start(scanner, lexer)) {
+      lexer->mark_end(lexer);
+      lexer->result_symbol = BLOCK_COMMENT_START;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+static bool scan_comment_content(Scanner *scanner, TSLexer *lexer) {
+  if (scanner->ending_char == 0) { // block comment
+    if (scan_block_content(scanner, lexer)) {
+      lexer->result_symbol = BLOCK_COMMENT_CONTENT;
+      return true;
+    }
+
+    return false;
+  }
+
+  while (lexer->lookahead != 0) {
+    if (lexer->lookahead == scanner->ending_char) {
+      reset_state(scanner);
+      lexer->result_symbol = BLOCK_COMMENT_CONTENT;
+      return true;
+    }
+
+    consume(lexer);
+  }
+
+  return false;
+}
+
+bool tree_sitter_lua_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) {
+  Scanner *scanner = (Scanner *)payload;
+
+  if (valid_symbols[BLOCK_STRING_END] && scan_block_end(scanner, lexer)) {
+    reset_state(scanner);
+    lexer->result_symbol = BLOCK_STRING_END;
+    return true;
+  }
+
+  if (valid_symbols[BLOCK_STRING_CONTENT] && scan_block_content(scanner, lexer)) {
+    lexer->result_symbol = BLOCK_STRING_CONTENT;
+    return true;
+  }
+
+  if (valid_symbols[BLOCK_COMMENT_END] && scanner->ending_char == 0 && scan_block_end(scanner, lexer)) {
+    reset_state(scanner);
+    lexer->result_symbol = BLOCK_COMMENT_END;
+    return true;
+  }
+
+  if (valid_symbols[BLOCK_COMMENT_CONTENT] && scan_comment_content(scanner, lexer)) {
+    return true;
+  }
+
+  skip_whitespaces(lexer);
+
+  if (valid_symbols[BLOCK_STRING_START] && scan_block_start(scanner, lexer)) {
+    lexer->result_symbol = BLOCK_STRING_START;
+    return true;
+  }
+
+  if (valid_symbols[BLOCK_COMMENT_START]) {
+    if (scan_comment_start(scanner, lexer)) {
+      return true;
+    }
+  }
+
+  return false;
+}

codegraph-kernel/grammars/lua/tree_sitter/alloc.h

@@ -0,0 +1,54 @@
+#ifndef TREE_SITTER_ALLOC_H_
+#define TREE_SITTER_ALLOC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// 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_

codegraph-kernel/grammars/lua/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 <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#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_

codegraph-kernel/grammars/lua/tree_sitter/parser.h

@@ -0,0 +1,286 @@
+#ifndef TREE_SITTER_PARSER_H_
+#define TREE_SITTER_PARSER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#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_

codegraph-kernel/src/langs.rs

@@ -18,12 +18,17 @@ use tree_sitter::Language;
 extern "C" {
     fn tree_sitter_kotlin() -> *const ();
 }
+// Vendored lua grammar (build.rs-compiled C — the wasm's v0.4.1 revision is
+// not on crates.io; see grammars/lua and the lua-luau checklist).
+extern "C" {
+    fn tree_sitter_lua() -> *const ();
+}
 
 /// Languages this kernel binary can extract (reported by contractInfo;
 /// TS-side routing policy decides what actually routes).
-pub const LANGUAGES: [&str; 16] = [
+pub const LANGUAGES: [&str; 18] = [
     "typescript", "tsx", "javascript", "jsx", "java", "python", "go", "c", "cpp", "rust",
-    "csharp", "ruby", "php", "swift", "kotlin", "r",
+    "csharp", "ruby", "php", "swift", "kotlin", "r", "lua", "luau",
 ];
 
 pub fn grammar_for(language: &str) -> Option<Language> {
@@ -60,6 +65,14 @@ pub fn grammar_for(language: &str) -> Option<Language> {
         // R7b batch 4: crate =1.2.0, sha-identical to the r-lib v1.2.0 tag
         // the vendored wasm was built from (r checklist §Grammar prep).
         "r" => Some(tree_sitter_r::LANGUAGE.into()),
+        // R7b batch 4: v0.4.1 vendored C compiled in build.rs (revision not
+        // on crates.io — the wasm is the v0.4.1 tag, table-identical).
+        "lua" => {
+            Some(unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_lua) }.into())
+        }
+        // R7b batch 4: crate =1.2.0, sha-identical to the v1.2.0 tag the
+        // vendored wasm was built from (lua-luau checklist §Grammar prep).
+        "luau" => Some(tree_sitter_luau::LANGUAGE.into()),
         _ => None,
     }
 }

codegraph-kernel/src/lib.rs

@@ -26,6 +26,7 @@ mod go;
 mod java;
 mod kotlin;
 mod langs;
+mod lua;
 mod php;
 mod rlang;
 mod ruby;
@@ -225,6 +226,7 @@ pub fn extract_file(file_path: String, content: String, language: String) -> Res
         "swift" => swift::extract(&file_path, &content).map_err(Error::from_reason)?,
         "kotlin" => kotlin::extract(&file_path, &content).map_err(Error::from_reason)?,
         "r" => rlang::extract(&file_path, &content).map_err(Error::from_reason)?,
+        "lua" | "luau" => lua::extract(&file_path, &content, &language).map_err(Error::from_reason)?,
         _ => tsjs::extract(&file_path, &content, &language).map_err(Error::from_reason)?,
     };
     Ok(ExtractBuffers {

codegraph-kernel/src/lua.rs

@@ -0,0 +1,846 @@
+//! Lua + Luau extraction — a faithful Rust port of the lua/luau paths of
+//! `TreeSitterExtractor` (src/extraction/tree-sitter.ts) plus
+//! languages/lua.ts and languages/luau.ts (36 lines extending lua).
+//!
+//! One walker, two dialects (ccpp precedent): the differences are exactly
+//! four — luau's typeAliasTypes=['type_definition'], the `export `-slice
+//! isExported hook, the return-type signature suffix, and the grammar handle.
+//! The authoritative quirk list is docs/design/lua-luau-kernel-port-checklist.md.
+//! Load-bearing oddities preserved on purpose: the require/visitNode-hook
+//! ASYMMETRIES (top-level requires — including inside top-level if/for/while
+//! blocks — mint import nodes, while the identical statement in a function
+//! body emits `calls "require"`; a top-level `local x = foo()` initializer
+//! emits NO calls ref while a top-level global `x = foo()` does), the BFS
+//! string-win inside require args (`require(script:WaitForChild("Kid"))` →
+//! import "Kid"; `require("a".."b")` → import "a"), raw-text callees verbatim
+//! (colon forms `M:render` with `self` never stripped, brackets `t2[k2]`,
+//! newline-glued chains byte-verbatim, the `(handler)` paren-conversion),
+//! receiver-QN methods (`M.sub.deep::chained`, stack-QN nested globals like
+//! `render::leakedGlobal`), variable nodes positioned at the IDENTIFIER with
+//! positional value pairing, LuaDoc `---` keeping a leading `- ` and
+//! `--!strict` joining docstring chains, the lua↔luau isExported wire
+//! divergence (lua functions: flag ABSENT; luau functions: present-false;
+//! methods: absent in both; variables: present-false in both), and duplicate
+//! same-(kind,name,line) ids emitted twice. Positions in UTF-16 code units.
+//! Files with parse errors defer to wasm (lua ~0%; luau 1.4–7.1% both-arm).
+
+use crate::buffers::{
+    build_meta, edge_kind_index, node_kind_index, Arena, BoolFlags, EdgeRow, EmitOut, NodeRow,
+    RefRow, Tables, FLAG_IS_EXPORTED, FUNCTION_REF_CODE, NONE, NONE_STR, StrRef,
+};
+use crate::docstring::preceding_docstring;
+use crate::ids;
+use crate::textutil as util;
+use std::collections::{HashSet, VecDeque};
+use tree_sitter::{Node, Parser};
+
+/// NAME_STOPLIST (function-ref.ts).
+fn is_stoplisted(name: &str) -> bool {
+    matches!(
+        name,
+        "this" | "self" | "super" | "null" | "nil" | "true" | "false" | "undefined" | "new"
+            | "NULL" | "nullptr" | "None"
+    )
+}
+
+struct Scope {
+    row: u32,
+    kind: &'static str,
+    name: String,
+}
+
+struct Cand {
+    from: u32,
+    name: String,
+    line: u32,
+    column_byte: usize,
+    row: usize,
+}
+
+#[derive(Default)]
+struct Extra<'a> {
+    docstring: Option<String>,
+    signature: Option<String>,
+    /// Some(_) sets the present bit (luau functions/type_aliases, variables
+    /// in both dialects); None leaves the pair absent (lua functions,
+    /// methods, imports).
+    is_exported: Option<bool>,
+    qualified_name_override: Option<String>,
+    _marker: std::marker::PhantomData<&'a ()>,
+}
+
+pub struct Walker<'t> {
+    src: &'t str,
+    file_path: &'t str,
+    is_luau: bool,
+    line_starts: Vec<usize>,
+    arena: Arena,
+    tables: Tables,
+    stack: Vec<Scope>,
+    node_ids: Vec<String>,
+    defined_fn_names: HashSet<String>,
+    imported_names: HashSet<String>,
+    fn_ref_cands: Vec<Cand>,
+}
+
+pub fn extract(file_path: &str, source: &str, language: &str) -> Result<EmitOut, String> {
+    let grammar = crate::langs::grammar_for(language).ok_or("no lua/luau grammar")?;
+    let t0 = std::time::Instant::now();
+    let mut parser = Parser::new();
+    parser
+        .set_language(&grammar)
+        .map_err(|e| format!("set_language({language}) failed: {e}"))?;
+    let tree = parser
+        .parse(source, None)
+        .ok_or_else(|| "parser returned null tree".to_string())?;
+    if tree.root_node().has_error() {
+        return Err("defer: parse tree contains errors — wasm recovery is canonical".to_string());
+    }
+
+    let mut w = Walker {
+        src: source,
+        file_path,
+        is_luau: language == "luau",
+        line_starts: util::line_starts(source),
+        arena: Arena::default(),
+        tables: Tables::default(),
+        stack: Vec::new(),
+        node_ids: Vec::new(),
+        defined_fn_names: HashSet::new(),
+        imported_names: HashSet::new(),
+        fn_ref_cands: Vec::new(),
+    };
+
+    // File node (tree-sitter.ts:508-521).
+    let line_count = source.bytes().filter(|b| *b == b'\n').count() as u32 + 1;
+    let base_name = file_path.rsplit(['/', '\\']).next().unwrap_or(file_path);
+    let mut flags = BoolFlags::default();
+    flags.set(FLAG_IS_EXPORTED, false);
+    let file_id = w.arena.put(&ids::file_node_id(file_path));
+    let name_ref = w.arena.put(base_name);
+    let qn_ref = w.arena.put(file_path);
+    w.tables.push_node(&NodeRow {
+        kind: node_kind_index("file").unwrap(),
+        visibility: 0,
+        flags,
+        start_line: 1,
+        end_line: line_count,
+        start_column: 0,
+        end_column: 0,
+        name: name_ref,
+        qualified_name: qn_ref,
+        id: file_id,
+        docstring: NONE_STR,
+        signature: NONE_STR,
+        decorators: NONE_STR,
+        type_parameters: NONE_STR,
+        return_type: NONE_STR,
+        extra_json: NONE_STR,
+    });
+    w.node_ids.push(ids::file_node_id(file_path));
+    w.stack.push(Scope { row: 0, kind: "file", name: base_name.to_string() });
+
+    // No packageTypes → no namespace node. Value-refs are language-gated off.
+    w.visit(tree.root_node());
+    w.flush_fn_ref_candidates();
+    w.stack.pop();
+
+    let duration_ms = t0.elapsed().as_secs_f64() * 1000.0;
+    let meta = build_meta(&w.tables, w.arena.len(), NONE_STR, duration_ms);
+    Ok(EmitOut {
+        meta,
+        nodes: w.tables.nodes,
+        edges: w.tables.edges,
+        refs: w.tables.refs,
+        arena: w.arena.into_vec(),
+    })
+}
+
+impl<'t> Walker<'t> {
+    fn text(&self, node: Node) -> &'t str {
+        &self.src[node.byte_range()]
+    }
+    fn line_of(&self, node: Node) -> u32 {
+        node.start_position().row as u32 + 1
+    }
+    fn col_of(&self, node: Node) -> u32 {
+        util::col16(self.src, &self.line_starts, node.start_position().row, node.start_byte())
+    }
+    fn end_col_of(&self, node: Node) -> u32 {
+        util::col16(self.src, &self.line_starts, node.end_position().row, node.end_byte())
+    }
+    fn top_row(&self) -> u32 {
+        self.stack.last().map(|s| s.row).unwrap_or(0)
+    }
+
+    fn push_ref_at(&mut self, from_row: u32, name: &str, kind: &str, node: Node) {
+        let name_ref = self.arena.put(name);
+        self.tables.push_ref(&RefRow {
+            from_idx: from_row,
+            kind: edge_kind_index(kind).unwrap(),
+            line: self.line_of(node),
+            column: self.col_of(node),
+            reference_name: name_ref,
+            candidates: NONE_STR,
+            from_id_str: NONE_STR,
+        });
+        // flushFnRefCandidates' importedNames gate (tree-sitter.ts:661-675):
+        // dotted lua module paths contribute their LAST segment; simple names
+        // (Roblox leaves) pass whole.
+        if kind == "imports" {
+            if util::simple_name().is_match(name) {
+                self.imported_names.insert(name.to_string());
+            } else if let Some(c) = util::qualified_import().captures(name) {
+                self.imported_names.insert(c[1].to_string());
+            }
+        }
+    }
+
+    // --- createNode (tree-sitter.ts:1308) ---------------------------------
+
+    fn create_node(&mut self, kind: &'static str, name: &str, node: Node<'t>, extra: Extra) -> Option<u32> {
+        if name.is_empty() {
+            return None;
+        }
+        let start_line = self.line_of(node);
+        let id = ids::node_id(self.file_path, kind, name, start_line);
+
+        // buildQualifiedName (1447-1460) — non-file stack NAMES joined `::`;
+        // the receiver override (extractMethod:1790-1792) replaces it whole.
+        let qualified = match &extra.qualified_name_override {
+            Some(qn) => qn.clone(),
+            None => {
+                let mut parts: Vec<&str> = Vec::new();
+                for s in &self.stack {
+                    if s.kind != "file" {
+                        parts.push(&s.name);
+                    }
+                }
+                let mut qn = parts.join("::");
+                if !qn.is_empty() {
+                    qn.push_str("::");
+                }
+                qn.push_str(name);
+                qn
+            }
+        };
+
+        let name_ref = self.arena.put(name);
+        let qn_ref = self.arena.put(&qualified);
+        let id_ref = self.arena.put(&id);
+        let doc_ref = opt_str(&mut self.arena, extra.docstring.as_deref());
+        let sig_ref = opt_str(&mut self.arena, extra.signature.as_deref());
+        let mut flags = BoolFlags::default();
+        if let Some(v) = extra.is_exported {
+            flags.set(FLAG_IS_EXPORTED, v);
+        }
+        let row = self.tables.push_node(&NodeRow {
+            kind: node_kind_index(kind).unwrap(),
+            visibility: 0,
+            flags,
+            start_line,
+            end_line: node.end_position().row as u32 + 1, // no resolveBody
+            start_column: self.col_of(node),
+            end_column: self.end_col_of(node),
+            name: name_ref,
+            qualified_name: qn_ref,
+            id: id_ref,
+            docstring: doc_ref,
+            signature: sig_ref,
+            decorators: NONE_STR,
+            type_parameters: NONE_STR,
+            return_type: NONE_STR,
+            extra_json: NONE_STR,
+        });
+        self.node_ids.push(id);
+        if kind == "function" || kind == "method" {
+            self.defined_fn_names.insert(name.to_string());
+        }
+
+        let parent_row = self.top_row();
+        self.tables.push_edge(&EdgeRow {
+            source_idx: parent_row,
+            target_idx: row,
+            kind: edge_kind_index("contains").unwrap(),
+            provenance: 0,
+            line: NONE,
+            column: NONE,
+            metadata_json: NONE_STR,
+            source_id_str: NONE_STR,
+            target_id_str: NONE_STR,
+        });
+
+        Some(row)
+    }
+
+    // --- lua.ts helper transcriptions -------------------------------------
+
+    /// findDescendant (lua.ts:9-17) — breadth-first over namedChildren.
+    fn find_descendant(&self, node: Node<'t>, kind: &str) -> Option<Node<'t>> {
+        let mut queue: VecDeque<Node<'t>> = VecDeque::new();
+        let mut cursor = node.walk();
+        for c in node.named_children(&mut cursor) {
+            queue.push_back(c);
+        }
+        while let Some(n) = queue.pop_front() {
+            if n.kind() == kind {
+                return Some(n);
+            }
+            let mut cur = n.walk();
+            for c in n.named_children(&mut cur) {
+                queue.push_back(c);
+            }
+        }
+        None
+    }
+
+    /// requireModule (lua.ts:28-60).
+    fn require_module(&self, call: Node<'t>) -> Option<String> {
+        let name = call.child_by_field_name("name")?;
+        if name.kind() != "identifier" || self.text(name) != "require" {
+            return None;
+        }
+        let args = call.child_by_field_name("arguments")?;
+
+        // String win: first string_content descendant, BFS order.
+        if let Some(content) = self.find_descendant(args, "string_content") {
+            let t = self.text(content).trim();
+            return if t.is_empty() { None } else { Some(t.to_string()) };
+        }
+        // Fallback: a string node with no content child — strip [[ ]] / quotes.
+        if let Some(s) = self.find_descendant(args, "string") {
+            let mut t = self.text(s).trim();
+            t = t.strip_prefix("[[").unwrap_or(t);
+            t = t.strip_suffix("]]").unwrap_or(t);
+            t = t.strip_prefix(['"', '\'']).unwrap_or(t);
+            t = t.strip_suffix(['"', '\'']).unwrap_or(t);
+            if !t.is_empty() {
+                return Some(t.to_string());
+            }
+        }
+        // Roblox instance path: trailing field/method segment.
+        let idx = self
+            .find_descendant(args, "dot_index_expression")
+            .or_else(|| self.find_descendant(args, "method_index_expression"));
+        if let Some(idx) = idx {
+            if let Some(field) = idx
+                .child_by_field_name("field")
+                .or_else(|| idx.child_by_field_name("method"))
+            {
+                let t = self.text(field).trim();
+                return if t.is_empty() { None } else { Some(t.to_string()) };
+            }
+        }
+        None
+    }
+
+    /// The hook's `emit` (lua.ts:108-126): import node at the CALL node +
+    /// imports ref from the stack top.
+    fn emit_require(&mut self, call: Node<'t>, module: &str) {
+        let (sig, _) = util::slice_utf16(self.text(call).trim(), 100);
+        let imp = self.create_node(
+            "import",
+            module,
+            call,
+            Extra { signature: Some(sig), ..Default::default() },
+        );
+        if imp.is_some() && !self.stack.is_empty() {
+            let parent_row = self.top_row();
+            self.push_ref_at(parent_row, module, "imports", call);
+        }
+    }
+
+    /// getReceiverType (lua.ts:92-99).
+    fn receiver_type(&self, node: Node<'t>) -> Option<&'t str> {
+        let name = node.child_by_field_name("name")?;
+        if name.kind() == "dot_index_expression" || name.kind() == "method_index_expression" {
+            return name.child_by_field_name("table").map(|t| self.text(t));
+        }
+        None
+    }
+
+    /// extractName (tree-sitter.ts:98-192) — the lua-reachable branches.
+    fn extract_name(&self, node: Node<'t>) -> String {
+        if let Some(name_node) = node.child_by_field_name("name") {
+            // Lua: dot/method index → the trailing field/method segment.
+            if name_node.kind() == "dot_index_expression" {
+                if let Some(f) = name_node.child_by_field_name("field") {
+                    return self.text(f).to_string();
+                }
+            }
+            if name_node.kind() == "method_index_expression" {
+                if let Some(m) = name_node.child_by_field_name("method") {
+                    return self.text(m).to_string();
+                }
+            }
+            return self.text(name_node).to_string();
+        }
+        // Fallback: first identifier-ish named child.
+        let mut cursor = node.walk();
+        for c in node.named_children(&mut cursor) {
+            if matches!(c.kind(), "identifier" | "type_identifier" | "simple_identifier" | "constant") {
+                return self.text(c).to_string();
+            }
+        }
+        "<anonymous>".to_string()
+    }
+
+    /// getSignature — lua (lua.ts:83-86) / luau (luau.ts:26-35).
+    fn signature_of(&self, node: Node<'t>) -> Option<String> {
+        let params = node.child_by_field_name("parameters")?;
+        let mut sig = self.text(params).to_string();
+        if self.is_luau {
+            // Return type = the named child AFTER `parameters` (found by
+            // startIndex match), unless it's the block.
+            let mut cursor = node.walk();
+            let kids: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
+            if let Some(idx) = kids.iter().position(|k| k.start_byte() == params.start_byte()) {
+                if let Some(ret) = kids.get(idx + 1) {
+                    if ret.kind() != "block" {
+                        sig.push_str(": ");
+                        sig.push_str(self.text(*ret));
+                    }
+                }
+            }
+        }
+        Some(sig)
+    }
+
+    /// isExported (luau.ts:23) — the raw 7-unit slice is an ASCII prefix test.
+    fn is_exported_of(&self, node: Node<'t>) -> Option<bool> {
+        if self.is_luau {
+            Some(self.text(node).starts_with("export "))
+        } else {
+            None
+        }
+    }
+
+    // --- the main walk (visitNode, tree-sitter.ts:936-1303) ---------------
+
+    fn visit(&mut self, node: Node<'t>) {
+        let kind = node.kind();
+
+        // The visitNode hook (lua.ts:105-151) runs FIRST.
+        if kind == "function_call" {
+            if let Some(module) = self.require_module(node) {
+                self.emit_require(node, &module);
+                // Consumed → scanFnRefSubtree (tree-sitter.ts:951).
+                self.scan_fn_ref_subtree(node, 0);
+                return;
+            }
+            // falls through — extractCall claims it below
+        } else if kind == "variable_declaration" {
+            // `local x = require(...)` — dig requires out of the initializer
+            // the variable branch will skip. Always falls through.
+            let mut cursor = node.walk();
+            let assign = node.named_children(&mut cursor).find(|c| c.kind() == "assignment_statement");
+            if let Some(assign) = assign {
+                let mut ac = assign.walk();
+                let expr_list = assign.named_children(&mut ac).find(|c| c.kind() == "expression_list");
+                if let Some(expr_list) = expr_list {
+                    let mut ec = expr_list.walk();
+                    let vals: Vec<Node<'t>> = expr_list.named_children(&mut ec).collect();
+                    for val in vals {
+                        if val.kind() == "function_call" {
+                            if let Some(module) = self.require_module(val) {
+                                self.emit_require(val, &module);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // maybeCaptureFnRefs (tree-sitter.ts:990).
+        self.maybe_capture_fn_refs(node);
+
+        // The dispatch ladder — lua/luau rows only.
+        if kind == "function_declaration" {
+            // isInsideClassLikeNode is always false (no class-like kinds).
+            self.extract_function(node);
+            return; // skipChildren — the body walk handles children
+        }
+        if self.is_luau && kind == "type_definition" {
+            let skip = self.extract_type_alias(node);
+            if skip {
+                return;
+            }
+            // plain path returns false → children re-visited (the
+            // typeof(require(...)) alias+import pair rides this).
+        } else if kind == "variable_declaration" {
+            self.extract_variable(node);
+            // Initializer subtrees are never walked — candidates only.
+            self.scan_fn_ref_subtree(node, 0);
+            return; // skipChildren
+        } else if kind == "function_call" {
+            self.extract_call(node);
+            // no skipChildren — nested/inner calls each get their own ref
+        }
+
+        let mut cursor = node.walk();
+        let children: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
+        for child in children {
+            self.visit(child);
+        }
+    }
+
+    // --- extractFunction / extractMethod (1517 / 1737) --------------------
+
+    fn extract_function(&mut self, node: Node<'t>) {
+        // :1522 receiver short-circuit IS the method routing.
+        if let Some(receiver) = self.receiver_type(node) {
+            let receiver = receiver.to_string();
+            self.extract_method(node, receiver);
+            return;
+        }
+        let name = self.extract_name(node);
+        if name == "<anonymous>" {
+            // Unreachable for function_declaration (grammar requires a name)
+            // but preserved: body walked with nothing pushed.
+            if let Some(body) = node.child_by_field_name("body") {
+                self.visit_body(body);
+            }
+            return;
+        }
+        let docstring = preceding_docstring(node, self.src);
+        let signature = self.signature_of(node);
+        let is_exported = self.is_exported_of(node); // lua None / luau Some(false)
+        let fn_row = self.create_node(
+            "function",
+            &name,
+            node,
+            Extra { docstring, signature, is_exported, ..Default::default() },
+        );
+        let Some(row) = fn_row else { return };
+        // extractTypeAnnotations / extractDecoratorsFor: structurally zero
+        // output for lua/luau (gates + no decorator kinds in scan positions).
+        self.stack.push(Scope { row, kind: "function", name });
+        if let Some(body) = node.child_by_field_name("body") {
+            self.visit_body(body);
+        }
+        self.stack.pop();
+    }
+
+    fn extract_method(&mut self, node: Node<'t>, receiver: String) {
+        let name = self.extract_name(node);
+        let docstring = preceding_docstring(node, self.src);
+        let signature = self.signature_of(node);
+        // extractMethod passes NO isExported — absent for BOTH dialects.
+        // QN override (:1790-1792): `receiver::name` verbatim (namespacePrefix
+        // is empty outside C++).
+        let qn = format!("{receiver}::{name}");
+        let method_row = self.create_node(
+            "method",
+            &name,
+            node,
+            Extra {
+                docstring,
+                signature,
+                qualified_name_override: Some(qn),
+                ..Default::default()
+            },
+        );
+        let Some(row) = method_row else { return };
+        // Owner-contains (:1799-1813) never fires: lua mints no
+        // struct/class/enum/trait nodes for a receiver name to match.
+        self.stack.push(Scope { row, kind: "method", name });
+        if let Some(body) = node.child_by_field_name("body") {
+            self.visit_body(body);
+        }
+        self.stack.pop();
+    }
+
+    // --- extractVariable — the lua/luau branch (2538-2549, 2789-2805) -----
+
+    fn extract_variable(&mut self, node: Node<'t>) {
+        // isConst absent → kind is ALWAYS `variable`; docstring from the
+        // DECLARATION node; isExported = hook ?? false → false for BOTH
+        // dialects (luau's slice sees `local …`).
+        let docstring = preceding_docstring(node, self.src);
+        let is_exported = self.is_exported_of(node).unwrap_or(false);
+
+        let mut cursor = node.walk();
+        let assign = node
+            .named_children(&mut cursor)
+            .find(|c| c.kind() == "assignment_statement")
+            .unwrap_or(node);
+        let mut ac = assign.walk();
+        let var_list = assign.named_children(&mut ac).find(|c| c.kind() == "variable_list");
+        let mut ec = assign.walk();
+        let expr_list = assign.named_children(&mut ec).find(|c| c.kind() == "expression_list");
+        let values: Vec<Node<'t>> = match expr_list {
+            Some(el) => {
+                let mut c = el.walk();
+                el.named_children(&mut c).collect()
+            }
+            None => Vec::new(),
+        };
+        let names: Vec<Node<'t>> = match var_list {
+            Some(vl) => {
+                let mut c = vl.walk();
+                vl.named_children(&mut c).filter(|n| n.kind() == "identifier").collect()
+            }
+            None => Vec::new(),
+        };
+        for (i, name_node) in names.iter().enumerate() {
+            let name = self.text(*name_node);
+            if name.is_empty() {
+                continue;
+            }
+            // Positional value pairing; a missing value → NO signature key.
+            let signature = values.get(i).map(|v| util::init_signature(self.text(*v)));
+            let name = name.to_string();
+            self.create_node(
+                "variable",
+                &name,
+                *name_node, // positioned at the IDENTIFIER
+                Extra {
+                    docstring: docstring.clone(),
+                    signature,
+                    is_exported: Some(is_exported),
+                    ..Default::default()
+                },
+            );
+        }
+    }
+
+    // --- extractTypeAlias (2890; plain path 2967-2991) — luau only --------
+
+    /// Returns skipChildren (always false on the plain path).
+    fn extract_type_alias(&mut self, node: Node<'t>) -> bool {
+        let name = self.extract_name(node); // generic_type name → verbatim text
+        if name == "<anonymous>" {
+            return false;
+        }
+        let docstring = preceding_docstring(node, self.src);
+        let is_exported = self.is_exported_of(node); // Some(true) for `export type`
+        self.create_node(
+            "type_alias",
+            &name,
+            node,
+            Extra { docstring, is_exported, ..Default::default() },
+        );
+        // TYPE_ANNOTATION_LANGUAGES excludes luau → no alias-value refs.
+        false // children re-visited by the ladder
+    }
+
+    // --- extractCall (3684; generic tail 4313, 4518-4532, 4572-4580) ------
+
+    fn extract_call(&mut self, node: Node<'t>) {
+        if self.stack.is_empty() {
+            return;
+        }
+        let caller_row = self.top_row();
+        // The `function` field is NULL in this grammar → namedChild(0) (the
+        // `name:` child). Member branch never fires (dot/method_index aren't
+        // in its type list) → raw source text, then the paren-conversion.
+        let func = node
+            .child_by_field_name("function")
+            .or_else(|| node.named_child(0));
+        let Some(func) = func else { return };
+        let mut callee: &str = self.text(func);
+        if let Some(caps) = util::paren_conversion().captures(callee) {
+            if let Some(inner) = caps.get(1) {
+                callee = &callee[inner.range()];
+            }
+        }
+        if callee.is_empty() {
+            return;
+        }
+        let callee = callee.to_string();
+        self.push_ref_at(caller_row, &callee, "calls", node);
+    }
+
+    // --- visitFunctionBody (5129-5286) — the hook-free body walk ----------
+
+    fn visit_body(&mut self, node: Node<'t>) {
+        // maybeCaptureFnRefs (5137) fires in the body walker too.
+        self.maybe_capture_fn_refs(node);
+
+        let kind = node.kind();
+        if kind == "function_call" {
+            // The hook NEVER runs here — a body-level require emits
+            // `calls "require"` (the neovim lazy-loading idiom).
+            self.extract_call(node);
+            // falls through to recursion — chains emit every link
+        } else if kind == "function_declaration" {
+            // Nested NAMED functions (5245-5250): extractFunction walks the
+            // nested body itself, so return. extractName is never
+            // `<anonymous>` for function_declaration.
+            self.extract_function(node);
+            return;
+        }
+        // variable_declaration / type_definition have NO branch here → plain
+        // recursion: body-local initializers ARE walked (calls emit), no
+        // variable/type_alias nodes minted.
+
+        let mut cursor = node.walk();
+        let children: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
+        for child in children {
+            self.visit_body(child);
+        }
+    }
+
+    // --- function-as-value capture (#756) — LUA_SPEC ----------------------
+
+    fn maybe_capture_fn_refs(&mut self, node: Node<'t>) {
+        // LUA_SPEC dispatch: arguments → args; assignment_statement → rhs
+        // (no field — last named child; param-storage skip via namedChild(0));
+        // field → value (field 'value', last-named-child fallback).
+        let mode: &str = match node.kind() {
+            "arguments" => "args",
+            "assignment_statement" => "rhs",
+            "field" => "value",
+            _ => return,
+        };
+        if self.stack.is_empty() {
+            return;
+        }
+        let from = self.top_row();
+
+        let mut values: Vec<Node<'t>> = Vec::new();
+        match mode {
+            "args" => {
+                let mut cursor = node.walk();
+                for c in node.named_children(&mut cursor) {
+                    values.push(c);
+                }
+            }
+            "rhs" => {
+                // No `field` in the rule → RHS = LAST named child (the
+                // expression_list). Param-storage skip: lhs =
+                // left/lhs/target field ?? namedChild(0) when ≥2 children;
+                // its trailing identifier vs the whole RHS text.
+                let count = node.named_child_count();
+                let rhs = if count > 0 { node.named_child(count - 1) } else { None };
+                if let Some(rhs) = rhs {
+                    let lhs = node
+                        .child_by_field_name("left")
+                        .or_else(|| node.child_by_field_name("lhs"))
+                        .or_else(|| node.child_by_field_name("target"))
+                        .or_else(|| if count >= 2 { node.named_child(0) } else { None });
+                    let lhs_text = lhs.map(|l| self.text(l)).unwrap_or("");
+                    let lhs_last = util::lhs_last_name()
+                        .captures(lhs_text)
+                        .and_then(|c| c.get(1))
+                        .map(|m| m.as_str());
+                    if !(lhs_last.is_some() && lhs_last == Some(self.text(rhs).trim())) {
+                        values.push(rhs);
+                    }
+                }
+            }
+            _ => {
+                // value — the `value` field (keyed AND positional table
+                // fields carry it), falling back to the last named child.
+                let v = node.child_by_field_name("value").or_else(|| {
+                    let count = node.named_child_count();
+                    if count > 0 { node.named_child(count - 1) } else { None }
+                });
+                if let Some(v) = v {
+                    values.push(v);
+                }
+            }
+        }
+
+        for v in values {
+            self.normalize_fn_ref_value(v, from, 0);
+        }
+    }
+
+    /// normalizeValue with LUA_SPEC's one transparent layer (expression_list
+    /// fans out to named children).
+    fn normalize_fn_ref_value(&mut self, v: Node<'t>, from: u32, depth: u32) {
+        if depth > 4 {
+            return;
+        }
+        match v.kind() {
+            "identifier" => {
+                let name = self.text(v).to_string();
+                if name.is_empty() || is_stoplisted(&name) {
+                    return;
+                }
+                let p = v.start_position();
+                self.fn_ref_cands.push(Cand {
+                    from,
+                    name,
+                    line: p.row as u32 + 1,
+                    column_byte: v.start_byte(),
+                    row: p.row,
+                });
+            }
+            "expression_list" => {
+                let mut cursor = v.walk();
+                let kids: Vec<Node<'t>> = v.named_children(&mut cursor).collect();
+                for c in kids {
+                    self.normalize_fn_ref_value(c, from, depth + 1);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn scan_fn_ref_subtree(&mut self, node: Node<'t>, depth: u32) {
+        if depth > 12 {
+            return;
+        }
+        // Halt at nested function definitions (their bodies are walked — and
+        // attributed — by extractFunction). function_definition (anonymous)
+        // is deliberately NOT in the halt list — the scan descends into
+        // anonymous initializer bodies, attributing candidates to the file.
+        if depth > 0
+            && matches!(
+                node.kind(),
+                "function_declaration" | "arrow_function" | "function_expression"
+                    | "lambda_literal" | "lambda_expression"
+            )
+        {
+            return;
+        }
+        self.maybe_capture_fn_refs(node);
+        let mut cursor = node.walk();
+        let children: Vec<Node<'t>> = node.named_children(&mut cursor).collect();
+        for c in children {
+            self.scan_fn_ref_subtree(c, depth + 1);
+        }
+    }
+
+    fn flush_fn_ref_candidates(&mut self) {
+        let cands = std::mem::take(&mut self.fn_ref_cands);
+        if cands.is_empty() || util::is_generated_file(self.file_path) {
+            return;
+        }
+        let mut seen: HashSet<(String, String)> = HashSet::new();
+        for c in cands {
+            // Gate: same-file function/method names ∪ imported names (lua
+            // candidates are always bare identifiers — no `this.`/`::`).
+            if !c.name.starts_with("this.")
+                && !c.name.contains("::")
+                && !self.defined_fn_names.contains(&c.name)
+                && !self.imported_names.contains(&c.name)
+            {
+                continue;
+            }
+            if !seen.insert((self.node_ids[c.from as usize].clone(), c.name.clone())) {
+                continue;
+            }
+            let column = util::col16(self.src, &self.line_starts, c.row, c.column_byte);
+            let name_ref = self.arena.put(&c.name);
+            self.tables.push_ref(&RefRow {
+                from_idx: c.from,
+                kind: FUNCTION_REF_CODE,
+                line: c.line,
+                column,
+                reference_name: name_ref,
+                candidates: NONE_STR,
+                from_id_str: NONE_STR,
+            });
+        }
+    }
+}
+
+fn opt_str(arena: &mut Arena, s: Option<&str>) -> StrRef {
+    match s {
+        Some(s) => arena.put(s),
+        None => NONE_STR,
+    }
+}

docs/design/lua-luau-kernel-port-checklist.md

@@ -0,0 +1,744 @@
+# Lua + Luau kernel port (R7b batch 4) — the bug-for-bug checklist
+
+**Status: SURVEY COMPLETE (2026-07-20)** — one combined checklist for BOTH
+languages: `languages/luau.ts` is 36 lines extending `languages/lua.ts`, the two
+grammars share their node-name vocabulary, and the recommendation is ONE walker
+module (`codegraph-kernel/src/lua.rs`, ccpp-style language-parameterized —
+`"lua" | "luau" => lua::extract(&file_path, &content, &language)` in
+lib.rs:214-226). Survey basis: every TS-side branch a `.lua`/`.luau` file
+exercises, with file:line anchors as of **`45a53eb`** (HEAD at survey time,
+clean main). Every grammar-shape claim was **probed against the production
+vendored wasms** (`dist/extraction/wasm/tree-sitter-{lua,luau}.wasm`) via CST
+dumps and childForFieldName truth tables, and every extraction-behavior claim
+was **pinned against the real `dist/` extractor** (`extract-*.txt` ground-truth
+dumps in the session scratchpad `svy-lua/` — §Probe artifacts), not derived
+from code reading alone. Read WITH
+`docs/design/rust-kernel-migration-plan.md` (§0a recipe, §2 boundary, §4
+tracker, §5 gates) and the format precedents
+(`kotlin-kernel-port-checklist.md` — the depth bar — plus
+`swift-kernel-port-checklist.md`, `ruby-kernel-port-checklist.md`).
+
+**Blocking findings: none.** Three eyes-open items. (1) **No grammar bump at
+all** — both languages are already in `VENDORED_WASM_LANGS` (grammars.ts:292)
+and the vendored wasms are the exact port-target revisions
+(`../scratchpad/batch4-grammar-probe.md`, verified 2026-07-20: lua = the
+v0.4.1 tag, table-identical; luau = crate 1.2.0, table-identical). The port is
+kernel-side only: lua takes the **vendored-grammar-C route** (kotlin
+mechanism, second use) because v0.4.1 is not on crates.io; luau is a plain
+**crate pin `tree-sitter-luau = "=1.2.0"`** (csharp-style), and the crate
+tarball's parser.c/scanner.c are **sha-identical to the v1.2.0 tag**
+(§Grammar prep — the swift tag≠crate divergence does NOT recur here). (2)
+**Error incidence is near-zero for lua** (kong 0.08% — a single deliberately
+invalid fixture; lazy.nvim and lua-resty-core 0.00%) — ruby-style: **any
+deferral on a lua sweep is a walker-bug signal**. Luau real-world incidence is
+**1.4–7.1%** (lune 1.36%, Fusion 7.08%), driven by two grammar-inherent
+shapes — generic type packs `(A...) -> T` and default type parameters
+`<T = D>` — both-arm by construction (same grammar revision on both arms).
+(3) The single biggest bug-for-bug surface is the **require/`visitNode`-hook
+machinery** and its **asymmetries**: requires at top level (anywhere visitNode
+reaches, including inside top-level `if`/`for`/`while` blocks) become `import`
+nodes, while the IDENTICAL statement inside a function body emits a
+**`calls "require"` ref** (visitFunctionBody never runs the hook); a top-level
+`local x = foo()` initializer emits **no** calls ref while a top-level global
+assignment `x = foo()` **does** (§extractVariable). Get these exactly wrong
+and sweeps light up on file one.
+
+## Grammar prep (kernel-side only — no wasm change, no bump gate)
+
+Both languages already ship vendored wasms (`VENDORED_WASM_LANGS`,
+grammars.ts:291-293; file map `lua: 'tree-sitter-lua.wasm'` /
+`luau: 'tree-sitter-luau.wasm'` at grammars.ts:39,41; the :255 comment
+records WHY lua was vendored — tree-sitter-wasms' ABI-13 build corrupted the
+shared WASM heap). Provenance was verified in the batch-4 grammar probe
+(`../scratchpad/batch4-grammar-probe.md`) and re-verified in this survey:
+
+- **lua** — vendored wasm ≡ **tree-sitter-grammars/tree-sitter-lua v0.4.1**,
+  tag commit `816840c592ab973500ae9750763c707b447e7fef` (release asset
+  table-identical, 0 positional mismatches). Tag parser.c declares
+  **ABI 15, STATE_COUNT 262, SYMBOL_COUNT 137, FIELD_COUNT 22** (verified in
+  the tag clone — matches the wasm's tables). **v0.4.1 is NOT on crates.io**
+  (only 0.1/0.2/0.5 exist) → **vendored-grammar-C route**, the kotlin
+  mechanism (`codegraph-kernel/grammars/kotlin` + build.rs cc precedent).
+  0.5.0 adds Lua-5.5 `global` (+1 field) — a future accuracy bump, NOT this
+  batch.
+- **luau** — vendored wasm ≡ **tree-sitter-grammars/tree-sitter-luau v1.2.0
+  ≡ crates.io crate 1.2.0**. Survey-verified sha match, tag ↔ crate tarball
+  (the swift lesson checked and CLEAR):
+  - `src/parser.c` `8f25bc1779400fa93d5492310e291fb895363ec051d44753444e724e99a08250` (both)
+  - `src/scanner.c` `a157bb5210454add058a08ce53eabcccad41aab6dac7006def2554e5cfebd376` (both)
+  Tag commit `a8914d6c1fc5131f8e1c13f769fa704c9f5eb02f`. parser.c declares
+  **ABI 14, STATE_COUNT 585, SYMBOL_COUNT 197, FIELD_COUNT 21**. Crate deps:
+  `tree-sitter-language = "0.1"` + `cc` build-dep, `tree-sitter` only as a
+  dev-dep (0.26.3) → **no pin conflict** with the kernel's tree-sitter 0.25.
+  Route: **`tree-sitter-luau = "=1.2.0"`** in codegraph-kernel/Cargo.toml,
+  `"luau" => Some(tree_sitter_luau::LANGUAGE.into())` in langs.rs.
+- **Lua kernel C vendor** (`codegraph-kernel/grammars/lua/`), from the v0.4.1
+  tag's CHECKED-IN generated artifacts (lua HAS an external scanner — comments
+  and long strings):
+  - `src/parser.c`  `b34a362e43f0311f405721f3089e94f97f31da403b154d456d093e64609a4081`
+  - `src/scanner.c` `35bbd630b5a7421d46d2e91185eeea09bf78565d44cb676b63ca20d0f1b54bbd`
+  - `src/tree_sitter/alloc.h`  `b29c1c9fb7cc82f58c84b376df1297d6e2737a1d655fd356db0859e3c29c2fea`
+  - `src/tree_sitter/array.h`  `5bdf6ed1a78e3409fd443e085ca967a64c188a5d082aaf7f819bccd53a471c94`
+  - `src/tree_sitter/parser.h` `180b893c8734778fd32f372dfbc27bd6ad1cd2221f26150b31256ff6716320d2`
+  build.rs: extend the kotlin block — `cc::Build` with
+  `include("grammars/lua")`, `file(parser.c)`, `file(scanner.c)`; crib the
+  tag's own `bindings/rust/build.rs` flags (`.std("c11")`, include src, msvc
+  `-utf-8`); `println!("cargo:rerun-if-changed=grammars/lua")`. langs.rs:
+  `extern "C" { fn tree_sitter_lua() -> *const (); }` +
+  `"lua" => Some(unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_lua) }.into())`
+  (kotlin precedent, langs.rs:17-20,57). `LANGUAGES: [&str; 15]` → **17**
+  (langs.rs:24).
+- **Grammar-parity rows**: `__tests__/kernel-grammar-parity.test.ts:39`
+  `GRAMMAR_LANGUAGES += 'lua', 'luau'` — asserts the C build / crate and the
+  vendored wasm are the same revision (id-by-id kind+field tables, ABI 15 for
+  lua / ABI 14 for luau). This replaces the bump gate entirely: there is no
+  old-vs-new dump-diff because nothing wasm-side changes.
+- **Error incidence** (current wasm, all files ≤1MiB, `error-sweep.cjs`):
+
+  | Repo | lang | files | hasError | phantoms | first-error classes |
+  |---|---|---|---|---|---|
+  | Kong/kong | lua | 1,309 | 1 (0.08%) | 0 | `spec/fixtures/invalid-module.lua` — deliberately invalid |
+  | folke/lazy.nvim | lua | 65 | 0 (0.00%) | 0 | — |
+  | openresty/lua-resty-core | lua | 38 | 0 (0.00%) | 0 | — |
+  | lune-org/lune | luau | 221 | 3 (1.36%) | 0 | `.d.luau` type-pack/typeof declaration shapes |
+  | dphfox/Fusion | luau | 113 | 8 (7.08%) | 0 | generic type packs `(A...) -> T`; default type params `type Scope<C = Fusion>` |
+  | luau-lang/luau (tests/) | luau | 203 | 39 (19.21%) | 0 | STRESS ONLY — deliberate future-syntax tests (`class Point`, `123i`, `export local`) |
+  | JohnnyMorganz/StyLua (tests/) | lua | 419 | 118 (28.16%) | 0 | STRESS ONLY — cfxlua dialect (`+=`, C comments), luau-in-.lua corpora |
+
+  **ZERO phantom-hasError files anywhere** (hasError with no ERROR/missing
+  node — probed per-file across all 2,368 files, plus 31 targeted snippet
+  probes in `mini-probes-{lua,luau}.out`): unlike kotlin, the defer signal is
+  always accompanied by a real ERROR node. Still gate on `has_error()` alone —
+  don't scan for ERROR nodes. Error-class probes (`errclass*.luau`): luau
+  default type parameters `type X<T = D>` and generic packs `(A...) -> T`
+  ERROR; luau also rejects `@native`/`@checked` attributes (real-Luau 2024+
+  syntax the 1.2.0 grammar predates) and lua-only syntax (`goto`, bitwise
+  `a & b`); lua rejects luau-isms (`type X = …`, `continue`, `+=`, backtick
+  interpolation) — cfxlua dialect files land here too. All of these defer to
+  wasm, which errors identically (same tables both arms) and still emits its
+  best-effort partial extraction.
+- Sweep defaults: `--max-deferral 0.1` (kernel-parity.mjs:38) holds
+  everywhere. Expect **0–1 deferrals on lua** repos (treat >0 as suspicious,
+  ruby-style) and **1.4–7.1% on luau** (typed-framework codebases sit at the
+  high end; a JUMP past ~10% is the bug signal).
+
+## Architecture decisions
+
+1. **One walker module, two grammar entries.** `codegraph-kernel/src/lua.rs`
+   with a dialect flag (ccpp precedent — lib.rs:219 `"c" | "cpp" =>
+   ccpp::extract(..., &language)`). The dialect differences are exactly four
+   (§Extractor config): typeAliasTypes, isExported, getSignature return
+   suffix, grammar handle. Everything else — require hook, receiver methods,
+   variable branch, call shapes, docstrings, fn-refs — is byte-shared.
+   **go.rs is the closest crib** (receiver-QN methods, extract_type_alias →
+   bool, `node_ids` vec, fn-ref flush deduped on `node_ids[from]` go.rs:1047).
+2. **No preParse** (neither lua.ts nor luau.ts has the hook; luau spreads
+   lua) → `preParsedSource` (kernel/index.ts:109-112) is a no-op; both arms
+   parse raw bytes. **No POST_PASSES entry** → `tryKernelExtractRaw` stays
+   eligible (kernel/index.ts:183).
+3. **No framework resolver lists lua/luau** (grepped
+   `src/resolution/frameworks/*` — zero hits) → no decoded-path forcing in
+   parse-worker; all repos ride the raw buffers-to-store transport. No
+   synthesis consumer either: `CC_LANGUAGES = {swift, kotlin}`
+   (callback-synthesizer.ts:77), `NATIVE = {java, kotlin, objc, cpp}`
+   (:1649). The only downstream consumers are resolution-side and
+   contract-pinned in §Resolution consumers.
+4. **`.lua` → `lua`, `.luau` → `luau`** purely by extension
+   (grammars.ts:122-123, `detectLanguage` :469 — no content sniffing; project
+   `codegraph.json` extension overrides are TS-side and upstream of the
+   kernel). MAX_FILE_SIZE (1 MiB) and generated-file skips are
+   orchestrator-side and shared.
+5. **REF_FLAG_FILE_PATH (wire v2) is NOT needed.** The lua hook's
+   `addUnresolvedReference` (lua.ts:117-123) passes no `filePath`; zero refs
+   in any ground-truth dump carried one. The ruby/php bit stays unused.
+6. **Value-refs, static-member refs, type-annotation refs, instantiates,
+   extends/implements, decorates: ALL structurally absent** for lua/luau —
+   §Dead machinery. The walker needs cheap early-outs that preserve exactly
+   this nothing.
+7. **Deferral policy**: per-file `has_error()` → `defer:` (ruby.rs:143
+   message convention). Expected counts per §Grammar prep. wasm recovery is
+   canonical for erroring files (incl. the cfxlua/`@native` dialect files).
+
+## Extractor config (languages/lua.ts — 152 lines; languages/luau.ts — 36 lines; read both whole)
+
+`luauExtractor = { ...luaExtractor, <4 overrides> }` (luau.ts:16-36).
+
+Shared types (lua.ts:62-81): functionTypes=[`function_declaration`] (covers
+global `function f`, `local function f`, table `function t.f`, method
+`function t:m` — ONE node type, form distinguished by the `name:` child;
+anonymous `function() end` is `function_definition`, NOT in the list);
+classTypes=[] ; methodTypes=[] ; interfaceTypes=[]; structTypes=[];
+enumTypes=[]; importTypes=[] (`require` is a function_call — the hook);
+callTypes=[`function_call`]; variableTypes=[`variable_declaration`];
+nameField=`name`, bodyField=`body`, paramsField=`parameters`.
+
+Luau overrides (luau.ts:20-35): typeAliasTypes=[`type_definition`] (lua: []);
+**isExported** = `source.slice(node.startIndex, node.startIndex + 7) ===
+'export '` (raw UTF-16 slice of the node's own first 7 chars — `export type X`
+nodes START at `export`, probed); **getSignature** = params text + `: <text of
+the named child AFTER parameters>` unless that child's type is `block`
+(finds params by `startIndex` match in `namedChildren`, so a leading
+`generic_type_list` never disturbs it — probed `(v: T): T`).
+
+Hooks PRESENT (port each exactly):
+
+- **visitNode (lua.ts:105-151)** — the require machinery, §Require hook.
+- **getSignature (lua.ts:83-86)** — lua: `getChildByField(node,
+  'parameters')` text or undefined. Probed: `(a, b)`, `(...)`, `()`.
+  (Luau override above; both read the REAL `parameters` field —
+  FIELD_COUNT is non-zero here, unlike kotlin: field lookups are LIVE.)
+- **getReceiverType (lua.ts:92-99)** — `name:` field child of type
+  `dot_index_expression` → its `table:` field text; `method_index_expression`
+  → its `table:` field text; else undefined. The table text is VERBATIM
+  dotted source: `function M.sub.deep:chained()` → receiver `M.sub.deep`
+  (probed). Plain `function f` / `local function f` (name is `identifier`) →
+  undefined.
+
+Hooks ABSENT (the walker must NOT invent them): `preParse`, `resolveName`,
+`recoverMangledName`, `isMisparsedFunction`, `isConst` (**every
+lua/luau variable is kind `variable` — `constant` never occurs**),
+`isAsync`/`isStatic` (**both undefined on every node** — flag present-bits
+stay 0; NOT kotlin's literal false), `getVisibility` (undefined — visibility
+byte 0), `getReturnType` (**returnType never set** — luau return types ride
+the SIGNATURE string only), `extractModifiers` (no decorators ever),
+`classifyClassNode`, `classifyMethodNode`, `extractPropertyName`,
+`propertyTypes`, `fieldTypes`, `enumMemberTypes`, `extraClassNodeTypes`,
+`packageTypes`/`extractPackage` (**no namespace node, ever** — QNs never get
+a package prefix), `resolveBody` (**body = `getChildByField(node, 'body')`
+only**; empty one-liner `function f() end` has NO body field — probed
+`field-truth.out` — so no body walk and no endLine extension; the
+createNode:1329-1334 extension is structurally a no-op since
+function_declaration's extent includes `end`), `extractImport`,
+`extractBareCall`, `synthesizeMembers`, `skipBodilessClass`,
+`methodsAreTopLevel`, `resolveTypeAliasKind`, `interfaceKind`,
+`isExported` for LUA (undefined — see the wire note in §Parity mechanics).
+
+## tree-sitter.ts branches (anchors as of `45a53eb`)
+
+### visitNode dispatch — what each lua/luau node hits (ladder at 936-1303)
+
+| Node | Branch | Behavior |
+|---|---|---|
+| every node | visitNode hook first (943-953) | `function_call` that IS a require → import + ref, handled=true → `scanFnRefSubtree` + STOP; non-require function_call → false, falls to :1248; `variable_declaration` → emits imports for require initializers, ALWAYS returns false (falls through to variableTypes) |
+| every node | maybeCaptureFnRefs (990) | fires for `arguments` / `assignment_statement` / `field` (LUA_SPEC keys) — top-level table registries and call args captured here |
+| `function_declaration` | functionTypes:994 | `isInsideClassLikeNode()` is ALWAYS false (no class-like kinds exist; :1486-1500 checks the STACK TOP only, and lua mints only file/function/method/variable/import/type_alias) → extractFunction:1517, whose :1522 receiver short-circuit diverts `function t.f`/`t:m` to extractMethod:1737. skipChildren |
+| `variable_declaration` | variableTypes:1098 | gate `!isInsideClassLikeNode() ∥ isClassScopeConstantAssignment` — always passes (first leg). extractVariable:2538 → lua branch :2789. Then `scanFnRefSubtree(node, 0)` (:1110) + skipChildren → **initializer subtrees are NEVER walked** (§extractVariable) |
+| `type_definition` (luau) | typeAliasTypes:1071 | extractTypeAlias:2890 → plain path :2967 (no resolveTypeAliasKind) → **returns false → children ARE re-visited** — how `typeof(require(...))` aliases emit an import (§Luau type aliases). Lua: no branch → recursed |
+| `function_call` (hook-declined) | callTypes:1248 | extractCall:3684. NO skipChildren → children recursed → nested/inner calls each get their own ref (glued chains, `f()()`) |
+| `assignment_statement` (top level) | **no branch** | maybeCaptureFnRefs('assignment_statement') → RHS candidates; then plain recursion → initializer calls DO emit (`globalAssign = topFn(10)` → calls topFn — pinned), anon `function_definition` RHS bodies are walked with the FILE as caller |
+| `update_statement` (luau `+=`) | **no branch, no dispatch key** | recursed → RHS calls emit; no fn-ref capture (dispatch has no update_statement key) |
+| `return_statement` / `if_statement` / `for_statement` / `while_statement` / `do_statement` (top level) | no branch | recursed → nested variable_declarations/function_calls dispatch normally — **top-level conditional requires become imports; block-locals become top-level variable nodes** (pinned `extract-condreq`: `if ok then local m = require("in.if") end` → import in.if + variable m, both contained by FILE) |
+| `comment` | no branch | recursed into `content:` — nothing matches. Consumed only by getPrecedingDocstring |
+| `hash_bang_line` (`#!` line 1, lua) | no branch | parses clean (probed); not a comment kind → BREAKS a docstring chain scanning past it |
+| INSTANTIATION_KINDS (354-361) / `impl_item`:1274 / `property_signature`:1282 / export_statement:1219 / swift property:1121 | never | no lua/luau node kinds among them. **Zero `instantiates` refs, ever** |
+
+### The require hook (lua.ts:105-151 + requireModule :28-60) — port verbatim
+
+`requireModule(callNode)`: `name:` field child must be type `identifier` with
+text exactly `require` (a dotted callee is dot/method_index — never require);
+`arguments:` field child required. Then, in ORDER:
+
+1. **String win, breadth-first**: `findDescendant(args, 'string_content')`
+   (BFS over namedChildren, lua.ts:9-17) → trimmed text. This catches plain
+   `require("a.b")`, single-quote and `[[...]]` requires (string_content is
+   inside the string node), **and any require whose argument merely CONTAINS
+   a string anywhere** — pinned: `require(script:WaitForChild("Kid"))` →
+   import **"Kid"** (the string beats the method-index path);
+   `require("a" .. "b")` → import **"a"** (first string_content in BFS
+   order — deterministic garbage, preserve).
+2. Fallback `findDescendant(args, 'string')` with manual `[[ ]]`/quote
+   stripping (reached only if a string node had no content child — empty
+   string `require("")` → mod falsy → null).
+3. **Roblox instance path**: first descendant `dot_index_expression` (else
+   `method_index_expression`) → its `field:` (else `method:`) child text —
+   `require(script.Parent.Signal)` → **"Signal"** (the trailing segment).
+4. Otherwise null (`require(dynName)`, `require()`).
+
+Hook dispatch (lua.ts:129-150):
+
+- `node.type === 'function_call'`: requireModule ≠ null → `emit(node)` +
+  **return true** (claimed — never double-counted as a call); null → return
+  false → extractCall emits **`calls "require"`** (pinned:
+  `require(dynamicTop)` at top level → calls require from FILE).
+- `node.type === 'variable_declaration'`: find the `assignment_statement`
+  child → its `expression_list` → for EVERY child of type `function_call`,
+  `emit(val)` (multi-require `local a, b = require("x"), require("y")` → two
+  imports — pinned). **Always returns false** → extractVariable also runs.
+  NOT emitted from here: requires nested deeper in the initializer
+  (`{ mod = require("t") }` table value — pinned NO import), and
+  `require("m").field` (the exprList child is dot_index_expression — pinned
+  NO import; the `accessed` variable still mints).
+- `emit(callNode)`: `ctx.createNode('import', mod, callNode, { signature:
+  getNodeText(callNode).trim().slice(0, 100) })` — import node **positioned
+  at the CALL node** (name = module string, qualifiedName = same via
+  buildQualifiedName, id line = call's line) — then, if the stack is
+  non-empty, `addUnresolvedReference({ fromNodeId: stack top (always the
+  FILE node), referenceName: mod, referenceKind: 'imports', line: call
+  startRow+1, column: call startColumn })`. No filePath on the ref.
+- **The hook NEVER runs inside function bodies** (visitFunctionBody has no
+  hook call — §visitFunctionBody): body-level `local lazy =
+  require("app.lazy")` emits **`calls "require"` from the enclosing
+  function** and NO import (pinned, `extract-bodies-lua.txt` L8-9 — the
+  neovim lazy-loading idiom lands here). Port this asymmetry exactly.
+
+### Node creation, IDs, qualified names
+
+- createNode (1308): id = `generateNodeId(filePath, kind, name, startRow+1)`
+  = `` `${kind}:${sha256(`${filePath}:${kind}:${name}:${line}`).hex.slice(0,32)}` ``
+  (tree-sitter-helpers.ts:18-30). FILE node id = literal `file:${filePath}`
+  (:509), name = basename, qualifiedName = filePath, endLine =
+  `source.split('\n').length`, isExported false.
+- **No namespace node** (no packageTypes → extractFilePackage:1397 returns
+  null). buildQualifiedName (1447-1460) joins the NON-file stack nodes' NAMES
+  with `::` — top-level symbols get bare QNs.
+- **Receiver-QN override**: table/method functions get `extraProps.
+  qualifiedName = composeReceiverQualifiedName(receiver, name)` (1790-1792) =
+  `` `${receiverType}::${name}` `` verbatim (1435-1442; namespacePrefix
+  always empty outside C++). Pinned QNs: `M::create`, `M.sub.deep::chained`,
+  `_G::installed` (yes — `function _G.installed()` mints method
+  `_G::installed`). The override REPLACES the stack QN even for nested
+  declarations: `function M.attached()` inside a body → `M::attached`, NOT
+  `render::attached` (pinned).
+- **Nested plain functions** get stack QNs from node NAMES: `local function
+  inner()` inside `M:render` → `render::inner` (the method's NAME, not its
+  `M::render` QN — buildQualifiedName reads `node.name`); a GLOBAL
+  `function leakedGlobal()` declared inside a body is still stack-scoped →
+  `render::leakedGlobal` (pinned — quirk, preserve).
+- **Variable nodes are positioned at the IDENTIFIER**, not the declaration
+  (§extractVariable) — id line/column = the identifier's.
+- contains edge from stack top for every created node (1363);
+  extractModifiers merge (1355-1358) inert (no hook); captureValueRefScope
+  (1374) runs but its output is discarded (§Dead machinery).
+- **Duplicate IDs are legal output**: `local x = 1; local x = 2` on one line
+  → two `variable:x` rows with the SAME id (pinned, mini-probes
+  `sameLineTwoLocals`) — minified/one-liner lua bundles hit this routinely.
+  The walker emits both rows verbatim (`node_ids` vec pattern; store upsert
+  handles collapse — parity compares pre-store output).
+
+### extractFunction (1517) / extractMethod (1737)
+
+- extractFunction: **:1522 receiver short-circuit is THE routing** —
+  getReceiverType ≠ undefined (name is dot/method_index_expression) →
+  extractMethod. extractName (:97-192): nameField `name` field hit → :136-143
+  unwraps `dot_index_expression → field:` / `method_index_expression →
+  method:` → the trailing simple name (`dotted`, `method`, `chain`).
+  `<anonymous>` unreachable for function_declaration (grammar requires a
+  name; `function_definition` never reaches extractFunction — it's in no
+  type list).
+- Extras (:1574-1580): docstring (§Docstrings), signature (getSignature),
+  visibility undefined, **isExported: lua undefined / luau false** (hook
+  slice — a function_declaration never starts with `export `), isAsync
+  undefined, isStatic undefined, returnType undefined.
+  extractTypeAnnotations (:1594) → early-out (§Dead machinery);
+  extractDecoratorsFor (:1599) → scans children/preceding siblings for
+  decorator/annotation/attribute kinds — lua's `attribute` node (`<const>`)
+  lives inside variable_list, NEVER adjacent to a function → structurally
+  zero output (keep the traversal or early-out equivalently — output is
+  what's pinned).
+- Body: `resolveBody?.() ?? getChildByField(node, 'body')` → the `body:`
+  block (absent on empty one-liners) → visitFunctionBody with the node
+  pushed.
+- extractMethod: receiverType recomputed (1742); gate :1747 passes via
+  receiver. Same extras (NOTE: extractMethod passes NO isExported — **luau
+  METHODS have isExported undefined while luau functions have false**;
+  pinned in `extract-torture-luau.txt`: `method "make"` no flag,
+  `function "typedTop"` isExported=false). QN override :1790-1792.
+  **Owner-contains (:1799-1813) NEVER fires**: it requires an in-file node
+  named `receiverType` with kind ∈ {struct, class, enum, trait} — lua mints
+  none of those kinds, and dotted receivers (`M.sub.deep`) match no node
+  name anyway. The ONLY containment is the normal stack-top edge (pinned:
+  `contains file → method:dotted`, `contains method:render →
+  method:attached`).
+
+### extractVariable — the lua/luau branch (2538-2549 head; 2789-2805 branch)
+
+Head: isConst absent → kind ALWAYS `variable` (:2546-2547); docstring from
+the DECLARATION node (:2548); `isExported = hook ?? false` (:2549) → **false
+for both languages** (luau's slice sees `local …`).
+
+Branch (:2789-2805): `assign` = first namedChild of type
+`assignment_statement` ?? node itself (covers bare `local x` with no `=`);
+`varList` = assign's `variable_list` child; `exprList` = assign's
+`expression_list` child; `names` = varList's children of type `identifier`
+ONLY (a `dot_index_expression`/`bracket_index_expression` LHS — possible only
+in bare assignment_statements, which never reach here — and `attribute` nodes
+(`<const>`/`<close>`) are skipped without disturbing positions); `values` =
+exprList's namedChildren. Per name, **positionally paired**:
+
+- `createNode(kind, name, nameNode, …)` — **positioned at the IDENTIFIER**
+  (pinned: `variable "http" L2 C6-10`).
+- signature = `` `= ${valueText.slice(0,100)}${'...' if ≥100}` `` from
+  `values[i]`; **no value at that index → NO signature key at all** (pinned:
+  `local ok, err = pcall(...)` → `ok` has the signature, `err` has none).
+  Signatures keep raw bytes verbatim — embedded `\n` (`= [[long\nstring]]`),
+  CRLF `\r\n`, the full anon-function text (`= function(v)\n\treturn
+  hidden(v)\nend`).
+- docstring and isExported repeated onto EVERY name of the declaration.
+
+Then the ladder (:1110-1111) runs `scanFnRefSubtree` and sets skipChildren →
+**the initializer subtree is never walked**: `local fromCall = topFn(3, 4)`
+emits NO calls ref; `local anon = function(v) return hidden(v) end` emits no
+function node, no calls (pinned). Contrast the shapes that DO walk (no
+branch → recursion): top-level `x = topFn(10)` assignment → calls topFn;
+`M.assigned = function(z) return topFn(z) end` → calls topFn **from the
+FILE node** (pinned L68). In function BODIES both decl forms walk
+(§visitFunctionBody) — the asymmetry is top-level-only.
+
+### Luau type aliases — extractTypeAlias (2890; plain path :2967-2991)
+
+`type_definition` → extractName via the `name:` FIELD: a simple alias's name
+child is `identifier`; **a generic alias's name child is `generic_type` and
+the node NAME is its verbatim text — `Generic<T>`, `Map<K, V>` (spaces
+preserved, pinned)**. Extras: docstring (works — pinned "doc for Point"),
+isExported from the luau slice hook — **`export type` → true** (the
+type_definition node STARTS at `export`, CST-probed), else false. Then
+:2973's `TYPE_ANNOTATION_LANGUAGES.has('luau')` is FALSE → no alias-value
+refs (doubly dead: the `value` field is also NULL in this grammar —
+`field-truth.out`). **Returns false → the alias's children are RE-VISITED by
+the ladder**: a `typeof(require(...))` alias's function_call child hits the
+hook → **`type_alias` node + `import` node + imports ref, all three** (pinned:
+`FromTypeof` → type_alias L11 C0-55 + import "Config" L11 C25-54 + imports
+ref from FILE; the alias node is created FIRST). Body-local `type X = …`
+(legal luau) minted NOTHING — visitFunctionBody has no typeAlias branch
+(pinned `extract-bodies-luau.txt`). Lua: typeAliasTypes=[] — a stray
+`type X =` in a .lua file is a parse ERROR anyway (deferred).
+
+### extractCall (3684) — the raw-text callee world
+
+Entry: the vbnet (:3698), erlang (:3746), ruby (:3913), arkts (:3996)
+branches are language-gated off. Generic path :4312-4313: `func =
+getChildByField(node, 'function') ?? node.namedChild(0)` — **the `function`
+field is NULL in this grammar** (truth-tabled) → always namedChild(0), which
+is the `name:` child (identifier / dot_index / method_index /
+parenthesized_expression / function_call in chains).
+
+**The member branch (:4364) NEVER fires**: `dot_index_expression` and
+`method_index_expression` are NOT in the accepted type list
+(member_expression/attribute/selector_expression/navigation_expression/
+field_expression). LITERAL_RECEIVER_TYPES (:373-388), SKIP_RECEIVERS
+(:4400), and every re-encode are unreachable. Everything falls to the ELSE
+(:4518-4520): **calleeName = RAW SOURCE TEXT of the callee node** (UTF-16
+substring). Pinned shapes:
+
+- bare `topFn(5)` → `topFn`; sugar calls `require 'x'` / `f {t}` route the
+  same (arguments without parens).
+- dotted `M.create(2)` → `M.create`; deep `core.util.log("x")` →
+  `core.util.log`.
+- **colon methods keep the COLON**: `M:render({})` → `M:render`;
+  `M.sub.deep:chained(13)` → `M.sub.deep:chained`; in bodies `self:helperMethod(o)`
+  → `self:helperMethod`, `self.field.deep(1)` → `self.field.deep` — **`self`
+  is NEVER stripped** (no SKIP_RECEIVERS on this path). Resolution depends on
+  these exact bytes (§Resolution consumers).
+- **bracket calls**: `M.registry[key](3)` → `M.registry[key]`; `t2[k2](14)` →
+  `t2[k2]` (brackets verbatim).
+- **call-result callees**: `f2()(15)` → outer ref `f2()` + inner ref `f2`
+  (children recursed — every chain link emits).
+- **the newline-glue trap** (lua's statement ambiguity): a call statement
+  followed by a line starting `(` parses as ONE glued chain —
+  `obj:foo():bar()\n\t(helper)(4)` emits FOUR refs: `obj:foo():bar()\n\t(helper)`
+  (raw text with embedded newline/tab — byte-verbatim), `obj:foo():bar()`,
+  `obj:foo():bar`, `obj:foo` (pinned `extract-bodies-lua.txt` L19). Same
+  with `string.format("%d", 9)\n("literal"):upper()` → three refs
+  (`extract-shapes-lua.txt` L29). Reproduce byte-for-byte, including the
+  glued middle links whose "callee" is a whole inner function_call's text.
+- **paren-conversion regex (:4529-4532)**: `/^\(\s*\*?\s*([A-Za-z_][\w.]*)\s*\)$/`
+  applies — a clean single `(handler)(16)` statement (semicolon-separated or
+  first-in-body, un-glued) → callee text `(handler)` → rewritten **`handler`**
+  (pinned twice: torture paren_conv; mini-probes `parenFirst` `(cb)()` →
+  `cb`). A glued/quoted parenthesized callee (`("x"):upper` — pinned raw)
+  does NOT match. Port the regex with JS `\s` semantics (matches `\r`).
+- cpp template-strip (:4542-4548) and fn-ptr fan-out (:4556) are gated off.
+- Ref: {fromNodeId = stack top, referenceName, referenceKind 'calls', line =
+  call startRow+1, column = call startColumn (UTF-16)}.
+- Luau extra shapes, all pinned: interpolation calls emit in bodies
+  (`` `point {p.x} of {Config.total()}` `` → calls `Config.total` at the
+  inner call's position); if-expression arms (`if p.x > 0 then bump() else
+  drop()` → both); `v += grow()` → calls grow (update_statement recursed).
+
+### Docstrings (tree-sitter-helpers.ts:95-127) — LIVE, with byte-level quirks
+
+Both grammars have ONE comment kind, `comment` (line `--`, block `--[[ ]]`,
+LuaDoc `---`, directives `--!strict`) — `comment` IS in the accepted sibling
+set (:109-121) → docstrings work everywhere getPrecedingDocstring is called
+(functions, methods, variables — every name of a multi-name decl —, luau
+type aliases, imports never — the hook passes no docstring).
+DOCSTRING_WRAPPER_TYPES (:55-62) contains `variable_declaration` but the
+climb inspects PARENTS — a lua declaration's parent is chunk/block → no
+climb, no effect. cleanCommentMarkers (:77-90), per comment, then
+`.join('\n').trim()`:
+
+- `--[[ … ]]` / `--[==[ … ]==]` → the `--[`-open strip (:80,
+  `^--\[=*\[` + `\]=*\]$`) — pinned "Block comment doc\nspanning two lines",
+  "lvl".
+- line comments → `^--\s?` per line (:85). **LuaDoc `---` keeps a leading
+  `- `** (`--- Summary` → `- Summary`, pinned in both langs). **`--!strict`
+  becomes docstring text `!strict`** and JOINS the chain — pinned: torture
+  luau's `core` docstring is `"!strict\nheader comment for torture.luau"`.
+- **Comment runs chain across blank lines** (siblings skip whitespace);
+  the chain BREAKS at any non-comment named sibling — including line 1's
+  `hash_bang_line`, which simply terminates the scan (shebang + comment run
+  → run kept, pinned).
+- **CRLF bytes, pinned** (`extract-torture-crlf-lua.txt`): line-comment
+  docstrings are IDENTICAL to LF (each comment `.trim()`ed → `\r` gone,
+  joined with `\n`); **block-comment docstrings KEEP interior `\r\n`**
+  ("Block comment doc\r\nspanning two lines") — only the ends are trimmed.
+  Signatures keep raw `\r\n` too (`= function(v)\r\n\treturn …`). All `gm`
+  strips ride `js_multiline_strip` in docstring.rs (#1329) — the lua strips
+  (`lua_open`/`lua_close` :49-50, `dashes` :56) are **already in
+  docstring.rs** — call the shared module, port nothing.
+
+### Function-as-value capture (#756) — LUA_SPEC (function-ref.ts:322-330)
+
+idTypes = {`identifier`} (bare identifiers only — dotted values never
+qualify: `{ on_make = M.make }` captured NOTHING, pinned). dispatch:
+`arguments` → args; `assignment_statement` → rhs with NO field (RHS = LAST
+named child = the expression_list; the param-storage skip :435-443 reads
+namedChild(0) = the variable_list, takes its trailing identifier, and
+compares to the WHOLE rhs text — `M.cb = cb` skips (pinned, no candidate);
+multi-value RHS never matches); `field` → value via the `value:` field
+(**keyed AND positional table fields** — `{ k = v }` and `{ v1 }` both carry
+`value:`, truth-tabled). layers: `expression_list` → null (fan out). No
+special, no unwrap, no ungatedModes, no addressOfOnly.
+
+- Capture points: visitNode:990 (top-level call args + assignments + every
+  `field` node the ladder recurses through), visitFunctionBody:5137, and
+  scanFnRefSubtree (hook-consumed require calls + variable_declaration
+  subtrees). **scanFnRefSubtree's halt list (:606-614) does NOT include
+  `function_definition`** → the scan DESCENDS into anonymous-function
+  initializer bodies (depth cap 12), so args/fields inside them still
+  produce candidates attributed to the FILE.
+- Flush (:639-728): definedHere = same-file function/method NAMES;
+  importedNames — lua module paths are dotted, so QUALIFIED_IMPORT (:665)
+  contributes the LAST segment (`app.core` → `core`; `two.a` → `a`) and
+  SIMPLE_NAME passes Roblox leaves (`Signal`, `Child`) — pinned: `(helper)`
+  glue candidate flushed because import `helper` existed. No `this.`/`::`
+  shapes ever occur → the bare-name gate is the only live path. Dedupe
+  `${fromNodeId}|${name}` — first occurrence's position wins (pinned: three
+  `topFn` table-value candidates → ONE function_ref at the first's line).
+  Emitted refs: {referenceKind:'function_ref'} → wire code 200.
+- Pinned population (torture.lua): `pcall(topFn, 7, 8)` → topFn (args mode);
+  `{ on_start = topFn, on_stop = localFn }` + `{ cb = topFn, [1] = localFn,
+  nested = { deep_cb = topFn } }` → topFn + localFn once each (field mode +
+  dedupe); `skipped = missing` gated out; `M.cb = cb` skipped. Luau:
+  `{ plain = typedTop }` → typedTop; `M:update(…, print)` → print gated out
+  (not defined/imported).
+
+### visitFunctionBody (5129-5286) — the body walker rows
+
+- maybeCaptureFnRefs (5137) per node. **No visitNode hook** → the require
+  asymmetry (§Require hook).
+- `function_call` ∈ callTypes → extractCall (5143); no return → children
+  recursed (chains emit every link).
+- INSTANTIATION_KINDS (5145) never; extractBareCall (5159) absent;
+  cpp declaration/assignment branches (5184-5215) gated off.
+- extractStaticMemberRef (5218) — dead on entry (§Dead machinery).
+- `variable_declarator` type-annotation branch (5230) — no such node kind.
+- **Nested `function_declaration` (5245)** → extractName ≠ `<anonymous>`
+  always → extractFunction → receiver check: `local function inner` →
+  function under the enclosing symbol (`render::inner`); `function M.attached`
+  → extractMethod with QN `M::attached`; global `function leakedGlobal` →
+  function `render::leakedGlobal` (all pinned).
+- classTypes/structTypes/enumTypes/interfaceTypes (5255-5275) — all empty.
+- **`variable_declaration` in a body: NO branch** → plain recursion → the
+  initializer IS walked: body `local lazy = require("app.lazy")` → calls
+  require; body `local x = topFn(9)` → calls topFn — the INVERSE of top
+  level. No variable node minted for body locals (pinned).
+- **`type_definition` in a luau body: NO branch** → recursed → no alias
+  node; a typeof-require inside it would emit `calls require` (hook-less).
+- Everything else (if/while/repeat/for, return_statement, update_statement,
+  interpolation, cast_expression, parenthesized_expression) is transparent
+  recursion.
+
+### Dead machinery — early-outs the walker must reproduce as SILENCE
+
+- **Value-reference edges**: `VALUE_REF_LANGS` (:401) has no lua/luau →
+  flushValueRefs (:777-784) discards everything captureValueRefScope
+  collected. **Zero `references` edges with `valueRef` metadata.** The
+  assignment shadow-prune (:803-878) never runs — its `assignment` case
+  (:829) is Python's node kind, not lua's `assignment_statement`, so even a
+  future opt-in would no-op. (Trap (a) from the survey brief: RESOLVED —
+  structurally dead.)
+- **Static-member refs**: STATIC_MEMBER_LANGS (:345-347) excludes lua/luau →
+  extractStaticMemberRef (:4750-4751) returns on entry;
+  MEMBER_ACCESS_TYPES (:323-331) has no lua kinds anyway. Zero.
+- **Type-annotation refs**: TYPE_ANNOTATION_LANGUAGES (:5752-5754) excludes
+  lua/luau → extractTypeAnnotations (:5788-5790) early-outs; luau parameter
+  types (`parameter > identifier + type` — a node shape lua lacks: lua
+  params are bare `name: identifier` children) and return types emit
+  NOTHING; type_alias values emit nothing (§Luau type aliases). Zero
+  `references` refs of any type-flavored kind.
+- **Instantiates**: INSTANTIATION_KINDS has no lua kinds; the ladder and
+  body walker never call extractInstantiation (:4610). Constructor-ish
+  calls (`setmetatable`, `M.create(2)`) are plain `calls`.
+- **Inheritance**: extractClass/extractInterface/extractEnum unreachable
+  (empty type lists) → extractInheritance (:5291) never runs. `setmetatable`
+  metatable-class patterns emit ONLY the calls ref — **no class synthesis,
+  no extends** (pinned: `M.create`'s body → calls setmetatable, nothing
+  else).
+- **Decorates**: extractDecoratorsFor (:4897-5024) runs for every
+  function/method but no decorator/annotation/attribute node kind ever
+  appears in the positions it scans (lua's `attribute` = `<const>`/`<close>`
+  lives inside variable_list — pinned: `local x <const> = 99` extracts
+  variable x, signature `= 99`, no ref; luau's real `@native`/`@checked`
+  attributes are grammar ERRORS → deferred files). Zero `decorates` refs.
+- **file-level `errors`**: none on clean parses (wasm-arm hasError files add
+  their own — kernel defers those wholesale).
+
+## Resolution consumers (TS-side, no port — but they pin the walker's BYTES)
+
+- **`resolveLuaRequire` (import-resolver.ts:1637-1671, dispatch :1450-1457)**
+  resolves each `imports` ref by treating the referenceName as a dotted path
+  (`telescope.config` → `telescope/config.lua`) or Roblox leaf (`Signal` →
+  `Signal.luau`), trying `<p>.lua|.luau|/init.lua|/init.luau` as PATH
+  SUFFIXES, longest-shared-prefix-with-the-requiring-file wins, →
+  file-node target at confidence 0.9. Walker obligation: referenceName =
+  the module string/leaf VERBATIM (dots intact, no normalization).
+- **Lua colon-method resolution**: extraction emits `lg:log`-shaped calls;
+  name-matcher's `luaColonMatch` (:1514-1520, `/^([\w.]+):(\w+)$/`) splits
+  them for local-variable receiver-type inference (#1108), whose lua
+  patterns (:1218-1234) include the **#1124 lookahead** — the third pattern
+  `\b<r>\b\s*:\s*([A-Z][\w.]*)(?![\w.]|\s*[({"'\[])` rejects PascalCase
+  METHOD CALLS (`lg:Log()`, the Roblox convention) as fake "type
+  annotations" because Lua's call syntax is the identical `receiver:Name`
+  shape. The pre-filter (resolution/index.ts:722-736) keeps single-`:` refs
+  alive when either side (or the capitalized receiver) names a known symbol.
+  Walker obligation: the SINGLE-COLON byte shape (and `[\w.]`-only
+  receivers — brackets/glue garbage simply never resolves).
+- Nothing else consumes lua/luau specially (no framework resolvers, no
+  synthesizers — §arch-3).
+
+## Parity mechanics (all have bitten before)
+
+- **Emission order** per construct, pinned across all dumps: file node →
+  source-order walk. Per require-decl: import node → imports ref happens
+  inside the hook, THEN extractVariable's variable nodes (`import:two.a`,
+  `import:two.b`, `variable:twoA`, `variable:twoB` — hook loop completes
+  first). Contains edges interleave with creation (createNode). Walk-order
+  refs (imports + calls interleaved by source position), then function_ref
+  refs at flush (:538). No value-ref edges. Store/harness are
+  rowid-order-sensitive — reproduce exactly.
+- **Wire flags (layout.ts:100-106 bit pairs)**: lua function/method/import/
+  type_alias-less world — the ONLY flag ever set for lua is variable
+  `isExported=false` (present=1, value=0). Luau ADDITIONALLY sets
+  isExported on **functions** (false) and **type_aliases** (true for
+  `export type`, false otherwise) — but NOT on methods (extractMethod
+  passes none). lua functions: present-bit 0 (undefined). Get the
+  present-vs-value distinction byte-right; it is the one lua↔luau
+  node-payload divergence besides signatures/typeAliases.
+- **visibility byte 0 everywhere; returnType/decorators/typeParameters
+  absent everywhere.**
+- **UTF-16 columns/slices** (textutil::col16/slice_utf16): every position
+  and every getNodeText (callee raw text, signatures, docstring sources,
+  import signatures + `.trim()`). Pinned: `local préfixe` → C6-13 (7 UTF-16
+  units).
+- **CRLF**: §Docstrings byte pins; callee raw text and signatures carry
+  `\r\n` verbatim; the paren-conversion regex's `\s*` eats `\r` (JS ⊇ Rust
+  `\s` — parity holds). CRLF fixture variants derived in-memory
+  (kernel-tsjs-parity pattern).
+- **Defer policy**: `has_error()` → `defer:` (no phantom class observed —
+  but trust the flag anyway, never node-scan). Deferral expectations §arch-7.
+- **generateNodeId inputs**: variables hash the IDENTIFIER's line; imports
+  the CALL's line; functions/methods the declaration's line; luau
+  type_aliases the type_definition's line (starts at `export` when
+  exported). Duplicate-id rows are emitted, not deduped.
+
+## Gates (per plan §5 — NO standalone bump gate; grammar-parity rows instead)
+
+- **Stage 0 (with or before the walker):** kernel C vendor
+  (grammars/lua, shas above) + build.rs block + langs.rs entries (+ crate
+  pin tree-sitter-luau "=1.2.0") + `GRAMMAR_LANGUAGES += 'lua','luau'` in
+  kernel-grammar-parity — proves C/crate ≡ vendored wasm revision (ABI 15 /
+  ABI 14, kind+field tables id-by-id). No dump-diff needed: the wasm arm is
+  untouched.
+- **Torture fixtures** per §Fixtures below, in a new
+  `__tests__/kernel-lua-parity.test.ts` (or kernel-lua-luau-parity) with
+  CRLF variants; full suite ×2 green with `CODEGRAPH_KERNEL_EXPECT=1`.
+- **Parity sweeps** (`scripts/kernel-parity.mjs <dir>`, default
+  `--max-deferral 0.1`):
+  - `…/svy-lua/gate-repos/kong` (large lua, 1,309 files — expect ≤1 deferral:
+    the invalid fixture)
+  - `…/gate-repos/lazy.nvim` (small lua, 65 — expect 0)
+  - `…/gate-repos/lua-resty-core` (small lua, 38, LuaJIT/OpenResty idioms —
+    expect 0)
+  - `…/gate-repos/lune` (luau, 221 — expect ~3 deferrals)
+  - `…/gate-repos/Fusion` (luau, 113, heavily typed — expect ~8 deferrals)
+  - luau-lang/luau tests/ + StyLua tests/ as OPTIONAL stress arms only
+    (deliberate-error corpora — run with `--max-deferral 0.3`/`0.5`, judge
+    only the non-deferred parity).
+  (Re-clone public OSS fresh if the scratchpad is gone — agent-eval policy.)
+  Then **full-init dump-diffs byte-identical** (kernel arm vs
+  `CODEGRAPH_KERNEL=0`, `scripts/dump-graph.mjs`, cmp) on kong + lazy.nvim +
+  lune + Fusion.
+- **`DEFAULT_ROUTED += 'lua', 'luau'`** (kernel/index.ts:37) only after all
+  of the above; changelog rides the existing kernel entry.
+
+## Fixtures to build
+
+1. `torture.lua` (survey seed + pinned dump `extract-torture-lua.txt` —
+   99 lines, parse-clean). Inventory: shebang + comment-run docstring;
+   require forms — double-quote, Roblox instance path, single-quote,
+   `[[ ]]`, `script:WaitForChild("Child")` (string-wins), `.field`-access
+   (NO import), dynamic (NO import), two-in-one-decl (order), pcall-require
+   (nothing); LuaDoc `---` (leading `- ` quirk); block-comment doc;
+   variable-with-invisible-anon-initializer; `function t.f`/`t:m`/
+   `a.b.c:m`/`_G.f` receiver QNs; body: require→calls-require, self-colon
+   and self-dot calls, bracket-callee calls, dotted-deep calls, nested
+   local/receiver/global functions (QN quirks), `M.assigned = function`
+   (file-attributed body calls); table fn-ref registries incl. positional
+   `[1] =` keys + nested tables + dedupe + `missing` gate-out + `M.cb = cb`
+   param-storage skip; global-assignment call visibility vs local-decl
+   invisibility; call shapes — bare/dotted/colon/bracket/`f2()()`/
+   `(handler)(16)` conv-rewrite (the survey torture keeps every statement
+   un-glued — verified: each L77-83 call emits its own single-line ref; the
+   newline-GLUE chain is pinned separately, fixture 5); bare `local x` (no
+   signature key — probed `barelocal.lua`); one-line multi-statement
+   (`local one = 1 local two = 2 print(...)`); long strings incl. `]==]`;
+   `<const>` attribute; non-ASCII line + following symbol (UTF-16 columns);
+   goto/label; `return M`.
+2. `torture.luau` (seed + `extract-torture-luau.txt` — 62 lines,
+   parse-clean): `--!strict` docstring-joining; requires (string + Roblox);
+   type aliases — plain (doc), `export type` (isExported=true, LuaDoc),
+   generic (`Generic<T>` verbatim name), `typeof(require(...))`
+   (alias+import pair); typed/generic/multi-ret/empty-one-liner function
+   signatures; typed methods (no isExported); body: type-in-body (nothing),
+   require→calls, interpolation call, if-expr arms, `+=` RHS call, cast,
+   `continue`; registry table (dotted value dropped, bare captured);
+   unicode line.
+3. **CRLF variants of both** derived in-memory (kernel-tsjs-parity
+   pattern) — pin the block-comment `\r\n` docstring byte and CRLF
+   signatures.
+4. **Defer fixtures**: one lua file with luau syntax (`x += 1`) and one
+   luau file with a default type param (`type S<T = U> = {}`) — kernel
+   `defer:`s, wasm-arm output asserted as-is (partial extraction).
+5. **Glue fixture** (if not folded into torture.lua): call statement +
+   next-line `(`-open statement → the 3-4-ref garbage chain, byte-pinned.
+6. **Duplicate-id fixture**: `local x = 1; local x = 2` one-liner (two
+   identical-id variable rows).
+
+## Probe artifacts (session scratchpad `svy-lua/`)
+
+`cst-dump.cjs` (CST dumps with fieldNameForNamedChild labels; `--all` mode
+walks anon children via cursor) + `cst-shapes-{lua,luau}.txt`;
+`field-truth.cjs` + `field-truth.out` (childForFieldName truth table — the
+NULL `function` field, name/table/field/method/parameters/body fields, luau
+generic_type name, positional-field `value:`); `extract-probe.cjs` (runs the
+REAL dist TreeSitterExtractor; prints nodes/edges/refs in emission order with
+every wire-relevant field) + ground truths `extract-shapes-lua.txt`,
+`extract-shapes-luau.txt`, `extract-bodies-{lua,luau}.txt`,
+`extract-requires-lua.txt`, `extract-condreq` (inline),
+`extract-torture-{lua,luau}.txt`, `extract-torture-crlf-{lua,luau}.txt`;
+`mini-probes.cjs` + `mini-probes-{lua,luau}.out` (31 snippet probes:
+one-liners, same-line duplicate ids, long strings/comments, LuaDoc, shebang,
+goto, paren-callee conv, bracket/call-call/paren-string callees, numeric/
+generic for, varargs, CRLF, integer-div/bitops, cross-dialect rejects,
+unicode, luau type/interp/continue/compound/if-expr/cast/directive/
+`@native`-reject probes); `errclass{1-4}.luau` (error classification);
+`error-sweep.cjs` + `errors-{lua,luau}.txt` (per-repo incidence + phantom
+scan); fixtures `shapes.lua`, `shapes.luau`, `bodies.lua`, `bodies.luau`,
+`requires.lua`, `condreq.lua`, `sigs.luau`, `generic.luau`,
+`torture.{lua,luau}` + CRLF twins; `grammar/` — `tree-sitter-lua` (v0.4.1
+tag clone), `tree-sitter-luau` (v1.2.0 tag clone), `luau-crate/`
+(crates.io 1.2.0 tarball, sha-matched), shas in §Grammar prep;
+`gate-repos/` — kong, lazy.nvim, lua-resty-core, StyLua, luau, Fusion, lune
+(shallow clones). Scratch dirs are throwaway — re-derive from this doc if
+gone.

docs/design/rust-kernel-migration-plan.md

@@ -609,7 +609,8 @@ parity before porting the language.
 | csharp | `languages/csharp.ts` | T1 | crates.io | **DONE (R7b #2, 2026-07-20)** — `csharp.rs` walker; NO grammar bump (the #717 vendored wasm verified table-identical to crate 0.23.5 — first port with no grammar-prep step); the #237 `#if` preParse stays TS-side via the route-point hoist. Parity 0-diff on serilog/Newtonsoft.Json/jellyfin (3,229 files) + dump byte-identical ×3; deferral 0.05–3.3% = both-arm `#if` damage. Quirk list: docs/design/csharp-kernel-port-checklist.md. | ☑ |
 | rust | `languages/rust.ts` | T1 | crates.io | **DONE (R7b #1, 2026-07-20)** — `rustlang.rs` walker; grammar bumped to v0.24.2 (crate + vendored wasm together). Parity 0-diff on ripgrep/tokio/rust-analyzer + dump byte-identical ×3; rust-analyzer's parser crates defer 18% (token-macro tables, both-arm parse errors — grammar-inherent). Quirk list: docs/design/rust-lang-kernel-port-checklist.md. | ☑ |
 | r | `languages/r.ts` | T1 | crates.io | **DONE (R7b batch 4 #1, 2026-07-20)** — `rlang.rs` walker; NO grammar change (crate pin `=1.2.0`: the crates.io tarball ships parser.c AND scanner.c sha-identical to the r-lib v1.2.0 tag the vendored wasm was built from — first true no-op grammar prep). The lightest-shared-surface, heaviest-hook port: r.ts works entirely through visitNode (every type list empty but `callTypes`), four shared machineries dead by language gates, walker = file node + hook transcription + generic extractCall. Parity 0-diff on AnomalyDetection/dplyr/ggplot2/shiny (838 files, deferrals 0/0/0/1 — the 1 = a moustache-template pseudo-R file, both-arm) + dump byte-identical ×3 (dplyr/ggplot2/shiny). kernel-parity.mjs gained lowercased-extension matching (`.R` is the dominant casing). Quirk list: docs/design/r-kernel-port-checklist.md. | ☑ |
-| dart, scala, lua, luau | dedicated files | T1 | dart/scala/lua: **vendored C** (revs not on crates.io — batch-4 probe); luau: crates.io `=1.2.0` | Long-tail T1, surveys COMPLETE 2026-07-20 (checklists in docs/design/). dart = tree-sitter-wasms artifact byte-copy re-vendor + UserNobody14 d4d8f3e vendored-C; scala = master 0aca5d0a6f vendored-C (35MB parser.c); lua+luau share one walker module. | ☐ |
+| lua, luau | `languages/lua.ts` + `luau.ts` (36-line extension) | T1 | lua: **vendored C** (v0.4.1 not on crates.io); luau: crates.io `=1.2.0` (tag≡crate sha-verified) | **DONE (R7b batch 4 #2, 2026-07-20)** — ONE walker (`lua.rs`, ccpp-style dialect flag); lua = the second vendored-grammar-C language (v0.4.1 tag artifacts, shas in the checklist); luau = plain crate pin. NO wasm change for either — grammar-parity rows replace the bump gate. Ports the require/visitNode-hook asymmetries (top-level imports vs body `calls "require"`), receiver-QN methods, the top-level initializer-visibility inversion, raw-text callee world (colon/bracket/glue chains, paren-conversion), LUA_SPEC fn-ref capture, LuaDoc `- `-keeping docstrings, and the lua↔luau isExported wire divergence. Parity 0-diff kong/lazy.nvim/lua-resty-core/lune/Fusion (1,734 clean files; deferrals 1/0/0/3/8 — every one matching the survey's both-arm predictions) + dump byte-identical ×4 (kong 157,650 dump lines). Quirk list: docs/design/lua-luau-kernel-port-checklist.md. | ☑ |
+| dart, scala | dedicated files | T1 | **vendored C** (revs not on crates.io — batch-4 probe) | Long-tail T1, surveys COMPLETE 2026-07-20 (checklists in docs/design/). dart = tree-sitter-wasms artifact byte-copy re-vendor + UserNobody14 d4d8f3e vendored-C (sibling-body double-walk is the port hazard); scala = master 0aca5d0a6f vendored-C (35MB parser.c; phantom-hasError dominant on scala-3). | ☐ |
 | kotlin | `languages/kotlin.ts` | T1½ | **vendored C** (crate unusable) | **DONE (R7b #6, 2026-07-20)** — `kotlin.rs` walker; the arc's FIRST vendored-grammar-C language: fwcd 0.3.8's sha-matched parser.c/scanner.c compile inside codegraph-kernel via build.rs + cc (the crates.io crate pins tree-sitter <0.23; tree-sitter-kotlin-ng is a different grammar). Behavior-neutral wasm re-vendor (dumps byte-identical old-vs-new ×3). Two walker firsts: extension-fn receiver QNs + owner-contains, and extractModifiers→decorators (KMP expect/actual — 412 synthesized edges identical both arms on kotlinx.coroutines). Parity 0-diff okio/okhttp/kotlinx.coroutines (1,861 clean files; deferral 4.7–8.5% both-arm incl. PHANTOM hasError files). Quirk list: docs/design/kotlin-kernel-port-checklist.md. | ☑ |
 | swift | shared + dedicated branch | T1½ | crates.io | **DONE (R7b #5, 2026-07-20)** — `swift.rs` walker incl. the #1020 dedicated property branch (Alamofire's 348 property nodes reproduced exactly on the kernel arm); grammar bumped to crate 0.7.3 (wasm built from the CRATE TARBALL's src — the tag ships an older ABI-14 generation; delta = error-set membership + 2 gate-found categories, all classified). Parity 0-diff Alamofire/vapor/swift-nio (720 clean files; deferral 9–27% both-arm structural — sweeps use --max-deferral 0.3). One walker fix found by the sweep: the shared `assignment` shadow-prune case is swift-live (declared-then-assigned `let X: T`). Quirk list: docs/design/swift-kernel-port-checklist.md. | ☑ |
 | c, cpp | `languages/c-cpp.ts` | **T2** | crates.io | **DONE (R7a, 2026-07-17)** — `ccpp/` walker; ALL pre-passes stayed TS-side via the route-point preParse hoist (+6 new blanks added during gating — see the checklist doc); content-based `.h` C-vs-C++ detection stays upstream at detectLanguage. Parity 0-diff + dump byte-identical on redis/git/fmt/protobuf/ALS. | ☑ |

scripts/kernel-parity.mjs

@@ -48,7 +48,7 @@ if (paths.length === 0) {
   process.exit(2);
 }
 
-const KERNEL_LANGS = new Set(['typescript', 'tsx', 'javascript', 'jsx', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php', 'swift', 'kotlin', 'r']);
+const KERNEL_LANGS = new Set(['typescript', 'tsx', 'javascript', 'jsx', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php', 'swift', 'kotlin', 'r', 'lua', 'luau']);
 const EXTS = new Map([
   ['.ts', 'typescript'], ['.mts', 'typescript'], ['.cts', 'typescript'],
   ['.tsx', 'tsx'], ['.js', 'javascript'], ['.mjs', 'javascript'],
@@ -65,6 +65,7 @@ const EXTS = new Map([
   ['.swift', 'swift'], // R7b
   ['.kt', 'kotlin'], ['.kts', 'kotlin'], // R7b
   ['.r', 'r'], // R7b batch 4 — real-world casing is `.R`; extname lowercased below
+  ['.lua', 'lua'], ['.luau', 'luau'], // R7b batch 4
 ]);
 
 /** Collect candidate files. */

src/extraction/kernel/index.ts

@@ -87,6 +87,13 @@ const DEFAULT_ROUTED: ReadonlySet<Language> = new Set<Language>([
   // moustache-template pseudo-R file, both-arm): any deferral on an R sweep
   // is a walker-bug signal, not grammar reality.
   'r',
+  // R7b batch 4 (2026-07-20): one walker, two dialects. Parity swept 0-diff
+  // on kong/lazy.nvim/lua-resty-core (lua) + lune/Fusion (luau) + full-init
+  // dump-diffs byte-identical. Lua error incidence ~0% (any deferral is a
+  // walker-bug signal); luau 1.4–7.1% both-arm grammar reality (generic type
+  // packs, default type params) — a JUMP past ~10% is the bug signal.
+  'lua',
+  'luau',
 ]);
 
 /**